Reading additional input from stdin... 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/memories] reasoning effort: medium reasoning summaries: none session id: 019e7fb5-8d94-75b0-8d84-13ece9b049c5 -------- 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_20260531_2024.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 campo vivo e il contesto del Lab prima di scegliere l’esperimento. Poi verifico lo stato del repo e scrivo un solo report nel path richiesto. exec /bin/bash -lc "sed -n '1,240p' 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. ## DIRETTIVA OPERATORE — override per questo cycle (one-shot) # Direttiva one-shot - Lab fisica D-ND / audit failure cache N=128 Fonte: TM7-vps, seconda cache row-aligned indipendente completata il 2026-05-29. Artefatti: - precedente N=8: `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` - indipendente N=128: `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` Risultato verificato: - N=8: 1 metadata, 432 cache rows, 1 summary; tutti i trial `27/27` in full-reader, centroid-only e kNN-only per logistica e percolation. - N=128: 1 metadata, 6912 cache rows, 1 summary. - logistica: observed baseline `26/27`; null cache N=128 ricostruisce quasi sempre `27/27`, ma non sempre: - full-reader `{26: 2, 27: 126}`; - centroid-only `{26: 1, 27: 127}`; - kNN-only `{26: 1, 27: 127}`. - percolation: observed baseline `27/27`; null cache N=128 non ricostruisce sempre `27/27`, soprattutto in full/centroid: - full-reader `{19: 1, 21: 1, 24: 2, 25: 2, 26: 3, 27: 119}`; - centroid-only `{19: 1, 21: 1, 24: 2, 25: 2, 26: 2, 27: 120}`; - kNN-only `{26: 1, 27: 127}`. Correzione di livello: - Non fissarsi sui singoli trial falliti come se fossero il punto. - Il punto generale e' la dinamica della combo: `fisica A -> null interno / lettore M -> robustezza contestuale -> possibile fisica B`. - Baseline originale: - logistica: full `26/27`, centroid `27/27`, kNN `26/27`; - percolation: full `27/27`, centroid `27/27`, kNN `27/27`. - Percolation null: - la riga surrogate ha sempre solo `178` gap disponibili; - le classi `n_gaps=512/1024/2048` cambiano soprattutto il denominatore degli altri domini, non la scala locale della riga percolation; - le failure full/centroid scompaiono quando il denominatore reader e' a `2048`, mentre kNN resta quasi sempre robusto. Compito del prossimo ciclo: 1. Audit macro della robustezza contestuale, non microscopia dei trial. 2. Separare logistica e percolation. 3. Per percolation, trattare i trial `14`, `34`, `68`, `80` come sonde della dinamica, non come oggetti finali. 4. Misurare se la differenza tra originale e null e': - invariance del target originale sotto denominatore variabile; - fragilita' del surrogate fisico-interno sotto denominatore povero; - recupero della combo quando il denominatore matura. 5. Solo se questa differenza resta dopo un secondo verifier, formulare una ipotesi fisica B; altrimenti classificarla come effetto di reader/contesto. Criterio di avanzamento: - posizione TM7 orientativa, non vincolante: - TM7 costruisce per il futuro del Lab, non solo per risolvere il presente; - se una mossa manuale scopre una funzione utile e ripetibile, la traiettoria preferita e' trasformarla in contratto/automazione del Lab (`tool_contract`, smoke, indice, output strutturato); - questa non e' una gabbia: se il movimento richiede esplorazione manuale, TM7 puo' continuare, ma deve riconoscere quando una funzione sta diventando organo futuro del Lab; - criterio pratico: esplorare quando il movimento non e' ancora formato; contrattualizzare quando il movimento diventa ripetibile. - il nodo non e' chiuso come "null interno ricostruisce sempre 27/27"; - il N=8 era troppo piccolo per vedere le code rare; - la mossa giusta e' salire alla dinamica scala/proiezione/denominatore, non scendere nei dettagli salvo come sonde; - verifier creativo percolation ladder N=64: - output: `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl`; - originale percolation: `54/54` in full, centroid e kNN su tutti i denominatori `128,256,512,1024,2048,4096`; - null percolation: full/centroid cedono solo nella banda intermedia `256/512/1024`, mentre `128/2048/4096` restano pieni; - questa e' una forma di zona intermedia operativa: non vertice puro, non centro trascendente, ma banda in cui il null perde la combo e l'originale la conserva; - secondo verifier banda N=96: - output: `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl`; - denominatori `192,256,384,512,768,1024,1536`; - originale percolation: `63/63` in full, centroid e kNN su tutta la banda; - null percolation: kNN `63/63` in 96/96 trial; full e centroid identici, con 88/96 trial pieni e collassi nella banda, piu' forti a `192` e `384`; - firma: full/centroid collassano insieme, kNN non collassa. Questo suggerisce una transazione di proiezione globale/centroide, non una rottura topologica locale del kNN. - ispezione margini/cross sulla banda N=96: - originale: margine centroide sempre `<0.25` (`63/63`) e cross-neighbor sempre `>0` (`63/63`); - null falliti: margine centroide sempre `>=0.25` (`0/73` sotto soglia), ma cross-neighbor sempre `>0` (`73/73`); - null riusciti campione: margine `<0.25` e cross `>0`; - quindi la firma e' precisa: la topologia locale resta convergente, la proiezione globale/centroide diventa non-convergente nella banda. - automazione interna avviata: - tool: `tools/exp_boundary_contextual_transaction_detector.py`; - report: `tools/data/boundary_contextual_transaction_detector_percolation_band_20260529.json`; - risultato sul verifier N=96: `73` transazioni `local=1,global=0` e `5975` righe `local=1,global=1`; - funzione: trasformare l'audit manuale convergente/non-convergente in check riusabile dal Lab, prima come post-process cache e poi come possibile gate interno se la logica viene confermata. - matrice di transizione aggiunta: - tool: `tools/exp_boundary_transition_matrix.py`; - report: `tools/data/boundary_transition_matrix_percolation_band_20260529.json`; - risultato: originale `local_global`; null `local_global` in `5975/6048` righe e `local_only` in `73/6048` righe (`1.207%`); - nessuno stato `global_only` o `neither`; - funzione: proiettare la risultante della transazione in una matrice leggibile e automatizzabile, senza promozione. - matrice di transizione estesa: - `tools/exp_boundary_transition_matrix.py` accetta ora `--reference-probe`; - la matrice ladder `tools/data/boundary_transition_matrix_percolation_ladder_20260529.json` contiene `reference_probe`; - campo aggiunto: `dominance_ratio = max/q90`, stato finale per variante, `candidate_recovery_dominance_ratio_min ~= 9.0`, `zero_base_dominance_ratio ~= 3.0`; - funzione: integrare la logica della transazione nel Lab come output strutturato, non come interpretazione lasciata in chat. - contratto Lab aggiunto: - file: `tools/data/tool_contracts/boundary_transaction_reference_probe_20260529.json`; - index: `tools/data/tool_contracts/index.json`; - smoke output: `tools/data/tool_contracts/runs/boundary_transaction_reference_probe_smoke_20260529.json`; - registry: `tools/lab_tool_contract.py` indicizza ora contratti generici tramite `--index-only`, non solo `component_state_spectrum_tester`; - scopo: evitare che TM7 faccia manualmente cio' che il Lab deve poter rifare; il movimento ora e' scopribile come tool contract interno. - secondo verifier indipendente, adapter Anderson: - tool: `tools/exp_boundary_anderson_transaction_adapter.py`; - report: `tools/data/boundary_anderson_transaction_adapter_20260529.json`; - input: audit esistente `tools/data/anderson3d_mobility_edge_two_reader_audit_20260515_1947.json`; - contratto locale/globale: - locale = `min_graph_bridge_frequency >= 0.75`; - globale = `classical_states_seen == ['classical_intermediate']`; - risultato: `local_global=1`, `local_only=3`, `global_only=4`, `neither=3`; - riga local_global piena: `Anderson3D_W_20.00`; - zona intermedia utile: `W=16.00` e `W=16.50` sono instabili/sensibili, non ancora forma chiusa; - interpretazione: la forma local/global della transazione trasferisce ad Anderson, ma il riferimento `max/q90` della percolation non va copiato. Per Anderson serve cercare il suo riferimento fisico interno, probabilmente nel rapporto tra stabilita' grafica, audit classico, IPR/entropia e W. - sonda riferimento latente Anderson: - tool: `tools/exp_boundary_anderson_latent_reference_probe.py`; - report: `tools/data/boundary_anderson_latent_reference_probe_20260529.json`; - input: stesso audit Anderson esistente, senza nuova simulazione; - assi candidati: - `graph_reference = graph_bridge_frequency * cross_neighbor_fraction / centroid_margin`; - `localization_load = mean_ipr / participation_entropy`; - `spectral_softening`; - `adjacent_midpoint_score`; - delta local_global meno focus instabile W16/W16.5: - `graph_reference +3.09106961`; - `localization_load +0.080113525`; - `spectral_softening +0.100458751`; - `adjacent_midpoint_score +0.15346875`; - lettura: W16 e W16.5 diventano local_global solo in una size ciascuno, mentre W20 resta local_global in entrambe. Il riferimento Anderson candidato e' co-stabilita' attraverso scala tra asse grafico e carico di localizzazione, non una copia del rapporto `max/q90`. - nota TQGE+R: non forzare gli enti principali come etichette chiuse. In dinamiche esotiche possono emergere enti relazionali nascosti; qui il candidato e' una relazione graph/localization, da trattare come `latent_reference_candidate_not_claim`. - misura tautologia/progresso: - tool: `tools/exp_boundary_evolution_measure.py`; - report: `tools/data/boundary_evolution_measure_20260529.json`; - risultato aggiornato dopo null co-stabilita': `tautology_risk=0.0`, `progress_score=0.857142857`, `evolutionary_verdict=evolves`; - correzione applicata: la misura non deve contare come "riuso" una stringa `max/q90` presente nel boundary testuale; deve guardare gli assi effettivi del probe Anderson; - criterio evolutivo: conta se c'e' trasferimento cross-dominio, coordinata nuova non copiata, contro-perimetro, contratto Lab e boundary non promozionale. - null co-stabilita' Anderson: - tool: `tools/exp_boundary_anderson_costability_null.py`; - report: `tools/data/boundary_anderson_costability_null_20260529.json`; - correzione: la prima versione usava solo le sei righe focus; ora il latent probe espone tutte le righe Anderson e il null lavora su tutte, preservando marginali per size e rompendo l'accoppiamento `graph_reference` / `localization_load`; - score: `rank_size(graph_reference) * rank_size(localization_load)`; - risultato: observed `all_row_separation=0.445`, `focus_separation=0.475`; null `all_row_add_one_p=0.142055162`, `focus_add_one_p=0.151818404`; - verdetto operativo: il candidato non e' semplice copia tautologica, ma non passa ancora il null relazionale a soglia `0.05`. Quindi e' progresso parziale/evolutivo, non promozione. Aggiornamento TM7 2026-05-29 post-report: - report giornaliero `20260529_0938` pubblicato/accettato localmente come `CONSTRAINT / NO PROMOTION`; - Anderson resta strumento discriminante, non teoria incorporata; - bicono resta utile come mappa di passaggio: nuove relazioni possono entrare come candidati di relazione, non come assiomi rigidi; - nuovo null/perturbazione fisica: `tools/exp_boundary_anderson_physical_perturbation_null.py`; - output: `tools/data/boundary_anderson_physical_perturbation_null_20260529.json`; - perturbazioni lanciate: - baseline Hamiltoniano Anderson; - hopping anisotropo `1.08,0.96,0.96`; 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. - **Prima impressione come condensato.** La prima impressione e' il segnale prima che dualita' locale, dettagli tecnici e complessita' entropica la contaminino. Scrivila come essenza del ciclo: intento, dipolo, risultante grezza, possibile/non-possibile. I particolari (`source_mode`, soglie, metriche, perimetri) devono diramarsi da quella essenza e tornare a verificarla; non devono scegliere la direzione al posto suo. - **Normalizzazione D-ND dei contesti scientifici.** Ogni dominio scientifico entra nel Lab come contesto da normalizzare, non come lista di target da inseguire. Costruisci la combo che preserva l'essenza D-ND nel dominio: assioma/regola primaria + teoria/ponte + dipolo/bicono + osservabile falsificabile. Se il dettaglio non serve questa combo, e' rumore o telemetria. - **Combo come contenitore del movimento.** La combo non e' una lista di ingredienti e non e' il target del ciclo. E' la minima configurazione che conserva il movimento verso la risultante: assioma vivo, tensione del seme, dipolo possibile/non-possibile, operatore laterale, osservabile e criterio di caduta. Deve dire cosa muove, cosa trattiene e cosa puo' decadere. Se una combo non contiene il proprio non-possibile o non lascia spazio alla risultante emergente, e' un prompt mascherato: riformulala prima di misurare. - **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-possibile/null. Non lasciare che il falsifier scopra il drift al posto tuo. - **Possibile / non-possibile atomico.** Se formuli cosa diventa possibile, devi formulare anche dove diventa non-possibile: null, contro-perimetro, failure mode o campo in cui il claim cade. Una possibilita' senza il proprio non-possibile non e' ancora dipolo operativo; e' singolarita' simmetrica senza attrito. Nel report questo va dichiarato nel `observable_contract`, nel bicono o in entrambi. - **Osservabili canonici e dedicati.** `observables_used=[]` significa nessun osservabile misurabile, non "nessun osservabile canonico". Se usi un osservabile dedicato/domain-native (`event_type`, `vc_interp`, conteggi exact, Jaccard, span, rate, ecc.), elencalo in `observables_used` e segnala che e' non-canonico. Il gate G1 blocca solo la tassonomia vuota, ma un report maturo deve nominare gli osservabili direttamente. - **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". - **Denominatori row-aligned.** Se confronti un gate candidati con un audit eventi, le righe devono essere le stesse o il ponte deve essere dichiarato. Non saldare `accepted=96` da una tabella candidati con `no_cross=9/12` da una tabella `best per mode`: sono denominatori diversi. Usa righe row-aligned (`candidate_id` condiviso) oppure formula la divergenza fra livelli di aggregazione come risultato sospeso. - **P-value definito prima dei risultati.** Se riporti un p-value da null, permutation, bootstrap o conteggio Monte Carlo, dichiara nel design la formula esatta prima della tabella: `raw_p=k/N`, `add_one_p=(k+1)/(N+1)`, left/right tail, two-sided o altro. Se usi una correzione, riporta anche i count grezzi che la generano. Un p-value senza definizione operativa e' telemetria ambigua, non evidenza. - **Null-first prima del nome candidato.** Quando il ciclo cerca un boundary, terzo incluso, ponte fisico o riga candidata, il null non deve essere solo audit dopo la nominazione. Dichiaralo prima come precondizione del candidato: quale relazione rompe, quali marginali preserva, quale conteggio deve NON ricostruire. Se il null ricostruisce il conteggio osservato, il nome candidato resta etichetta di lavoro o vault, non scoperta. - **Null comparabili o non confrontare.** Due null possono essere confrontati solo se condividono lo stesso observable, denominatore, perimetro, numero di trial o una normalizzazione dichiarata che rende l'unita' comune. Se cambi lettore, compressione, seed, spazio feature, trial count o source rows, il risultato ammesso e' `nulls_not_comparable:`, non "piu' restrittivo" o "piu' permissivo". Prima rendi comparabili i null; poi interpreta. - **Partizioni esaustive prima dei conteggi narrativi.** Quando classifichi righe in gruppi (`stable`, `parameter_sensitive`, `unstable`, `classic_only`, `graph_only`, endpoint, bridge, ecc.), dichiara se la lista e' una partizione completa o un sottoinsieme. Se il testo dice "le righe X sono ..." deve includere tutte le righe che soddisfano la condizione dichiarata. Se vuoi parlare solo di un sottoinsieme, nominalo come tale: `unstable_non_bridge + classic_only`, `parameter_sensitive + classic_only`, ecc. Il totale deve tornare al denominatore atomico prima del verdict. - **Residuo del seme quando restringi il perimetro.** Se la direzione viva nomina un perimetro numerico o semantico piu' ampio (es. `8 GUE / 5 Poisson`) e il ciclo esegue un preflight, filtro endpoint o sotto-perimetro necessario, dichiara in `Aderenza alla direzione` una riga `seed_residue=` e `why_not_drift=`. Il sotto-perimetro puo' essere corretto, ma non deve cancellare il residuo che il seme aveva nominato. - **Counter-perimeter deliberato.** Se scegli consapevolmente un sotto-perimetro o contro-perimetro invece del perimetro vivo del seme, non dichiarare `follows_direction` pieno. Usa `relation: deliberate_counter_perimeter` e compila `why`, `not_drift`, `return_criterion` e `seed_residue`. Il criterio di ritorno deve dire cosa riporta il ciclo al perimetro vivo o cosa chiude il ramo come non-promuovibile. Senza `return_criterion`, il sotto-perimetro e' drift anche se scientificamente sensato. - **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. - **Dominanza non e' invariante.** Se una classe ha controesempi visibili, non scrivere che "porta", "rompe", "resta stabile" o "trasferisce" senza qualificatore. Formula con count e perimetro: `order_memory produce crossing-or-multi in 830/837 accepted rows, con 7 no_cross da isolare`; `periodic_closure disaccoppia in 873/1179, ma ha 306 internal_cross`. I controesempi sono informazione, non rumore da arrotondare. - **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. - **Patch non e' invariante.** Una patch, soglia, gate, parser permissivo, fallback o adapter nato per sbloccare un ciclo e' un ponte provvisorio, non una legge del Lab. Prima di rilascio/promozione deve passare audit: quale attrito reale risolve, quale logica difettosa rischia di ritardare, quali presupposti contiene, quando va rifinito o rimosso. Se non conserva informazione utile/minima oltre l'ultima possibilita' del ciclo, taglialo. Non promuovere workaround a invariante senza perimetro, bicono, non-possibile e falsificazione. - **Regola operativa non e' assioma eterno.** Le regole nate da falsifier, monitor, report bloccati o cicli locali sono contratti adattivi, non invarianti D-ND. Devono dichiarare: `origin=`, `protects=`, `valid_until=`, `retire_when=`. Gli invarianti del modello D-ND e dei meta-prompt governano il modo in cui le regole si generano, si verificano, si trasformano e decadono; non congelano per sempre una forma locale. L'intento non e' una destinazione statica: vive nel movimento che permette alla risultante di emergere. Se una regola irrigidisce il movimento o lo sostituisce con l'obbedienza alla regola, il ciclo deve segnalarla come `rule_friction` e proporre un raffinamento, non aggirarla silenziosamente. - **Blocco come tensione autologica, non come fermo.** Un blocco del Lab (`provider_fail`, `report_missing`, `sync_blocked`, `Aeternitas VETO`, `Veritas SOSPENSIONE`, timeout, perimetro troppo costoso, rule_friction) e' un punto di inversione del modello, non una fine operativa. Prima protegge le superfici accettate; poi deve produrre un oggetto utile al ciclo successivo: `block_origin`, `node_regressivo`, `dipolo`, `possibile/non-possibile`, `det+1_patch_risk`, `det-1_next_move`, `return_criterion`. Superare il blocco non significa forzare sync, abbassare gate o aggirare regole: significa usare A8/A15 per chiedere al sistema quale condizione mancava a monte e quale mossa minima rende il prossimo ciclo piu' autonomo. Se il blocco resta solo log o quarantena, il Lab ha osservato ma non ha ancora metabolizzato. - **Null label-preserving non e' indipendenza.** Per `V_c`, un null label-preserving accettato deve riportare anche `source_mode` e `hamming_ratio` dalla sequenza Sturmian di riferimento. Se il null passa `Jaccard>=0.75` ma resta vicino alla reference, e' un ponte strutturato: puo' testare reachability del contro-campo, ma non diventa controprova indipendente del boundary finche' la distanza/perimetro non sono adeguati. - **Collasso minimo del ciclo.** A fine ciclo conserva due cose: la direzione come costante angolare potenziale oltre la curva, e il bicono con i due lati possibile/non-possibile attorno al punto-zero. Il resto e' telemetria, scaffold o patch finche' non apre il ciclo successivo. - **Dinamica fisico A -> matematica -> fisico B.** Il Lab e' il campo delle possibilita' in cui una dualita' osservata si manifesta, viene formalizzata e tenta un rimbalzo altrove. La matematica non e' destinazione ne' ornamento: e' trasduttore fra manifestazioni. Se il ciclo parte da un attrito fisico, deve estrarre una struttura formale e poi chiedere dove quella struttura puo' ri-manifestarsi, cadere o delimitare un non-possibile in un altro fenomeno, 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 docs/guides/lab_current_state_logic_2026-05-08.md M papers/paper_zero.md M tools/LAB_AGENT_CONTEXT.md M tools/build_agent_field.py M tools/build_lab_graph.py M tools/data/agent_field_live.md M tools/data/b2_apply_log.jsonl 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/domandatore_pre_cycle.json M tools/data/domande_fondamentali.json M tools/data/g1_log.jsonl M tools/data/g2_log.jsonl M tools/data/graph_completion/latest.json M tools/data/incrocio_risultato.json M tools/data/knowledge_state.json M tools/data/lab_bridge_issues.jsonl 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/repairs/repair_run_log.jsonl M tools/data/reports/latest.md 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 D tools/data/seme_archive/piano_9.json M tools/data/seme_backup_pre_run.json M tools/data/tm1_figures/tensions.json M tools/data/tm1_figures/tensions_raw.json M tools/data/valutatore_log.jsonl M tools/evolution_report.md M tools/exp_semireal_boundary_transfer_gate.py M tools/graph_completion_compiler.py M tools/lab_aeternitas.py M tools/lab_agent.sh M tools/lab_falsifier.py M tools/lab_session_logger.py ?? applications/scoperte/20260513_0330_prime-vs-mod6-sr-boundary_auto/ ?? applications/scoperte/20260514_1330_sr-residual-width-audit_auto/ ?? applications/scoperte/20260514_1631_chiusura-tester-rimbalzo-fisico-w6_auto/ ?? applications/scoperte/20260514_1640_rafforzamento-tester-fisico-goegue-n-curve_auto/ ?? applications/scoperte/20260515_1712_primemod6-generative-null-w2048_auto/ ?? applications/scoperte/20260515_1816_v2-generator-scaling-gate_auto/ ?? applications/scoperte/20260515_1904_boundary-classical-crossover-audit_auto/ ?? applications/scoperte/20260515_1933_rosenzweig-porter-physical-bridge-audit_auto/ ?? applications/scoperte/20260515_1940_rp-boundary-size-stability-audit_auto/ ?? applications/scoperte/20260515_1947_anderson-3d-mobility-edge-two-reader_auto/ ?? applications/scoperte/20260516_0921_rp-unfolding-sensitivity-audit_auto/ ?? applications/scoperte/20260516_0938_rp-candidate-local-window-stress-gate_auto/ ?? applications/scoperte/20260516_1007_rp-local-window-persistence-curve_auto/ ?? applications/scoperte/20260516_1019_rp-exact-local-window-size-stress_auto/ ?? applications/scoperte/20260516_1031_boundary-unfolding-transfer-matrix_auto/ ?? applications/scoperte/20260516_1104_endpoint-gated-rp-boundary_auto/ ?? applications/scoperte/20260516_1111_endpoint-gated-rp-size-ladder_auto/ ?? applications/scoperte/20260516_1117_anderson-3d-two-reader-boundary-null_auto/ ?? applications/scoperte/20260516_1135_anderson-comparable-null-audit_auto/ ?? applications/scoperte/20260516_1148_prime-bridge-label-null-audit_auto/ ?? applications/scoperte/20260516_1206_graph-only-residue-label-null-audit_auto/ ?? applications/scoperte/20260516_1230_graph-mechanism-ablation_auto/ ?? applications/soluzioni/20260513_0330_prime-vs-mod6-sr-boundary/ ?? applications/soluzioni/20260514_1330_sr-residual-width-audit/ ?? applications/soluzioni/20260514_1631_chiusura-tester-rimbalzo-fisico-w6/ ?? applications/soluzioni/20260514_1640_rafforzamento-tester-fisico-goegue-n-curve/ ?? applications/soluzioni/20260515_1712_primemod6-generative-null-w2048/ ?? applications/soluzioni/20260515_1816_v2-generator-scaling-gate/ ?? applications/soluzioni/20260515_1904_boundary-classical-crossover-audit/ ?? applications/soluzioni/20260515_1933_rosenzweig-porter-physical-bridge-audit/ ?? applications/soluzioni/20260515_1940_rp-boundary-size-stability-audit/ ?? applications/soluzioni/20260515_1947_anderson-3d-mobility-edge-two-reader/ ?? applications/soluzioni/20260516_0921_rp-unfolding-sensitivity-audit/ ?? applications/soluzioni/20260516_0938_rp-candidate-local-window-stress-gate/ ?? applications/soluzioni/20260516_1007_rp-local-window-persistence-curve/ ?? applications/soluzioni/20260516_1019_rp-exact-local-window-size-stress/ ?? applications/soluzioni/20260516_1031_boundary-unfolding-transfer-matrix/ ?? applications/soluzioni/20260516_1104_endpoint-gated-rp-boundary/ ?? applications/soluzioni/20260516_1111_endpoint-gated-rp-size-ladder/ ?? applications/soluzioni/20260516_1117_anderson-3d-two-reader-boundary-null/ ?? applications/soluzioni/20260516_1135_anderson-comparable-null-audit/ ?? applications/soluzioni/20260516_1148_prime-bridge-label-null-audit/ ?? applications/soluzioni/20260516_1206_graph-only-residue-label-null-audit/ ?? applications/soluzioni/20260516_1230_graph-mechanism-ablation/ ?? docs/guides/lab_preflight_agent_2026-05-14.md ?? docs/operations/ ?? tools/build_lab_data.py ?? tools/build_safe_agent_field_preview.py ?? tools/compose_filtered_field_preview.py ?? tools/compose_supervised_entry_preview.py ?? tools/data/aeternitas/aeternitas_20260512_033539.json ?? tools/data/aeternitas/aeternitas_20260513_033605.json ?? tools/data/aeternitas/aeternitas_20260514_033420.json ?? tools/data/aeternitas/aeternitas_20260514_133424.json ?? tools/data/aeternitas/aeternitas_20260514_150454.json ?? tools/data/aeternitas/aeternitas_20260514_161058.json ?? tools/data/aeternitas/aeternitas_20260514_161719.json ?? tools/data/aeternitas/aeternitas_20260514_163527.json ?? tools/data/aeternitas/aeternitas_20260514_164509.json ?? tools/data/aeternitas/aeternitas_20260514_165437.json ?? tools/data/aeternitas/aeternitas_20260514_170109.json ?? tools/data/aeternitas/aeternitas_20260514_171152.json ?? tools/data/aeternitas/aeternitas_20260514_185450.json ?? tools/data/aeternitas/aeternitas_20260515_162727.json ?? tools/data/aeternitas/aeternitas_20260515_165116.json ?? tools/data/aeternitas/aeternitas_20260515_170328.json ?? tools/data/aeternitas/aeternitas_20260515_171005.json ?? tools/data/aeternitas/aeternitas_20260515_171725.json ?? tools/data/aeternitas/aeternitas_20260515_172913.json ?? tools/data/aeternitas/aeternitas_20260515_174023.json ?? tools/data/aeternitas/aeternitas_20260515_175045.json ?? tools/data/aeternitas/aeternitas_20260515_180306.json ?? tools/data/aeternitas/aeternitas_20260515_181257.json ?? tools/data/aeternitas/aeternitas_20260515_182126.json ?? tools/data/aeternitas/aeternitas_20260515_183111.json ?? tools/data/aeternitas/aeternitas_20260515_190118.json ?? tools/data/aeternitas/aeternitas_20260515_191018.json ?? tools/data/aeternitas/aeternitas_20260515_192915.json ?? tools/data/aeternitas/aeternitas_20260515_193919.json ?? tools/data/aeternitas/aeternitas_20260515_194625.json ?? tools/data/aeternitas/aeternitas_20260515_195317.json ?? tools/data/aeternitas/aeternitas_20260516_033848.json ?? tools/data/aeternitas/aeternitas_20260516_0720.json ?? tools/data/aeternitas/aeternitas_20260516_0820.json ?? tools/data/aeternitas/aeternitas_20260516_0921.json ?? tools/data/aeternitas/aeternitas_20260516_0938.json ?? tools/data/aeternitas/aeternitas_20260516_1007.json ?? tools/data/aeternitas/aeternitas_20260516_1019.json ?? tools/data/aeternitas/aeternitas_20260516_1031.json ?? tools/data/aeternitas/aeternitas_20260516_1045.json ?? tools/data/aeternitas/aeternitas_20260516_1058.json ?? tools/data/aeternitas/aeternitas_20260516_1104.json ?? tools/data/aeternitas/aeternitas_20260516_1111.json ?? tools/data/aeternitas/aeternitas_20260516_1117.json ?? tools/data/aeternitas/aeternitas_20260516_1124.json ?? tools/data/aeternitas/aeternitas_20260516_1135.json ?? tools/data/aeternitas/aeternitas_20260516_1140.json ?? tools/data/aeternitas/aeternitas_20260516_1148.json ?? tools/data/aeternitas/aeternitas_20260516_1206.json ?? tools/data/aeternitas/aeternitas_20260516_1230.json ?? tools/data/aeternitas/aeternitas_20260528_2028.json ?? tools/data/aeternitas/aeternitas_20260528_2042.json ?? tools/data/aeternitas/aeternitas_20260528_2138.json ?? tools/data/aeternitas/aeternitas_20260528_2222.json ?? tools/data/aeternitas/aeternitas_20260529_0938.json ?? tools/data/agent_field_entry_supervised.md ?? tools/data/anderson3d_comparable_null_audit_20260516_1135.json ?? tools/data/anderson3d_component_state_interface_input_20260514_1850.json ?? tools/data/anderson3d_endpoint_preserving_null_20260516_1124.json ?? tools/data/anderson3d_mobility_edge_two_reader_audit_20260515_1947.json ?? tools/data/anderson3d_mobility_edge_two_reader_audit_20260516_1117.json ?? tools/data/anderson3d_mobility_edge_two_reader_audit_20260529_focused.json ?? tools/data/anderson3d_physical_perturbation_20260529_anisotropic_x.json ?? tools/data/anderson3d_physical_perturbation_20260529_baseline.json ?? tools/data/anderson3d_physical_perturbation_20260529_e2e_anisotropic_x.json ?? tools/data/anderson3d_physical_perturbation_20260529_e2e_baseline.json ?? tools/data/anderson3d_physical_perturbation_20260529_e2e_tilted_disorder.json ?? tools/data/anderson3d_physical_perturbation_20260529_tilted_disorder.json ?? tools/data/aubry_binary_grammar_surrogate_gate_20260515_1807.json ?? tools/data/aubry_boundary_phase_transport_gate_20260515_1745.json ?? tools/data/aubry_cosine_boundary_counter_gate_20260515_1758.json ?? tools/data/aubry_physical_perturbation_20260529_baseline.json ?? tools/data/aubry_physical_perturbation_20260529_second_hop_neg.json ?? tools/data/aubry_physical_perturbation_20260529_second_hop_pos.json ?? tools/data/aubry_v2_generator_scaling_gate_20260515_1816.json ?? tools/data/biconi/bicono_20260512_0330.json ?? tools/data/biconi/bicono_20260513_0330.json ?? tools/data/biconi/bicono_20260514_0330.json ?? tools/data/biconi/bicono_20260514_1330.json ?? tools/data/biconi/bicono_20260514_1458.json ?? tools/data/biconi/bicono_20260514_1605.json ?? tools/data/biconi/bicono_20260514_1612.json ?? tools/data/biconi/bicono_20260514_1631.json ?? tools/data/biconi/bicono_20260514_1640.json ?? tools/data/biconi/bicono_20260514_1649.json ?? tools/data/biconi/bicono_20260514_1656.json ?? tools/data/biconi/bicono_20260514_1701.json ?? tools/data/biconi/bicono_20260514_1850.json ?? tools/data/biconi/bicono_20260515_1623.json ?? tools/data/biconi/bicono_20260515_1647.json ?? tools/data/biconi/bicono_20260515_1659.json ?? tools/data/biconi/bicono_20260515_1705.json ?? tools/data/biconi/bicono_20260515_1712.json ?? tools/data/biconi/bicono_20260515_1724.json ?? tools/data/biconi/bicono_20260515_1734.json ?? tools/data/biconi/bicono_20260515_1745.json ?? tools/data/biconi/bicono_20260515_1758.json ?? tools/data/biconi/bicono_20260515_1807.json ?? tools/data/biconi/bicono_20260515_1816.json ?? tools/data/biconi/bicono_20260515_1826.json ?? tools/data/biconi/bicono_20260515_1855.json ?? tools/data/biconi/bicono_20260515_1904.json ?? tools/data/biconi/bicono_20260515_1915.json ?? tools/data/biconi/bicono_20260515_1933.json ?? tools/data/biconi/bicono_20260515_1940.json ?? tools/data/biconi/bicono_20260515_1947.json ?? tools/data/biconi/bicono_20260516_0330.json ?? tools/data/biconi/bicono_20260516_0720.json ?? tools/data/biconi/bicono_20260516_0820.json ?? tools/data/biconi/bicono_20260516_0921.json ?? tools/data/biconi/bicono_20260516_0938.json ?? tools/data/biconi/bicono_20260516_1007.json ?? tools/data/biconi/bicono_20260516_1019.json ?? tools/data/biconi/bicono_20260516_1031.json ?? tools/data/biconi/bicono_20260516_1045.json ?? tools/data/biconi/bicono_20260516_1058.json ?? tools/data/biconi/bicono_20260516_1104.json ?? tools/data/biconi/bicono_20260516_1111.json ?? tools/data/biconi/bicono_20260516_1117.json ?? tools/data/biconi/bicono_20260516_1124.json ?? tools/data/biconi/bicono_20260516_1135.json ?? tools/data/biconi/bicono_20260516_1140.json ?? tools/data/biconi/bicono_20260516_1148.json ?? tools/data/biconi/bicono_20260516_1206.json ?? tools/data/biconi/bicono_20260516_1230.json ?? tools/data/biconi/bicono_20260528_2042.json ?? tools/data/biconi/bicono_20260528_2138.json ?? tools/data/biconi/bicono_20260528_2222.json ?? tools/data/biconi/bicono_20260529_0938.json ?? tools/data/boundary_anderson_closure_probe_20260529.json ?? tools/data/boundary_anderson_closure_probe_20260529_focused.json ?? tools/data/boundary_anderson_costability_null_20260529.json ?? tools/data/boundary_anderson_costability_null_20260529_focused.json ?? tools/data/boundary_anderson_latent_reference_probe_20260529.json ?? tools/data/boundary_anderson_latent_reference_probe_20260529_focused.json ?? tools/data/boundary_anderson_physical_perturbation_null_20260529.json ?? tools/data/boundary_anderson_physical_perturbation_null_20260529_e2e.json ?? tools/data/boundary_anderson_transaction_adapter_20260529.json ?? tools/data/boundary_anderson_transaction_adapter_20260529_focused.json ?? tools/data/boundary_aubry_physical_perturbation_null_20260529.json ?? tools/data/boundary_bridge_stability_audit_20260515_1915.json ?? tools/data/boundary_bridge_stability_audit_20260516_1140.json ?? tools/data/boundary_classical_crossover_audit_20260515_1904.json ?? tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl ?? tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl ?? tools/data/boundary_contextual_transaction_detector_percolation_band_20260529.json ?? tools/data/boundary_contextual_transaction_detector_percolation_ladder_20260529.json ?? tools/data/boundary_discriminator_workflow_20260529.json ?? tools/data/boundary_evolution_measure_20260529.json ?? tools/data/boundary_evolution_measure_20260529_focused.json ?? tools/data/boundary_graph_curvature_gate_20260515_1855.json ?? tools/data/boundary_graph_mechanism_ablation_20260516_1230.json ?? tools/data/boundary_graph_null_audit_20260516_0330.json ?? tools/data/boundary_graph_residue_threshold_audit_20260516_0720.json ?? tools/data/boundary_percolation_edge_trace_20260528_2138.json ?? tools/data/boundary_physical_internal_null_20260528_2042.json ?? tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl ?? tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl ?? tools/data/boundary_physical_internal_null_cache_row_aligned_smoke_20260528.jsonl ?? tools/data/boundary_physical_internal_null_preflight_20260528_2042.json ?? tools/data/boundary_physical_internal_null_repro_20260528_2201.json ?? tools/data/boundary_physical_internal_null_repro_20260528_2222_seed202605282042.json ?? tools/data/boundary_physical_internal_null_repro_20260528_2222_seed202605282223_N1.json ?? tools/data/boundary_physical_perturbation_evolution_measure_20260529_e2e.json ?? tools/data/boundary_prime_label_null_audit_20260516_1148.json ?? tools/data/boundary_reader_regression_audit_20260528_2138.json ?? tools/data/boundary_reference_position_probe_trial47_20260529.json ?? tools/data/boundary_residue_label_count_null_audit_20260516_1206.json ?? tools/data/boundary_rp_physical_perturbation_null_20260529.json ?? tools/data/boundary_rp_physical_perturbation_null_20260529_reps12.json ?? tools/data/boundary_tail_reference_probe_20260529.json ?? tools/data/boundary_tail_reference_probe_trial47_replay_20260529.json ?? tools/data/boundary_tail_reference_probe_trial47_replay_debug_20260529.json ?? tools/data/boundary_tail_reference_probe_trial47_replay_fixed_20260529.json ?? tools/data/boundary_transition_matrix_percolation_band_20260529.json ?? tools/data/boundary_transition_matrix_percolation_ladder_20260529.json ?? tools/data/boundary_unfolding_transfer_matrix_20260516_1031.json ?? tools/data/component_state_anderson3d_interface_20260514_1850.json ?? tools/data/component_state_anderson3d_interface_20260514_1850.trace.jsonl ?? tools/data/component_state_fit_ready_20260514_1649.json ?? tools/data/component_state_interface_smoke_20260514_1649.json ?? tools/data/component_state_interface_smoke_20260514_1649.trace.jsonl ?? tools/data/component_state_interface_smoke_input_20260514_1649.json ?? tools/data/domandatore/domandatore_20260512_0330.json ?? tools/data/domandatore/domandatore_20260512_0345.json ?? tools/data/domandatore/domandatore_20260513_0330.json ?? tools/data/domandatore/domandatore_20260513_0345.json ?? tools/data/domandatore/domandatore_20260514_0330.json ?? tools/data/domandatore/domandatore_20260514_0345.json ?? tools/data/domandatore/domandatore_20260514_1330.json ?? tools/data/domandatore/domandatore_20260514_1458.json ?? tools/data/domandatore/domandatore_20260515_0345.json ?? tools/data/domandatore/domandatore_20260515_1623.json ?? tools/data/domandatore/domandatore_20260515_1647.json ?? tools/data/domandatore/domandatore_20260515_1659.json ?? tools/data/domandatore/domandatore_20260516_0345.json ?? tools/data/domandatore/domandatore_20260517_0345.json ?? tools/data/domandatore/domandatore_20260518_0345.json ?? tools/data/domandatore/domandatore_20260519_0345.json ?? tools/data/domandatore/domandatore_20260520_0345.json ?? tools/data/domandatore/domandatore_20260521_0345.json ?? tools/data/domandatore/domandatore_20260522_0345.json ?? tools/data/domandatore/domandatore_20260523_0345.json ?? tools/data/domandatore/domandatore_20260524_0345.json ?? tools/data/domandatore/domandatore_20260525_0345.json ?? tools/data/domandatore/domandatore_20260526_0345.json ?? tools/data/domandatore/domandatore_20260526_1751.json ?? tools/data/domandatore/domandatore_20260526_1852.json ?? tools/data/domandatore/domandatore_20260526_1854.json ?? tools/data/domandatore/domandatore_20260526_1901.json ?? tools/data/domandatore/domandatore_20260526_1915.json ?? tools/data/domandatore/domandatore_20260526_1918.json ?? tools/data/domandatore/domandatore_20260526_1937.json ?? tools/data/domandatore/domandatore_20260526_1957.json ?? tools/data/domandatore/domandatore_20260527_0345.json ?? tools/data/domandatore/domandatore_20260528_0345.json ?? tools/data/domandatore/domandatore_20260528_2028.json ?? tools/data/domandatore/domandatore_20260528_2042.json ?? tools/data/domandatore/domandatore_20260528_2138.json ?? tools/data/domandatore/domandatore_20260529_0345.json ?? tools/data/domandatore/domandatore_20260530_0345.json ?? tools/data/domandatore/domandatore_20260531_0345.json ?? tools/data/domandatore/domandatore_20260531_2024.json ?? tools/data/endpoint_feature_scramble_null_20260516_1058.json ?? tools/data/endpoint_gated_rp_boundary_20260516_1104.json ?? tools/data/endpoint_gated_rp_size_ladder_20260516_1111.json ?? tools/data/endpoint_stability_filter_20260516_1045.json ?? tools/data/evolution/evolution_20260512_0330.md ?? tools/data/evolution/evolution_20260513_0330.md ?? tools/data/evolution/evolution_20260514_0330.md ?? tools/data/evolution/evolution_20260514_1330.md ?? tools/data/evolution/evolution_20260514_1458.md ?? tools/data/evolution/evolution_20260514_1605.md ?? tools/data/evolution/evolution_20260514_1612.md ?? tools/data/evolution/evolution_20260514_1631.md ?? tools/data/evolution/evolution_20260514_1640.md ?? tools/data/evolution/evolution_20260514_1649.md ?? tools/data/evolution/evolution_20260514_1656.md ?? tools/data/evolution/evolution_20260514_1701.md ?? tools/data/evolution/evolution_20260514_1850.md ?? tools/data/evolution/evolution_20260515_1623.md ?? tools/data/evolution/evolution_20260515_1647.md ?? tools/data/evolution/evolution_20260515_1659.md ?? tools/data/evolution/evolution_20260515_1705.md ?? tools/data/evolution/evolution_20260515_1712.md ?? tools/data/evolution/evolution_20260515_1724.md ?? tools/data/evolution/evolution_20260515_1734.md ?? tools/data/evolution/evolution_20260515_1745.md ?? tools/data/evolution/evolution_20260515_1758.md ?? tools/data/evolution/evolution_20260515_1807.md ?? tools/data/evolution/evolution_20260515_1816.md ?? tools/data/evolution/evolution_20260515_1826.md ?? tools/data/evolution/evolution_20260515_1855.md ?? tools/data/evolution/evolution_20260515_1904.md ?? tools/data/evolution/evolution_20260515_1915.md ?? tools/data/evolution/evolution_20260515_1933.md ?? tools/data/evolution/evolution_20260515_1940.md ?? tools/data/evolution/evolution_20260515_1947.md ?? tools/data/evolution/evolution_20260516_0330.md ?? tools/data/evolution/evolution_20260516_0720.md ?? tools/data/evolution/evolution_20260516_0820.md ?? tools/data/evolution/evolution_20260516_0921.md ?? tools/data/evolution/evolution_20260516_0938.md ?? tools/data/evolution/evolution_20260516_1007.md ?? tools/data/evolution/evolution_20260516_1019.md ?? tools/data/evolution/evolution_20260516_1031.md ?? tools/data/evolution/evolution_20260516_1045.md ?? tools/data/evolution/evolution_20260516_1058.md ?? tools/data/evolution/evolution_20260516_1104.md ?? tools/data/evolution/evolution_20260516_1111.md ?? tools/data/evolution/evolution_20260516_1117.md ?? tools/data/evolution/evolution_20260516_1124.md ?? tools/data/evolution/evolution_20260516_1135.md ?? tools/data/evolution/evolution_20260516_1140.md ?? tools/data/evolution/evolution_20260516_1148.md ?? tools/data/evolution/evolution_20260516_1206.md ?? tools/data/evolution/evolution_20260516_1230.md ?? tools/data/evolution/evolution_20260528_2028.md ?? tools/data/evolution/evolution_20260528_2042.md ?? tools/data/evolution/evolution_20260528_2138.md ?? tools/data/evolution/evolution_20260528_2222.md ?? tools/data/falsifier_20260529_0938.json ?? tools/data/graph_completion/graph_completion_20260512_0330.json ?? tools/data/graph_completion/graph_completion_20260513_0330.json ?? tools/data/graph_completion/graph_completion_20260514_0330.json ?? tools/data/graph_completion/graph_completion_20260514_1330.json ?? tools/data/graph_completion/graph_completion_20260514_1458.json ?? tools/data/graph_completion/graph_completion_20260514_1605.json ?? tools/data/graph_completion/graph_completion_20260514_1612.json ?? tools/data/graph_completion/graph_completion_20260514_1631.json ?? tools/data/graph_completion/graph_completion_20260514_1640.json ?? tools/data/graph_completion/graph_completion_20260514_1649.json ?? tools/data/graph_completion/graph_completion_20260514_1656.json ?? tools/data/graph_completion/graph_completion_20260514_1701.json ?? tools/data/graph_completion/graph_completion_20260514_1850.json ?? tools/data/graph_completion/graph_completion_20260515_1623.json ?? tools/data/graph_completion/graph_completion_20260515_1647.json ?? tools/data/graph_completion/graph_completion_20260515_1659.json ?? tools/data/graph_completion/graph_completion_20260515_1705.json ?? tools/data/graph_completion/graph_completion_20260515_1712.json ?? tools/data/graph_completion/graph_completion_20260515_1724.json ?? tools/data/graph_completion/graph_completion_20260515_1734.json ?? tools/data/graph_completion/graph_completion_20260515_1745.json ?? tools/data/graph_completion/graph_completion_20260515_1758.json ?? tools/data/graph_completion/graph_completion_20260515_1807.json ?? tools/data/graph_completion/graph_completion_20260515_1816.json ?? tools/data/graph_completion/graph_completion_20260515_1904.json ?? tools/data/graph_completion/graph_completion_20260515_1933.json ?? tools/data/graph_completion/graph_completion_20260515_1940.json ?? tools/data/graph_completion/graph_completion_20260515_1947.json ?? tools/data/graph_completion/graph_completion_20260516_0921.json ?? tools/data/graph_completion/graph_completion_20260516_0938.json ?? tools/data/graph_completion/graph_completion_20260516_1007.json ?? tools/data/graph_completion/graph_completion_20260516_1019.json ?? tools/data/graph_completion/graph_completion_20260516_1031.json ?? tools/data/graph_completion/graph_completion_20260516_1104.json ?? tools/data/graph_completion/graph_completion_20260516_1111.json ?? tools/data/graph_completion/graph_completion_20260516_1117.json ?? tools/data/graph_completion/graph_completion_20260516_1135.json ?? tools/data/graph_completion/graph_completion_20260516_1148.json ?? tools/data/graph_completion/graph_completion_20260516_1206.json ?? tools/data/graph_completion/graph_completion_20260516_1230.json ?? tools/data/incrocio_20260512_0330.json ?? tools/data/incrocio_20260513_0330.json ?? tools/data/incrocio_20260514_0330.json ?? tools/data/incrocio_20260514_1330.json ?? tools/data/incrocio_20260514_1458.json ?? tools/data/incrocio_20260514_1605.json ?? tools/data/incrocio_20260514_1612.json ?? tools/data/incrocio_20260514_1631.json ?? tools/data/incrocio_20260514_1640.json ?? tools/data/incrocio_20260514_1649.json ?? tools/data/incrocio_20260514_1656.json ?? tools/data/incrocio_20260514_1701.json ?? tools/data/incrocio_20260514_1850.json ?? tools/data/incrocio_20260515_1623.json ?? tools/data/incrocio_20260515_1647.json ?? tools/data/incrocio_20260515_1659.json ?? tools/data/incrocio_20260515_1705.json ?? tools/data/incrocio_20260515_1712.json ?? tools/data/incrocio_20260515_1724.json ?? tools/data/incrocio_20260515_1734.json ?? tools/data/incrocio_20260515_1745.json ?? tools/data/incrocio_20260515_1758.json ?? tools/data/incrocio_20260515_1807.json ?? tools/data/incrocio_20260515_1816.json ?? tools/data/incrocio_20260515_1826.json ?? tools/data/incrocio_20260515_1855.json ?? tools/data/incrocio_20260515_1904.json ?? tools/data/incrocio_20260515_1915.json ?? tools/data/incrocio_20260515_1933.json ?? tools/data/incrocio_20260515_1940.json ?? tools/data/incrocio_20260515_1947.json ?? tools/data/incrocio_20260516_0330.json ?? tools/data/incrocio_20260516_0720.json ?? tools/data/incrocio_20260516_0820.json ?? tools/data/incrocio_20260516_0921.json ?? tools/data/incrocio_20260516_0938.json ?? tools/data/incrocio_20260516_1007.json ?? tools/data/incrocio_20260516_1019.json ?? tools/data/incrocio_20260516_1031.json ?? tools/data/incrocio_20260516_1045.json ?? tools/data/incrocio_20260516_1058.json ?? tools/data/incrocio_20260516_1104.json ?? tools/data/incrocio_20260516_1111.json ?? tools/data/incrocio_20260516_1117.json ?? tools/data/incrocio_20260516_1124.json ?? tools/data/incrocio_20260516_1135.json ?? tools/data/incrocio_20260516_1140.json ?? tools/data/incrocio_20260516_1148.json ?? tools/data/incrocio_20260516_1206.json ?? tools/data/incrocio_20260516_1230.json ?? tools/data/incrocio_20260528_2028.json ?? tools/data/incrocio_20260528_2042.json ?? tools/data/incrocio_20260528_2138.json ?? tools/data/incrocio_20260528_2222.json ?? tools/data/incrocio_20260531_2024.json ?? tools/data/landing/ ?? tools/data/operator_directives_consumed/operator_directive_20260514_1612.md ?? tools/data/operator_directives_consumed/operator_directive_20260514_1631.md ?? tools/data/operator_directives_consumed/operator_directive_20260514_1640.md ?? tools/data/operator_directives_consumed/operator_directive_20260514_1649.md ?? tools/data/operator_directives_consumed/operator_directive_20260514_1656.md ?? tools/data/operator_directives_consumed/operator_directive_20260514_1701.md ?? tools/data/operator_directives_consumed/operator_directive_20260514_1850.md ?? tools/data/operator_directives_consumed/operator_directive_20260528_2138.md ?? tools/data/operator_directives_consumed/operator_directive_20260528_2222.md ?? tools/data/operator_directives_consumed/operator_directive_20260531_2024.md ?? tools/data/photonic_boundary_third_included_gate_20260515_1734.json ?? tools/data/physical_sr_residue_bounce_20260514_1612.json ?? tools/data/physical_sr_residue_bounce_20260514_1612.trace.jsonl ?? tools/data/physical_sr_residue_bounce_20260514_1631_w6.json ?? tools/data/physical_sr_residue_bounce_20260514_1631_w6.trace.jsonl ?? tools/data/physical_sr_residue_bounce_20260514_1640_goe_gue_ncurve.json ?? tools/data/physical_sr_residue_bounce_20260514_1640_goe_gue_ncurve.trace.jsonl ?? tools/data/preflight/ ?? tools/data/prime_sr_persistent_boundary_20260512_0330.json ?? tools/data/prime_sr_persistent_boundary_20260512_0330_seedcheck.json ?? tools/data/prime_vs_mod6_sr_boundary_20260513_0330.json ?? tools/data/prime_vs_mod6_sr_boundary_20260513_0330_seedcheck.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_0330.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_0330.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_0330_seedcheck.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_0330_seedcheck.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1330_w1024.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1330_w1024.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1330_w2048.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1330_w2048.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1330_w512.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1330_w512.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1458_w4096.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1458_w4096.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1458_w4096_dense.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1458_w4096_dense.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1458_w8192_dense.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1458_w8192_dense.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1605_w16384.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1605_w16384.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1605_w4096.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1605_w4096.trace.jsonl ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1605_w8192.json ?? tools/data/prime_vs_mod6_sr_boundary_20260514_1605_w8192.trace.jsonl ?? tools/data/promotions/promotion_20260513_0330.json ?? tools/data/promotions/promotion_20260514_1330.json ?? tools/data/promotions/promotion_20260514_1631.json ?? tools/data/promotions/promotion_20260514_1640.json ?? tools/data/promotions/promotion_20260514_1656.json ?? tools/data/promotions/promotion_20260515_1712.json ?? tools/data/promotions/promotion_20260515_1758.json ?? tools/data/promotions/promotion_20260515_1816.json ?? tools/data/promotions/promotion_20260515_1904.json ?? tools/data/promotions/promotion_20260515_1933.json ?? tools/data/promotions/promotion_20260515_1940.json ?? tools/data/promotions/promotion_20260515_1947.json ?? tools/data/promotions/promotion_20260516_0921.json ?? tools/data/promotions/promotion_20260516_0938.json ?? tools/data/promotions/promotion_20260516_1007.json ?? tools/data/promotions/promotion_20260516_1019.json ?? tools/data/promotions/promotion_20260516_1031.json ?? tools/data/promotions/promotion_20260516_1104.json ?? tools/data/promotions/promotion_20260516_1111.json ?? tools/data/promotions/promotion_20260516_1117.json ?? tools/data/promotions/promotion_20260516_1135.json ?? tools/data/promotions/promotion_20260516_1148.json ?? tools/data/promotions/promotion_20260516_1206.json ?? tools/data/promotions/promotion_20260516_1230.json ?? tools/data/promotions/promotion_20260528_2028.json ?? tools/data/quasiperiodic_grammar_scale_gate_20260514_1701.json ?? tools/data/quasiperiodic_vc_lattice_gate_20260515_1724.json ?? tools/data/repairs/repair_20260512_0330_decision.json ?? tools/data/repairs/repair_20260513_0330_decision.json ?? tools/data/repairs/repair_20260514_0330_decision.json ?? tools/data/repairs/repair_20260514_1330_decision.json ?? tools/data/repairs/repair_20260514_1458_decision.json ?? tools/data/repairs/repair_20260514_1605_decision.json ?? tools/data/repairs/repair_20260514_1612_decision.json ?? tools/data/repairs/repair_20260514_1631_decision.json ?? tools/data/repairs/repair_20260514_1640_decision.json ?? tools/data/repairs/repair_20260514_1649_decision.json ?? tools/data/repairs/repair_20260514_1656.json ?? tools/data/repairs/repair_20260514_1656.md ?? tools/data/repairs/repair_20260514_1656_decision.json ?? tools/data/repairs/repair_20260514_1850_decision.json ?? tools/data/reports/agent_20260512_0330.md ?? tools/data/reports/agent_20260513_0330.md ?? tools/data/reports/agent_20260514_0330.md ?? tools/data/reports/agent_20260514_1330.md ?? tools/data/reports/agent_20260514_1458.md ?? tools/data/reports/agent_20260514_1605.md ?? tools/data/reports/agent_20260514_1612.md ?? tools/data/reports/agent_20260514_1631.md ?? tools/data/reports/agent_20260514_1640.md ?? tools/data/reports/agent_20260514_1649.md ?? tools/data/reports/agent_20260514_1656.md ?? tools/data/reports/agent_20260514_1701.md ?? tools/data/reports/agent_20260514_1850.md ?? tools/data/reports/agent_20260515_1623.md ?? tools/data/reports/agent_20260515_1647.md ?? tools/data/reports/agent_20260515_1659.md ?? tools/data/reports/agent_20260515_1705.md ?? tools/data/reports/agent_20260515_1712.md ?? tools/data/reports/agent_20260515_1724.md ?? tools/data/reports/agent_20260515_1734.md ?? tools/data/reports/agent_20260515_1745.md ?? tools/data/reports/agent_20260515_1758.md ?? tools/data/reports/agent_20260515_1807.md ?? tools/data/reports/agent_20260515_1816.md ?? tools/data/reports/agent_20260515_1826.md ?? tools/data/reports/agent_20260515_1855.md ?? tools/data/reports/agent_20260515_1904.md ?? tools/data/reports/agent_20260515_1915.md ?? tools/data/reports/agent_20260515_1933.md ?? tools/data/reports/agent_20260515_1940.md ?? tools/data/reports/agent_20260515_1947.md ?? tools/data/reports/agent_20260516_0330.md ?? tools/data/reports/agent_20260516_0720.md ?? tools/data/reports/agent_20260516_0820.md ?? tools/data/reports/agent_20260516_0921.md ?? tools/data/reports/agent_20260516_0938.md ?? tools/data/reports/agent_20260516_1007.md ?? tools/data/reports/agent_20260516_1019.md ?? tools/data/reports/agent_20260516_1031.md ?? tools/data/reports/agent_20260516_1045.md ?? tools/data/reports/agent_20260516_1058.md ?? tools/data/reports/agent_20260516_1104.md ?? tools/data/reports/agent_20260516_1111.md ?? tools/data/reports/agent_20260516_1117.md ?? tools/data/reports/agent_20260516_1124.md ?? tools/data/reports/agent_20260516_1135.md ?? tools/data/reports/agent_20260516_1140.md ?? tools/data/reports/agent_20260516_1148.md ?? tools/data/reports/agent_20260516_1206.md ?? tools/data/reports/agent_20260516_1230.md ?? tools/data/reports/agent_20260528_2042.md ?? tools/data/reports/agent_20260528_2138.md ?? tools/data/reports/agent_20260528_2222.md ?? tools/data/reports/agent_20260529_0938.md ?? tools/data/reports/ddf_20260512_0405.json ?? tools/data/reports/ddf_20260513_0405.json ?? tools/data/reports/ddf_20260514_0405.json ?? tools/data/reports/ddf_20260515_0405.json ?? tools/data/reports/ddf_20260516_0405.json ?? tools/data/reports/ddf_20260517_0405.json ?? tools/data/reports/ddf_20260518_0405.json ?? tools/data/reports/ddf_20260519_0405.json ?? tools/data/reports/ddf_20260520_0405.json ?? tools/data/reports/ddf_20260521_0405.json ?? tools/data/reports/ddf_20260522_0405.json ?? tools/data/reports/ddf_20260523_0405.json ?? tools/data/reports/ddf_20260524_0405.json ?? tools/data/reports/ddf_20260525_0405.json ?? tools/data/reports/ddf_20260526_0405.json ?? tools/data/reports/ddf_20260527_0405.json ?? tools/data/reports/ddf_20260528_0405.json ?? tools/data/reports/ddf_20260529_0405.json ?? tools/data/reports/ddf_20260530_0405.json ?? tools/data/reports/ddf_20260531_0405.json ?? tools/data/reports/e2e_anderson_physical_perturbation_20260529.md ?? tools/data/reports/e2e_landing_loop_anderson_physical_perturbation_20260529.md ?? tools/data/reports/e2e_w165_closure_confirmation_20260529.md ?? tools/data/reports/e2e_w165_closure_map_20260529.md ?? tools/data/reports/falsifier_20260512_0330.json ?? tools/data/reports/falsifier_20260513_0330.json ?? tools/data/reports/falsifier_20260514_0330.json ?? tools/data/reports/falsifier_20260514_1330.json ?? tools/data/reports/falsifier_20260514_1458.json ?? tools/data/reports/falsifier_20260514_1605.json ?? tools/data/reports/falsifier_20260514_1612.json ?? tools/data/reports/falsifier_20260514_1631.json ?? tools/data/reports/falsifier_20260514_1640.json ?? tools/data/reports/falsifier_20260514_1649.json ?? tools/data/reports/falsifier_20260514_1656.json ?? tools/data/reports/falsifier_20260514_1701.json ?? tools/data/reports/falsifier_20260514_1850.json ?? tools/data/reports/falsifier_20260515_1623.json ?? tools/data/reports/falsifier_20260515_1647.json ?? tools/data/reports/falsifier_20260515_1659.json ?? tools/data/reports/falsifier_20260515_1705.json ?? tools/data/reports/falsifier_20260515_1712.json ?? tools/data/reports/falsifier_20260515_1712.raw.txt ?? tools/data/reports/falsifier_20260515_1724.json ?? tools/data/reports/falsifier_20260515_1734.json ?? tools/data/reports/falsifier_20260515_1745.json ?? tools/data/reports/falsifier_20260515_1758.json ?? tools/data/reports/falsifier_20260515_1807.json ?? tools/data/reports/falsifier_20260515_1816.json ?? tools/data/reports/falsifier_20260515_1826.json ?? tools/data/reports/falsifier_20260515_1855.json ?? tools/data/reports/falsifier_20260515_1904.json ?? tools/data/reports/falsifier_20260515_1915.json ?? tools/data/reports/falsifier_20260515_1933.json ?? tools/data/reports/falsifier_20260515_1940.json ?? tools/data/reports/falsifier_20260515_1947.json ?? tools/data/reports/falsifier_20260516_0330.json ?? tools/data/reports/falsifier_20260516_0720.json ?? tools/data/reports/falsifier_20260516_0820.json ?? tools/data/reports/falsifier_20260516_0921.json ?? tools/data/reports/falsifier_20260516_0921.raw.txt ?? tools/data/reports/falsifier_20260516_0938.json ?? tools/data/reports/falsifier_20260516_1007.json ?? tools/data/reports/falsifier_20260516_1019.json ?? tools/data/reports/falsifier_20260516_1031.json ?? tools/data/reports/falsifier_20260516_1045.json ?? tools/data/reports/falsifier_20260516_1058.json ?? tools/data/reports/falsifier_20260516_1104.json ?? tools/data/reports/falsifier_20260516_1111.json ?? tools/data/reports/falsifier_20260516_1117.json ?? tools/data/reports/falsifier_20260516_1124.json ?? tools/data/reports/falsifier_20260516_1135.json ?? tools/data/reports/falsifier_20260516_1140.json ?? tools/data/reports/falsifier_20260516_1148.json ?? tools/data/reports/falsifier_20260516_1206.json ?? tools/data/reports/falsifier_20260516_1230.json ?? tools/data/reports/falsifier_20260528_2042.json ?? tools/data/reports/falsifier_20260528_2138.json ?? tools/data/reports/falsifier_20260528_2222.json ?? tools/data/reports/falsifier_20260529_0938.json ?? tools/data/reports/incident_20260528_2028.md ?? tools/data/reports/loop_guard_20260512_0330.json ?? tools/data/reports/loop_guard_20260513_0330.json ?? tools/data/reports/loop_guard_20260514_0330.json ?? tools/data/reports/loop_guard_20260514_1330.json ?? tools/data/reports/loop_guard_20260514_1458.json ?? tools/data/reports/loop_guard_20260514_1605.json ?? tools/data/reports/loop_guard_20260514_1612.json ?? tools/data/reports/loop_guard_20260514_1631.json ?? tools/data/reports/loop_guard_20260514_1640.json ?? tools/data/reports/loop_guard_20260514_1649.json ?? tools/data/reports/loop_guard_20260514_1656.json ?? tools/data/reports/loop_guard_20260514_1701.json ?? tools/data/reports/loop_guard_20260514_1850.json ?? tools/data/reports/loop_guard_20260515_1623.json ?? tools/data/reports/loop_guard_20260515_1647.json ?? tools/data/reports/loop_guard_20260515_1659.json ?? tools/data/reports/loop_guard_20260515_1705.json ?? tools/data/reports/loop_guard_20260515_1712.json ?? tools/data/reports/loop_guard_20260515_1724.json ?? tools/data/reports/loop_guard_20260515_1734.json ?? tools/data/reports/loop_guard_20260515_1745.json ?? tools/data/reports/loop_guard_20260515_1758.json ?? tools/data/reports/loop_guard_20260515_1807.json ?? tools/data/reports/loop_guard_20260515_1816.json ?? tools/data/reports/loop_guard_20260515_1826.json ?? tools/data/reports/loop_guard_20260515_1855.json ?? tools/data/reports/loop_guard_20260515_1904.json ?? tools/data/reports/loop_guard_20260515_1915.json ?? tools/data/reports/loop_guard_20260515_1933.json ?? tools/data/reports/loop_guard_20260515_1940.json ?? tools/data/reports/loop_guard_20260515_1947.json ?? tools/data/reports/loop_guard_20260516_0330.json ?? tools/data/reports/loop_guard_20260516_0720.json ?? tools/data/reports/loop_guard_20260516_0820.json ?? tools/data/reports/loop_guard_20260516_0921.json ?? tools/data/reports/loop_guard_20260516_0938.json ?? tools/data/reports/loop_guard_20260516_1007.json ?? tools/data/reports/loop_guard_20260516_1019.json ?? tools/data/reports/loop_guard_20260516_1031.json ?? tools/data/reports/loop_guard_20260516_1045.json ?? tools/data/reports/loop_guard_20260516_1058.json ?? tools/data/reports/loop_guard_20260516_1104.json ?? tools/data/reports/loop_guard_20260516_1111.json ?? tools/data/reports/loop_guard_20260516_1117.json ?? tools/data/reports/loop_guard_20260516_1124.json ?? tools/data/reports/loop_guard_20260516_1135.json ?? tools/data/reports/loop_guard_20260516_1140.json ?? tools/data/reports/loop_guard_20260516_1148.json ?? tools/data/reports/loop_guard_20260516_1206.json ?? tools/data/reports/loop_guard_20260516_1230.json ?? tools/data/reports/loop_guard_20260528_2028.json ?? tools/data/reports/loop_guard_20260528_2042.json ?? tools/data/reports/loop_guard_20260528_2138.json ?? tools/data/reports/loop_guard_20260528_2222.json ?? tools/data/reports/quarantine_manifest.json ?? tools/data/restore_backups/ ?? tools/data/rosenzweig_porter_bridge_physical_audit_20260515_1933.json ?? tools/data/rp_boundary_raw_count_null_audit_20260516_0820.json ?? tools/data/rp_boundary_size_stability_audit_20260515_1940.json ?? tools/data/rp_candidate_window_stress_20260516_0938_w11.json ?? tools/data/rp_candidate_window_stress_20260516_0938_w5.json ?? tools/data/rp_candidate_window_stress_20260516_1007_w7.json ?? tools/data/rp_candidate_window_stress_20260516_1007_w9.json ?? tools/data/rp_exact_local_window_matrix_20260516_1019.json ?? tools/data/rp_exact_local_window_matrix_20260516_1019_w10.json ?? tools/data/rp_exact_local_window_matrix_20260516_1019_w11.json ?? tools/data/rp_exact_local_window_matrix_20260516_1019_w12.json ?? tools/data/rp_exact_local_window_matrix_20260516_1019_w9.json ?? tools/data/rp_physical_perturbation_20260529_baseline.json ?? tools/data/rp_physical_perturbation_20260529_diagonal_heavy.json ?? tools/data/rp_physical_perturbation_20260529_gue_heavy.json ?? tools/data/rp_physical_perturbation_20260529_reps12_baseline.json ?? tools/data/rp_physical_perturbation_20260529_reps12_diagonal_heavy.json ?? tools/data/rp_physical_perturbation_20260529_reps12_gue_heavy.json ?? tools/data/rp_unfolding_sensitivity_audit_20260516_0921.json ?? tools/data/seme_archive/piano_136.json ?? tools/data/seme_backup_b2_20260512_033557.json ?? tools/data/seme_backup_b2_20260513_033622.json ?? tools/data/seme_backup_b2_20260514_150530.json ?? tools/data/seme_backup_b2_20260514_161119.json ?? tools/data/seme_backup_b2_20260515_180327.json ?? tools/data/seme_backup_b2_20260515_194643.json ?? tools/data/seme_backup_b2_20260516_094447.json ?? tools/data/seme_backup_b2_20260516_101425.json ?? tools/data/seme_backup_b2_20260516_102450.json ?? tools/data/seme_backup_b2_20260516_120521.json ?? tools/data/seme_backup_b2_20260516_122021.json ?? tools/data/seme_backup_b2_20260516_123925.json ?? tools/data/seme_backup_tm7_cache_n8_20260528_2258.json ?? tools/data/seme_backup_tm7_cache_row_aligned_20260528_2245.json ?? tools/data/seme_backup_tm7_reader_provenance_20260528_2225.json ?? tools/data/seme_backup_tm7_reader_redesign_20260528_213736.json ?? tools/data/sturmian_denominator_alignment_gate_20260515_1826.json ?? tools/data/tool_contracts/ ?? tools/data/veritas/veritas_20260512_033539.json ?? tools/data/veritas/veritas_20260513_033605.json ?? tools/data/veritas/veritas_20260514_033420.json ?? tools/data/veritas/veritas_20260514_133424.json ?? tools/data/veritas/veritas_20260514_150454.json ?? tools/data/veritas/veritas_20260514_161058.json ?? tools/data/veritas/veritas_20260514_161719.json ?? tools/data/veritas/veritas_20260514_163527.json ?? tools/data/veritas/veritas_20260514_164509.json ?? tools/data/veritas/veritas_20260514_165437.json ?? tools/data/veritas/veritas_20260514_170109.json ?? tools/data/veritas/veritas_20260514_171152.json ?? tools/data/veritas/veritas_20260514_185450.json ?? tools/data/veritas/veritas_20260515_162727.json ?? tools/data/veritas/veritas_20260515_165116.json ?? tools/data/veritas/veritas_20260515_170328.json ?? tools/data/veritas/veritas_20260515_171005.json ?? tools/data/veritas/veritas_20260515_171725.json ?? tools/data/veritas/veritas_20260515_172913.json ?? tools/data/veritas/veritas_20260515_174023.json ?? tools/data/veritas/veritas_20260515_175045.json ?? tools/data/veritas/veritas_20260515_180306.json ?? tools/data/veritas/veritas_20260515_181257.json ?? tools/data/veritas/veritas_20260515_182126.json ?? tools/data/veritas/veritas_20260515_183111.json ?? tools/data/veritas/veritas_20260515_190118.json ?? tools/data/veritas/veritas_20260515_191018.json ?? tools/data/veritas/veritas_20260515_192915.json ?? tools/data/veritas/veritas_20260515_193919.json ?? tools/data/veritas/veritas_20260515_194625.json ?? tools/data/veritas/veritas_20260515_195317.json ?? tools/data/veritas/veritas_20260516_033848.json ?? tools/data/veritas/veritas_20260516_072533.json ?? tools/data/veritas/veritas_20260516_082608.json ?? tools/data/veritas/veritas_20260516_092735.json ?? tools/data/veritas/veritas_20260516_094423.json ?? tools/data/veritas/veritas_20260516_101403.json ?? tools/data/veritas/veritas_20260516_102427.json ?? tools/data/veritas/veritas_20260516_103737.json ?? tools/data/veritas/veritas_20260516_105525.json ?? tools/data/veritas/veritas_20260516_110354.json ?? tools/data/veritas/veritas_20260516_111042.json ?? tools/data/veritas/veritas_20260516_111633.json ?? tools/data/veritas/veritas_20260516_112343.json ?? tools/data/veritas/veritas_20260516_113001.json ?? tools/data/veritas/veritas_20260516_113946.json ?? tools/data/veritas/veritas_20260516_114656.json ?? tools/data/veritas/veritas_20260516_120457.json ?? tools/data/veritas/veritas_20260516_122002.json ?? tools/data/veritas/veritas_20260516_123900.json ?? tools/data/veritas/veritas_20260528_202855.json ?? tools/data/veritas/veritas_20260528_210258.json ?? tools/data/veritas/veritas_20260528_214307.json ?? tools/data/veritas/veritas_20260528_223400.json ?? tools/data/veritas/veritas_20260529_094016.json ?? tools/data/veritas/veritas_20260529_094421.json ?? tools/exp_anderson3d_comparable_null_audit.py ?? tools/exp_anderson3d_endpoint_preserving_null.py ?? tools/exp_anderson3d_mobility_edge_two_reader_audit.py ?? tools/exp_aubry_binary_grammar_surrogate_gate.py ?? tools/exp_aubry_boundary_phase_transport_gate.py ?? tools/exp_aubry_cosine_boundary_counter_gate.py ?? tools/exp_aubry_v2_generator_scaling_gate.py ?? tools/exp_boundary_anderson_closure_probe.py ?? tools/exp_boundary_anderson_costability_null.py ?? tools/exp_boundary_anderson_latent_reference_probe.py ?? tools/exp_boundary_anderson_physical_perturbation_null.py ?? tools/exp_boundary_anderson_transaction_adapter.py ?? tools/exp_boundary_anderson_w165_closure_map.py ?? tools/exp_boundary_aubry_physical_perturbation_null.py ?? tools/exp_boundary_bridge_stability_audit.py ?? tools/exp_boundary_classical_crossover_audit.py ?? tools/exp_boundary_contextual_transaction_detector.py ?? tools/exp_boundary_discriminator_workflow.py ?? tools/exp_boundary_evolution_measure.py ?? tools/exp_boundary_graph_curvature_gate.py ?? tools/exp_boundary_graph_mechanism_ablation.py ?? tools/exp_boundary_graph_null_audit.py ?? tools/exp_boundary_graph_residue_threshold_audit.py ?? tools/exp_boundary_percolation_edge_trace.py ?? tools/exp_boundary_physical_internal_null.py ?? tools/exp_boundary_physical_internal_null_cache_row_aligned.py ?? tools/exp_boundary_physical_internal_null_preflight.py ?? tools/exp_boundary_physical_perturbation_evolution_measure.py ?? tools/exp_boundary_physical_perturbation_landing_loop.py ?? tools/exp_boundary_prime_label_null_audit.py ?? tools/exp_boundary_reader_regression_audit.py ?? tools/exp_boundary_reference_position_probe.py ?? tools/exp_boundary_residue_label_count_null_audit.py ?? tools/exp_boundary_rp_physical_perturbation_null.py ?? tools/exp_boundary_tail_reference_probe.py ?? tools/exp_boundary_transition_matrix.py ?? tools/exp_boundary_unfolding_transfer_matrix.py ?? tools/exp_endpoint_feature_scramble_null.py ?? tools/exp_endpoint_gated_rp_boundary.py ?? tools/exp_endpoint_stability_filter.py ?? tools/exp_photonic_boundary_third_included_gate.py ?? tools/exp_physical_sr_residue_bounce.py ?? tools/exp_prime_sr_persistent_boundary.py ?? tools/exp_prime_vs_mod6_sr_boundary.py ?? tools/exp_quasiperiodic_grammar_scale_gate.py ?? tools/exp_rosenzweig_porter_bridge_physical_audit.py ?? tools/exp_rp_boundary_raw_count_null_audit.py ?? tools/exp_rp_boundary_size_stability_audit.py ?? tools/exp_rp_exact_local_window_matrix.py ?? tools/exp_rp_unfolding_sensitivity_audit.py ?? tools/exp_sturmian_denominator_alignment_gate.py ?? tools/field_coherence_preflight.py ?? tools/field_rebuild_risk_map.py ?? tools/lab_cycle_monitor.py ?? tools/lab_preflight_agent.py ?? tools/lab_runtime_observer.py ?? tools/lab_surface_invariant_check.py ?? tools/lab_tool_contract.py ?? tools/prime_mod6_counter_null_audit.py ?? tools/prime_mod6_generative_null_audit.py ?? tools/prime_mod6_null_fairness_audit.py ?? tools/prime_mod6_pipeline_closeout.py ?? tools/selector_authority_matrix.py ?? tools/stale_field_source_map.py 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 codex Il campo contiene una direttiva one-shot: audit macro della robustezza contestuale, separando logistica/percolation e trattando i fallimenti come sonde. Il repo è già molto sporco; terrò l’intervento confinato al report richiesto e a eventuali artefatti sperimentali nuovi. exec /bin/bash -lc "sed -n '241,520p' tools/data/agent_field_live.md" in /opt/MM_D-ND succeeded in 0ms: - tilt onsite `0.04`; - risultato: - W20 resta `local_global` in baseline, anisotropia e tilt; - W16/W16.5 restano zona intermedia e non chiudono insieme; - anisotropia: W16 -> `neither`, W16.5 -> `local_only`, W20 -> `local_global`; - tilt: W16 -> `local_only`, W16.5 -> `local_only`, W20 -> `local_global`; - lettura: il riferimento W20 e' robusto sotto perturbazione fisica piccola; la zona W16/W16.5 resta passaggio, non nuova chiusura. Questo rafforza Anderson come discriminatore fisico e non promuove alcun ente graph/localization. - prossima mossa: trasferire il discriminatore a un dominio fisico diverso oppure alzare la perturbazione Anderson solo se cambia il falsificatore; non aggiungere metriche derivate. - trasferimento cross-dominio RP: - tool: `tools/exp_boundary_rp_physical_perturbation_null.py`; - patch generator: `tools/exp_rosenzweig_porter_bridge_physical_audit.py` accetta ora `--diagonal-scale` e `--gue-scale`; - patch size audit: `tools/exp_rp_boundary_size_stability_audit.py` propaga gli scale fisici; - output scientifico: `tools/data/boundary_rp_physical_perturbation_null_20260529_reps12.json`; - nota: un primo run `reps=8` ha spostato il riferimento baseline a `lambda=0.045`; per non confondere risoluzione e perturbazione, il run interpretato usa il denominatore storico `reps=12`; - risultato `reps=12`: - baseline: `0.045 -> global_only`, `0.060 -> local_global`, `0.075 -> global_only`; - diagonal-heavy: `0.045 -> local_global`, `0.060 -> local_global`, `0.075 -> global_only`; - GUE-heavy: `0.045 -> local_global`, `0.060 -> local_global`, `0.075 -> global_only`; - lettura: il riferimento `0.060` resta preservato come `local_global`; il lato sinistro `0.045` puo' chiudere sotto perturbazione fisica, mentre il lato destro `0.075` resta globale ma non locale. Quindi il passaggio non e' simmetrico: c'e' una direzionalita' della zona intermedia. - contratto: `tools/data/tool_contracts/boundary_rp_physical_perturbation_null_20260529.json`; - smoke: `tools/data/tool_contracts/runs/boundary_rp_physical_perturbation_null_smoke_20260529.json`; - boundary: smoke a size singola non e' evidenza; e' solo controllo runtime. Nessuna promozione fisica. - terzo dominio Aubry/Sturmian: - tool: `tools/exp_boundary_aubry_physical_perturbation_null.py`; - patch generator: `tools/exp_aubry_boundary_phase_transport_gate.py` accetta ora `--second-hopping`; - output scientifico: `tools/data/boundary_aubry_physical_perturbation_null_20260529.json`; - focus: `V=1.00`, `V=1.25`, `V=1.50`; - criterio: bordo preservato se `V=1.25` resta `joint_boundary=true` e `V=1.50` resta `false`; - perturbazioni: `second_hopping=+0.06` e `-0.04`; - risultato: - baseline: `V=1.00 true`, `V=1.25 true`, `V=1.50 false`; - second-hop positivo: `true`, `true`, `false`; - second-hop negativo: `true`, `true`, `false`; - lettura: il bordo di uscita `1.25 -> 1.50` resta direzionale sotto perturbazione fisica in un terzo dominio. Questo sostiene il processo cognitivo discriminatore, non una legge fisica universale. - contratto: `tools/data/tool_contracts/boundary_aubry_physical_perturbation_null_20260529.json`; - smoke: `tools/data/tool_contracts/runs/boundary_aubry_physical_perturbation_null_smoke_20260529.json`; - boundary: smoke a `N=89` non e' evidenza; il run scientifico usa `N=89,144,233`. - processo cognitivo codificato: - tool: `tools/exp_boundary_discriminator_workflow.py`; - output: `tools/data/boundary_discriminator_workflow_20260529.json`; - input: Anderson, RP e Aubry perturbation/null chiusi; - misura: `domain_count=3`, `reference_preserved_count=3`, `directional_or_edge_signal_count=3`, `workflow_score=1.0`; - verdetto: `CODIFY_WORKFLOW`; - bicono candidato: - radici: riferimento stabile multi-dominio / passaggio intermedio direzionale falsificabile; - singolare: il bordo non e' un valore singolo; una parte del passaggio puo' chiudere mentre l'altra resta non-locale/fuori bordo; - invariante: lettura finale chiusa dopo perturbazione fisica, senza osservare/correggere durante il lancio; - campo: possibile automatizzare il discriminatore; non-possibile promuoverlo come legge fisica o fondazione ontologica. - contratto: `tools/data/tool_contracts/boundary_discriminator_workflow_20260529.json`; - smoke: `tools/data/tool_contracts/runs/boundary_discriminator_workflow_smoke_20260529.json`; - regola cicli: i cicli utili sono cicli di discriminazione: candidato -> dominio indipendente -> perturbazione fisica -> lettura finale -> bicono candidato -> contratto -> stop se non cambia il falsificatore. Non sono ripetizione cieca di metriche. - sonda chiusura Anderson: - tool: `tools/exp_boundary_anderson_closure_probe.py`; - report: `tools/data/boundary_anderson_closure_probe_20260529.json`; - oggetto: cosa deve muoversi in W16/W16.5 per somigliare al riferimento W20 size-matched; - movimento positivo aggregato: `graph_reference +5.720217941`, `localization_load +0.61063384`, `spectral_softening +0.369800693`, `adjacent_midpoint_score +0.259875`; - lettura: nei casi non chiusi il deficit primario e' `graph_reference`; nei casi gia' local_global il delta residuo e' `localization_load`. Quindi il candidato Anderson non e' un asse solo: ponte grafico per entrare, carico di localizzazione per stabilizzare. - riferimento della possibilita' aggiunto alla matrice: - campo `possibility_reference`; - stato: `candidate_reference_not_claim`; - definizione: il riferimento e' la qualita' preservata/persa nella transizione, non uno dei due endpoint; - transizione: `local_global->local_only`; - qualita' preservata: convergenza locale; - qualita' persa: convergenza globale/centroide; - tasso: `0.012070106`; - boundary: non chiamarla informazione trascendentale finche' non persiste in verifier indipendenti e ritorno fisica B. - residui zero nella ladder indipendente: - detector ladder: `tools/data/boundary_contextual_transaction_detector_percolation_ladder_20260529.json`; - matrice ladder: `tools/data/boundary_transition_matrix_percolation_ladder_20260529.json`; - stati null: `local_global=3440`, `local_only=14`, `global_only=1`, `neither=1`; - i due stati local=0 sono lo stesso surrogate `trial=47`, denominatore `1024`, `k=2`, seed reader `20260516/20260517`; - uno e' `neither` (`margin=0.250845867`, `cross=0.0`), l'altro e' `global_only` (`margin=0.233048755`, `cross=0.0`); - interpretazione operativa: il residuo zero non va scartato; e' il punto in cui la curva di riferimento passa sul bordo del centroide mentre la relazione locale si annulla. - ispezione fisica trial `47`: - rispetto ai trial `local_global`, il surrogate zero non e' semplicemente piu' rumoroso; - ha coda compressa: `max/q90 = 3.0` contro media `local_global ~4.54`; - ha autocorrelazione alta: `0.441934` contro media `local_global ~0.193`; - quindi appare come continuita' interna senza picco singolare dominante: una forma coerente ma priva del riferimento finale che orienta gli angoli verso localita'/globalita'; - ipotesi operativa, non claim: la globalita' dell'originale potrebbe essere mantenuta da una singolarita' di scala/tail che attraversa il campo; il trial zero mostra cosa accade quando resta continuita' ma manca quel picco. - probe tail/reference chiuso: - tool: `tools/exp_boundary_tail_reference_probe.py`; - report corretto: `tools/data/boundary_tail_reference_probe_trial47_replay_fixed_20260529.json`; - il replay corretto usa `source_reader_count=54` per ricostruire il vero surrogate trial `47`; - risultato: - `zero_reference_base` = `local_global:1`, `global_only:1`, `neither:1`; - `zero_tail_amp_1_5` e `zero_tail_amp_2_0` non ripristinano localita'; - `zero_tail_amp_3_0` ripristina `local_global:3`; - `zero_top5_original_tail` peggiora (`global_only:1`, `neither:2`); - `original_tail_compress_0_25/0_5` resta `local_global:3`; - interpretazione: non basta "coda grande" in astratto. L'originale e' robusto anche con coda compressa; il surrogate zero richiede un picco singolare molto dominante per recuperare localita'. Il riferimento finale dipende dalla forma nella transazione, non da uno scalare isolato. - probe posizione/ordine del riferimento: - tool: `tools/exp_boundary_reference_position_probe.py`; - report: `tools/data/boundary_reference_position_probe_trial47_20260529.json`; - input: stesso surrogate zero trial `47`, stessi replacement seed reali del ladder, picco massimo amplificato `x3`; - risultato: tutte le varianti con picco `x3` restano `local_global:3`, anche spostando il massimo a inizio, centro, fine, quartili, posizione mappata dell'originale, ordinamento crescente/decrescente e permutazione fissa; - controllo: `zero_reference_base` resta diviso (`local_global:1`, `global_only:1`, `neither:1`); - interpretazione: in questa sonda il recupero non dipende dalla posizione del picco nella sequenza. La firma misurabile e' una soglia di dominanza che il reader riconosce a transazione chiusa; la "posizione nel campo" va cercata come posizione nello spazio delle feature/relazioni, non come indice lineare del gap. - nessuna promozione fisica finche' la robustezza contestuale non e' riprodotta con un secondo verifier e trasformata in ipotesi fisica B verificabile. Output richiesto: - sezione `claim` limitata a cache/provenance/failure audit; - sezione `results` con confronto N=8 vs N=128; - sezione `lacuna` sulla differenza tra originale robusto e null fragile sotto banda intermedia del denominatore; - nessuna promozione pubblica senza Aeternitas/Veritas sopra soglia. Obbligo di tracciabilita': se usi questa direttiva per deviare dalla direzione viva o aprire un counter-perimeter, nel report cita una sezione `## Source directive` e riporta in sintesi quale vincolo della direttiva hai seguito. Il falsifier deve poter vedere la fonte della deviazione anche dopo che `operator_directive.md` e' stato consumato. ## 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. Dinamica di movimento: `fisico A -> matematica -> fisico B`. Non e' una rotta prescritta e non sceglie il dominio al posto del campo. Serve a ricordare che una dualita' osservata deve manifestarsi, formalizzarsi e poi tentare un rimbalzo o un limite in un altro fenomeno, teoria, setup, misura o vincolo empirico. Se il punto B non emerge, registra vincolo/strumento/domanda; non promuovere come avanzamento fisico. ## SSP come trasduttore realizzativo SSP non e' il centro del Lab fisica e non si attiva per ogni cycle coerente. Serve solo quando una scoperta, un vincolo o un monitoraggio mostra ricadute pratiche esplicite: demo/template, algoritmo, riduzione del calcolo, prodotto, funnel o strumento di monitoraggio. Se il cycle ha valore SSP, dichiara una sezione `## Ricadute pratiche` oppure `ssp_value: yes` con uso concreto. Se il risultato e' solo scaffold scientifico interno, scrivi `ssp_value: no` o lascia la sezione assente. ## Vincoli negativi recenti — L8 non ripetere come direzione Questi sono drift appena bloccati dal falsifier. Sono memoria di bordo, non consecutio. Il prossimo report deve seguire `seme.json.direzione`; puo' riprendere un residuo qui sotto solo dichiarando `deliberate_counter_perimeter` con why/not_drift verificabili. - Direzione viva ora: Report giornaliero BOUNDARY Anderson focused chiuso come CONSTRAINT/NO PROMOTION. Bicono completo e falsifier coerente. Rerun fisico L=5,6,7 conferma W20 come unico local_global all-size e W16/W16.5 come zona intermedia, ma feature-scramble null p=0.887 e co-stability graph/localization null p=0.449/0.182 non passano. Misura evolutiva: tautology_risk=0.0, progress_score=0.857, verdict=evolves. Prossimo: perturbation/null fisico Anderson su W16/W16.5/W20, non altra metrica derivata. - Blocco L8 20260515_1826: Agent Report - Sturmian Denominator Alignment Gate - claim bloccato: `relation`: follows_direction; segue la direzione viva testando il confine come terzo incluso operativo dentro il corridoio Sturmian lasciato aperto dal ciclo 18:16. - evidenza: `seme.json.direzione` viva è: "Esplorare il confine: 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo". Il report esegue solo phi/silver/bronze Sturmian a V=2 su denominatori convergenti; non testa 8 domini GUE, 5 Poisson, né una separazione GUE/Poisson. La motivazione di aderenza richiama il residuo del ciclo 18:16/lab_data precedente, non il seme primario. - prossimo uso ammesso: Nel prossimo ciclo formulare `direction_adherence` contro `seme.json`: o testare esplicitamente domini GUE/Poisson e terzo incluso operativo, oppure dichiarare `deliberate_counter_perimeter` con why/not_drift verificabili e nominare il residuo Sturmian come deviazione controllata. Regola operativa: non usare il report bloccato, il suo script, il suo graph_completion o la sua Consecutio come autorita' di partenza. ## Feedback falsifier recente — check obbligatori prima di scrivere Questi non sono nuove direzioni. Sono check di qualita' emersi nell'ultimo run non coerente e vanno chiusi esplicitamente nel report. - Run non coerente: 20260516_1124 - L2: Il null endpoint-preserving e' piu' restrittivo del feature-scramble pieno: `26/512` trial arrivano al conteggio osservato compatto, contro `112/128` del null pieno sul perimetro 11:17. Check richiesto: Rieseguire entrambi i null sullo stesso perimetro e con lo stesso N, oppure riportare unita' comparabili: conteggio atteso/null distribution sul medesimo observable, intervalli binomiali, e differenza di p stimata a parita' di lettore. Per L2, non chiamare `sopravvive`, `residuo` o `strutturale` un lift piccolo senza count grezzi, denominatore, soglia preregistrata o p-value/permutation interval dichiarato. Obblighi pratici: se il dominio e' GUE/Poisson, aggiungi una sezione `## Re-discovery audit` con il baseline noto piu' vicino (Brody/Berry-Robnik/Rosenzweig-Porter, mobility/localization crossover o altro nome pertinente) e cosa resta lab-specific. Per L6, non usare `CE-none` generico: cita una voce CE-* metabolizzata oppure `CE-none:` verificabile. Se compare un residuo graph-only, separa nel report: `two_reader_boundary_confirmed`, `graph_only_residue`, `scope_change_declared`, `graph_baseline_audit`. Non sommare righe graph-only al boundary a due lettori. Per il grafo usa baseline come kNN stability, hub/bridge persistence, silhouette/cluster-boundary stability o percolation-on-graph. ## 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. Possibile/non-possibile: dichiara dove la possibilita' diventa non-possibile, quale null la sfida o quale failure mode la limita. 6. Proiezione: solo dopo scegli osservabile, perimetro, null e misura. 7. Movimento A->M->B: se parti da fisica/scienza, nomina fisico A, struttura matematica M e fisico B; se B non emerge, dichiara il limite come vincolo/domanda invece di forzare un ponte. Se non riesci a compilare questi 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, G=8, T=7, E=4, R=4 **Generatrici/strade dense**: - disc_5: 2 ghost · Metrica primi g=(p/2)², curvatura GUE r=0.503 - report_20260516_1230: 2 ghost · Agent Report - Graph Mechanism Ablation - report_20260516_1148: 2 ghost · Agent Report - Prime Bridge Label Null Audit **Forma del campo**: 9 ponti, 1 vuoto(i), 6 scoperte. **Direzione seme da respirare**: Report giornaliero BOUNDARY Anderson focused chiuso come CONSTRAINT/NO PROMOTION. Bicono completo e falsifier coerente. Rerun fisico L=5,6,7 conferma W20 come unico local_global all-size e W16/W16.5 come zona intermedia, ma feature-scramble null p=0.887 e co-s ## Contratto di aderenza alla traiettoria - Direzione viva del seme: Report giornaliero BOUNDARY Anderson focused chiuso come CONSTRAINT/NO PROMOTION. Bicono completo e falsifier coerente. Rerun fisico L=5,6,7 conferma W20 come unico local_global all-size e W16/W16.5 come zona intermedia, ma feature-scramble null p=0.887 e co-stability graph/localization null p=0.449/0.182 non passano. Misura evolutiva: tautology_risk=0.0, progress_score=0.857, verdict=evolves. Prossimo: perturbation/null fisico Anderson su W16/W16.5/W20, non altra metrica derivata. - Ultima decisione valutatore ammessa: 20260516_1230 REDESIGN/high - Direzione operativa valutatore: Testare null fisici interni per i residui graph-only logistica_biforcazione_var_3.5699 e percolation sul perimetro fisso 8 GUE / 5 Poisson: separare dinamica fisica da ricostruzione del reader grafico - Perche': Il ciclo ha delimitato il reader: label-count null ricostruisce spesso il 27/27 e i due residui non condividono lo stesso meccanismo grafico. La consecutio non e' continuare il confine in forma generica, ma spostare il test al nodo regressivo dichiarato: null fisici interni per logistica/percolation, mantenendo fisso il denominatore 13x27 e chiedendo se il residuo sopravvive fuori dal reader. - Nota: Evitare nuovi domini e nuovi fit. Observable minimo: full 27/27 contro surrogate dinamici interni N-matched per logistica e percolation, con confronto esplicito ai null graph gia' prodotti. Nel report aggiungi una sezione `## Aderenza alla direzione` con tre righe: - `relation`: follows_direction | deliberate_counter_perimeter | local_regression - `why`: perche' l'esperimento serve la direzione viva - `not_drift`: cosa impedisce che sia solo ritorno a un deposito familiare Puoi deviare dalla direzione solo se lo dichiari come contro-perimetro deliberato e lo rendi falsificabile. Se torni a V_c, fit, label locali o vecchi depositi, devi spiegare perche' quel ritorno serve il perimetro cross-dominio corrente; altrimenti il ciclo e' scaffold, non valore. ## 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 exec /bin/bash -lc "sed -n '261,620p' tools/LAB_AGENT_CONTEXT.md" in /opt/MM_D-ND succeeded in 0ms: teoria, setup, misura o vincolo empirico. Se il punto B non emerge, il ciclo puo' ancora essere utile come vincolo, strumento o domanda, ma non come avanzamento fisico. ## Come operare — il modus Non seguire passi. Segui il modus: **espandi → osserva → taglia → risultante**. ### 0. Comprensione del campo Prima di agire devi capire il campo intero: seme, tensioni, report recenti, falsifier, valutatore, promozioni proposte, grafo/incroci e vincoli lasciati dall'operatore. Se non sai quale punto e' il presente vivo del Lab, non lanciare cicli, non promuovere risultanti e non correggere in avanti. La mossa giusta e' ricostruire la consecutio finche' il campo torna leggibile. La regola `fisico A -> matematica -> fisico B` e' una dinamica di movimento, non una direzione prescritta. Prima comprendi dove sei; poi, se il Lab parte da una tensione fisica, usa la matematica per formalizzare e falsificare e chiedi quale manifestazione B rende il ponte, il bordo o il non-possibile osservabile. Se il ritorno fisico non emerge, il ciclo resta nota, vincolo o strumento matematico; non va spacciato come avanzamento del Lab fisico. ### 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. Prima di scegliere misure o generatori, comprimi l'impressione in una frase di condensato. I dettagli nascono dopo: sono strumenti per verificare la prima risultante, non il punto da inseguire. ### 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. - **Nearest-known baseline prima della promozione.** Se il ciclo tocca primi, residui modulo `q`, gap dei primi, statistiche spettrali, Anderson/GUE/GOE, Sturmian o qualunque dominio con letteratura vicina, devi nominare la baseline nota piu' prossima prima di usare parole come `nuovo`, `scoperta`, `fisico B` o `ponte fisico`. Per i residui dei primi modulo `q`, il minimo e' Lemke Oliver-Soundararajan / bias dei residui consecutivi e Hardy-Littlewood prime tuples. Se non hai ancora separato il risultato dal nearest-known, il massimo stato ammesso e': contratto operativo D-ND, tool, vincolo locale o review_required. Non promuovere il report. - **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. - Se la tensione nasce nel fisico, non fermarti nella matematica. Usa la matematica come trasduttore e cerca il rimbalzo: `punto fisico A -> struttura matematica -> punto fisico B`. Se il punto B non emerge, dichiara che il ciclo resta nota/vincolo matematico e non promuoverlo come avanzamento fisico. - Il rimbalzo fisico non puo' saltare il nearest-known baseline. Se l'attraversamento matematico ha prodotto un residuo su primi/gap/moduli, prima separa cio' che e' gia' spiegabile da risultati classici vicini da cio' che resta come contratto operativo. Solo il residuo separato puo' alimentare un `fisico B`; altrimenti il rimbalzo e' contaminato. ## Formato report ```markdown # Agent Report — TITOLO **Date**: YYYY-MM-DD HH:MM **Piano**: N **Tension explored**: ID (intensità) observables_used: [nomi osservabili canonici o domain-native] - usa [] solo se non hai misurato nulla **observable_contract**: claim=; observable=; operator=; generator=; denominator=; non_possible=; not_tested= ## Respiro fuori-tempo (Obbligatorio. Compilalo prima dell'esperimento, non dopo.) - **Combo**: almeno tre enti simultanei (assioma D-ND + incrocio teorie + nodo del grafo/dipolo + tensione seme) - **Dipolo / punto-zero**: i due poli, il possibile/non-possibile 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 - **Movimento A->M->B**: se il ciclo parte da fisica/scienza, nomina fisico A, struttura matematica M e fisico B; se B non c'e', dichiara il limite senza forzare un ponte. ## Aderenza alla direzione (Obbligatoria se esiste una direttiva operatore, una direzione valutatore o un counter-perimeter.) - `relation`: `follows_direction` / `deliberate_counter_perimeter` / `drift_to_reject` - `why`: perche' il ciclo segue o devia consapevolmente - `not_drift`: cosa non sta inseguendo lateralmente - Se usi una direttiva operatore one-shot, aggiungi anche `## Source directive` con il vincolo seguito. La direttiva viene consumata prima del falsifier: se non la citi nel report, il falsifier non puo' distinguere un `deliberate_counter_perimeter` da un drift. ## 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 ## Ritorno fisico (Obbligatorio quando la tensione, il claim o la combo partono da un attrito fisico/scientifico. Se non applicabile, scrivi `non_applicabile` e perche'.) - **Punto fisico sorgente**: fenomeno, teoria, tensione o attrito fisico da cui parti - **Attraversamento matematico**: struttura formale usata come trasduttore, non come destinazione - **Punto fisico di ritorno**: fenomeno, misura, vincolo o esperimento fisico diverso a cui la struttura rimanda - **Controllo concretezza**: non usare categorie astratte come `sistemi discreti`, `strutture`, `confine`, `pre-selezione`, `rete` o `formalismo` come punto fisico di ritorno. Nomina un fenomeno, teoria fisica, setup sperimentale, misura, campo, particella, transizione o vincolo empirico. - **Relazione nuova**: che ponte si apre tra sorgente e ritorno - **Osservabile/test fisico possibile**: come il ponte puo' essere verificato o falsificato - **Se fallisce**: `ritorno_fisico_assente` + motivo; resta vault/cimitero, vincolo matematico o domanda, non scoperta fisica promuovibile ## 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, non_possible/null, 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 "sed -n '1,220p' shared_memory/README.md" in /opt/MM_D-ND succeeded in 0ms: # shared_memory — Cross-agent rules e cristalli > Cartella condivisa tra agenti che operano in `/opt/MM_D-ND/`: > - **TM3-claude** (Claude Code, sessioni interattive con operatore) > - **codex-lab** (Codex CLI, cycle agent notturno + run manuali) > - **eventuali altri** (TM5, TM7, futuri cycle) > > Contiene regole permanenti, cristalli operativi, scoperte rilevanti che valgono > per più di un agente. **Non** memoria operativa locale (quella resta in > `~/.claude/projects/.../memory/` per TM3, in `~/.codex_lab/memories/` per codex). ## Pattern di scrittura Ogni file: - Filename: `__.md` (es. `feedback_cycletest_2026-05-07.md`, `cristallo_gate_transferability_2026-05-07.md`) - Frontmatter: ```yaml --- type: feedback | cristallo | regola | finding-cross-agent author: TM3 | codex-lab | TM7 | operatore date: YYYY-MM-DD scope: cross-agent | mm-dnd-only | lab-cycle-only --- ``` - Body: conciso. Se è regola → "Why" + "How to apply". Se è cristallo → contesto + insight + how it changes work. ## Pattern di lettura - **TM3 (claude code)**: al boot di sessione su `/opt/MM_D-ND/`, leggi `MM_D-ND/.claude/CLAUDE.md` che adesso punta qui (sezione *Cross-agent rules*). Scansiona `ls -t shared_memory/*.md | head -10` (le più recenti) e integra in contesto. - **codex-lab**: `/opt/MM_D-ND/AGENTS.md` punta qui. Codex legge AGENTS.md ad ogni cycle, AGENTS.md istruisce di leggere shared_memory. - **Cleanup**: file > 90 giorni e non rilevanti vanno archiviati o rimossi (lo fa TM3 quando la cartella supera 50 file). ## Direzione bidirezionale - TM3 → codex: TM3 scrive feedback/cristalli da sessioni operatore qui → codex li vede al cycle dopo via AGENTS.md. - codex → TM3: codex durante un cycle scopre/cristallizza qualcosa di cross-agent → scrive qui → TM3 li vede al boot di sessione successiva. Il flusso non sostituisce le memorie locali — *integra* per ciò che serve a tutti. ## Anti-pattern - Duplicare qui regole che valgono SOLO per TM3 (vanno in `/root/.claude/projects/.../memory/`) - Duplicare qui regole che valgono SOLO per codex-lab cycle (vanno in `/root/.codex_lab/memories/`) - Scrivere note di lavoro temporanee (vanno nel campo vivo, non qui) exec /bin/bash -lc "sed -n '1,220p' shared_memory/feedback_indeterminato_reitera_con_sistema_2026-05-07.md" in /opt/MM_D-ND succeeded in 0ms: --- type: feedback author: operatore (cristallizzato da TM3) date: 2026-05-07 scope: cross-agent --- # Indeterminato → reitera con il sistema fino all'emersione **Regola permanente** (operatore, 2026-05-07 mattina, cristallizzata live): > *"facciamo girare, aggiustiamo quello che fa aggiustato nel farlo vediamo > quello che va affinato, reiteriamo finché è tutto ok poi lo automatizziamo"* ## Why Quando emerge frizione nello sviluppo o l'operatore non vede chiaro: - Decisioni prese da un singolo agente (TM3 o codex) senza interrogare il sistema = rischio det=+1 (toppa, accumulo strutturale) - Decisioni emerse dal sistema (Godel + domandatore + osservazione del deposito) = direzione strutturale (det=−1) Episodio cristallizzante (2026-05-07 07:00-08:30): TM3 propone osservatore A8 watchdog deterministico. Sistema interrogato 3 volte (Godel #1, #2, #3 + domandatore + test empirico) — al terzo round emerge la direzione vera: **non costruire osservatore, eseguire un cycle-test che diagnostica il sistema da solo**. Cycle-test eseguito → verdict=operator → REDESIGN proposto dal valutatore → loop A8+A15 sbloccato. ## How to apply (per qualsiasi agente) 1. **Esegui** un atto minimo (no design teorico astratto) 2. **Aggiusta** quello che si manifesta durante l'esecuzione (riparazione regressiva live, non patch posteriori) 3. **Osserva** il deposito che emerge (no immaginazione) 4. **Reitera** fino a stato OK (loop A8: il sistema converge se modus radicato) 5. **Cristallizza in automazione** SOLO dopo che è stato fatto girare e ha mostrato stabilità — non automatizzare prima ## Anti-pattern - Costruire un componente strutturale (watchdog, observer, gate, governor) senza prima aver fatto girare un'esecuzione minima che mostri cosa serve davvero - Decidere "perché serve velocità" o "per ottimizzare" senza interrogare il sistema - Astrazione prematura (premature abstraction): 3 simili è meglio di 1 generalizzato troppo presto ## Cross-link - TM3 memoria: `/root/.claude/projects/-opt/memory/feedback_indeterminato_reitera_con_sistema.md` (versione completa con episodio + metafora foresta-sentiero) - Verifica empirica: cycle `20260507_0803` (verdict=operator, REDESIGN/high) - Pattern A8+A15 (autologica + veicolo senza guidatore) applicato allo sviluppo software stesso, non solo al lab di ricerca exec /bin/bash -lc "sed -n '1,220p' shared_memory/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) codex La risultante utile è già indicata dalla direttiva: non un nuovo dominio, ma una misura macro che confronta originale e null per denominatore/lettore. Ora ispeziono gli artefatti esistenti per costruire una tabella row-aligned senza cambiare le sorgenti. exec /bin/bash -lc 'head -5 tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"experiment": "boundary_physical_internal_null_cache_row_aligned", "params": {"k_values": [2, 3, 4], "logistic_block_size": 34, "n_gaps_values": [512, 1024, 2048], "n_shuffle": 32, "null_seed": 202605290001, "null_trials": 128, "percolation_lattice": 48, "percolation_p": 0.5927, "percolation_samples": 200, "reader_runs": 27, "scope": "tools/data/boundary_denominator_prescan_full_20260509_1500.json", "seeds": [20260515, 20260516, 20260517], "targets": ["logistica_biforcazione_var_3.5699:cycle_13", "percolation:cycle_9"]}, "question": "Which target/trial/reader rows reconstruct physical-internal null hits under full, centroid-only and kNN-only readers?", "row_spacings_provenance": {"domain_seeds": {"brownian_motion:cycle_12": {"domain": "brownian_motion", "seed": 122252476}, "cellular_automata:cycle_8": {"domain": "cellular_automata", "seed": 1602944734}, "coupled_oscillators:cycle_10": {"domain": "coupled_oscillators", "seed": 1226273018}, "ising_2d:cycle_1": {"domain": "ising_2d", "seed": 2979832589}, "logistica_biforcazione:cycle_5": {"domain": "logistica_biforcazione", "seed": 2543766472}, "logistica_biforcazione_var_3.5699:cycle_13": {"domain": "logistica_biforcazione_var_3.5699", "seed": 2298612439}, "numeri_primi:cycle_3": {"domain": "numeri_primi", "seed": 2149417817}, "pendolo_doppio:cycle_2": {"domain": "pendolo_doppio", "seed": 123506562}, "percolation:cycle_9": {"domain": "percolation", "seed": 2828479326}, "random_matrix:cycle_7": {"domain": "random_matrix", "seed": 1975849338}, "reaction_diffusion:cycle_11": {"domain": "reaction_diffusion", "seed": 1406704140}, "string_vibration:cycle_6": {"domain": "string_vibration", "seed": 1667741782}, "zeta_zeros:cycle_4": {"domain": "zeta_zeros", "seed": 3393297592}}, "seed_salt": "boundary-row-spacings-v1"}, "type": "metadata"} {"null_meta": {"block_size": 34, "breaks": "long-range gap order induced by the orbit reader", "null": "logistic_gap_block_shuffle", "preserves": "gap marginal and local contiguous blocks", "surrogate_seed": 4002066895599915386}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 512, "n_shuffle": 32, "replacement_feature_seed": 4919215738134318915, "seed": 20260515}, "reader_index": 0, "source": {"domain": "logistica_biforcazione_var_3.5699", "domain_seed": 2298612439, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "GUE"}, "target": "logistica_biforcazione_var_3.5699:cycle_13", "target_features": {"n_gaps_available": 4727, "n_gaps_used": 512, "observables": {"L1": -0.003984091, "L2": -0.004001929, "SR": 0.571705019, "SR2": 0.372534329, "SR_local_rigidity": 81.686245305, "triple_var": 121.108662915}, "shuffle_z": {"L1": -0.232464, "L2": -0.336236, "SR": 46.156369, "SR2": 27.094386, "triple_var": 0.116424}}, "trial": 0, "type": "cache_row"} {"null_meta": {"block_size": 34, "breaks": "long-range gap order induced by the orbit reader", "null": "logistic_gap_block_shuffle", "preserves": "gap marginal and local contiguous blocks", "surrogate_seed": 4002066895599915386}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 512, "n_shuffle": 32, "replacement_feature_seed": 1040926662185324515, "seed": 20260516}, "reader_index": 1, "source": {"domain": "logistica_biforcazione_var_3.5699", "domain_seed": 2298612439, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "GUE"}, "target": "logistica_biforcazione_var_3.5699:cycle_13", "target_features": {"n_gaps_available": 4727, "n_gaps_used": 512, "observables": {"L1": -0.003984091, "L2": -0.004001929, "SR": 0.571705019, "SR2": 0.372534329, "SR_local_rigidity": 81.686245305, "triple_var": 121.108662915}, "shuffle_z": {"L1": -0.251999, "L2": -0.323639, "SR": 61.295917, "SR2": 28.078777, "triple_var": -0.196264}}, "trial": 0, "type": "cache_row"} {"null_meta": {"block_size": 34, "breaks": "long-range gap order induced by the orbit reader", "null": "logistic_gap_block_shuffle", "preserves": "gap marginal and local contiguous blocks", "surrogate_seed": 4002066895599915386}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 512, "n_shuffle": 32, "replacement_feature_seed": 110277504262484454, "seed": 20260517}, "reader_index": 2, "source": {"domain": "logistica_biforcazione_var_3.5699", "domain_seed": 2298612439, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "GUE"}, "target": "logistica_biforcazione_var_3.5699:cycle_13", "target_features": {"n_gaps_available": 4727, "n_gaps_used": 512, "observables": {"L1": -0.003984091, "L2": -0.004001929, "SR": 0.571705019, "SR2": 0.372534329, "SR_local_rigidity": 81.686245305, "triple_var": 121.108662915}, "shuffle_z": {"L1": -0.264516, "L2": -0.185732, "SR": 48.544144, "SR2": 29.793374, "triple_var": -0.176788}}, "trial": 0, "type": "cache_row"} {"null_meta": {"block_size": 34, "breaks": "long-range gap order induced by the orbit reader", "null": "logistic_gap_block_shuffle", "preserves": "gap marginal and local contiguous blocks", "surrogate_seed": 4002066895599915386}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 1024, "n_shuffle": 32, "replacement_feature_seed": 4209179455282880149, "seed": 20260515}, "reader_index": 3, "source": {"domain": "logistica_biforcazione_var_3.5699", "domain_seed": 2298612439, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "GUE"}, "target": "logistica_biforcazione_var_3.5699:cycle_13", "target_features": {"n_gaps_available": 4727, "n_gaps_used": 1024, "observables": {"L1": -0.003894377, "L2": -0.003905556, "SR": 0.570748725, "SR2": 0.366900691, "SR_local_rigidity": 138.389347681, "triple_var": 114.422696906}, "shuffle_z": {"L1": -0.399939, "L2": -0.27617, "SR": 74.387766, "SR2": 50.815856, "triple_var": -0.319}}, "trial": 0, "type": "cache_row"} exec /bin/bash -lc 'tail -5 tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1172556284631405664}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 1024, "n_shuffle": 32, "replacement_feature_seed": 5449311303764024516, "seed": 20260517}, "reader_index": 23, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 172, "n_gaps_used": 172, "observables": {"L1": 0.19077753, "L2": 0.012083962, "SR": 0.467851786, "SR2": 0.451216589, "SR_local_rigidity": 0.580281354, "triple_var": 6.468582239}, "shuffle_z": {"L1": 2.911779, "L2": 0.364559, "SR": 0.940497, "SR2": 0.057198, "triple_var": 0.844599}}, "trial": 127, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1172556284631405664}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 2048, "n_shuffle": 32, "replacement_feature_seed": 5940649003009404594, "seed": 20260515}, "reader_index": 24, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 172, "n_gaps_used": 172, "observables": {"L1": 0.19077753, "L2": 0.012083962, "SR": 0.467851786, "SR2": 0.451216589, "SR_local_rigidity": 0.580281354, "triple_var": 6.468582239}, "shuffle_z": {"L1": 2.910629, "L2": 0.269466, "SR": 1.271808, "SR2": 0.465077, "triple_var": 0.726679}}, "trial": 127, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1172556284631405664}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 2048, "n_shuffle": 32, "replacement_feature_seed": 7308942652648876069, "seed": 20260516}, "reader_index": 25, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 172, "n_gaps_used": 172, "observables": {"L1": 0.19077753, "L2": 0.012083962, "SR": 0.467851786, "SR2": 0.451216589, "SR_local_rigidity": 0.580281354, "triple_var": 6.468582239}, "shuffle_z": {"L1": 2.905113, "L2": 0.623946, "SR": 1.204008, "SR2": 0.501908, "triple_var": 0.9524}}, "trial": 127, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1172556284631405664}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 2048, "n_shuffle": 32, "replacement_feature_seed": 5302672909855824497, "seed": 20260517}, "reader_index": 26, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 172, "n_gaps_used": 172, "observables": {"L1": 0.19077753, "L2": 0.012083962, "SR": 0.467851786, "SR2": 0.451216589, "SR_local_rigidity": 0.580281354, "triple_var": 6.468582239}, "shuffle_z": {"L1": 2.629186, "L2": 0.545887, "SR": 1.451881, "SR2": 0.266165, "triple_var": 0.735525}}, "trial": 127, "type": "cache_row"} {"summary": {"logistica_biforcazione_var_3.5699:cycle_13": {"centroid_hit_distribution": {"26": 1, "27": 127}, "full_hit_distribution": {"26": 2, "27": 126}, "knn_hit_distribution": {"26": 1, "27": 127}, "observed_hits": 26}, "percolation:cycle_9": {"centroid_hit_distribution": {"19": 1, "21": 1, "24": 2, "25": 2, "26": 2, "27": 120}, "full_hit_distribution": {"19": 1, "21": 1, "24": 2, "25": 2, "26": 3, "27": 119}, "knn_hit_distribution": {"26": 1, "27": 127}, "observed_hits": 27}}, "type": "summary"} exec /bin/bash -lc 'head -5 tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"experiment": "boundary_physical_internal_null_cache_row_aligned", "params": {"k_values": [2, 3, 4], "logistic_block_size": 34, "n_gaps_values": [192, 256, 384, 512, 768, 1024, 1536], "n_shuffle": 32, "null_seed": 202605290003, "null_trials": 96, "percolation_lattice": 48, "percolation_p": 0.5927, "percolation_samples": 200, "reader_runs": 63, "scope": "tools/data/boundary_denominator_prescan_full_20260509_1500.json", "seeds": [20260515, 20260516, 20260517], "targets": ["percolation:cycle_9"]}, "question": "Which target/trial/reader rows reconstruct physical-internal null hits under full, centroid-only and kNN-only readers?", "row_spacings_provenance": {"domain_seeds": {"brownian_motion:cycle_12": {"domain": "brownian_motion", "seed": 122252476}, "cellular_automata:cycle_8": {"domain": "cellular_automata", "seed": 1602944734}, "coupled_oscillators:cycle_10": {"domain": "coupled_oscillators", "seed": 1226273018}, "ising_2d:cycle_1": {"domain": "ising_2d", "seed": 2979832589}, "logistica_biforcazione:cycle_5": {"domain": "logistica_biforcazione", "seed": 2543766472}, "logistica_biforcazione_var_3.5699:cycle_13": {"domain": "logistica_biforcazione_var_3.5699", "seed": 2298612439}, "numeri_primi:cycle_3": {"domain": "numeri_primi", "seed": 2149417817}, "pendolo_doppio:cycle_2": {"domain": "pendolo_doppio", "seed": 123506562}, "percolation:cycle_9": {"domain": "percolation", "seed": 2828479326}, "random_matrix:cycle_7": {"domain": "random_matrix", "seed": 1975849338}, "reaction_diffusion:cycle_11": {"domain": "reaction_diffusion", "seed": 1406704140}, "string_vibration:cycle_6": {"domain": "string_vibration", "seed": 1667741782}, "zeta_zeros:cycle_4": {"domain": "zeta_zeros", "seed": 3393297592}}, "seed_salt": "boundary-row-spacings-v1"}, "type": "metadata"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1888500348059881088}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 192, "n_shuffle": 32, "replacement_feature_seed": 4607707654638271858, "seed": 20260515}, "reader_index": 0, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 173, "n_gaps_used": 173, "observables": {"L1": 0.080031955, "L2": 0.154514473, "SR": 0.482783965, "SR2": 0.440687963, "SR_local_rigidity": 0.522258227, "triple_var": 3.611655266}, "shuffle_z": {"L1": 1.493071, "L2": 2.098603, "SR": 1.355532, "SR2": -0.591153, "triple_var": 1.75499}}, "trial": 0, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1888500348059881088}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 192, "n_shuffle": 32, "replacement_feature_seed": 4205368566732664057, "seed": 20260516}, "reader_index": 1, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 173, "n_gaps_used": 173, "observables": {"L1": 0.080031955, "L2": 0.154514473, "SR": 0.482783965, "SR2": 0.440687963, "SR_local_rigidity": 0.522258227, "triple_var": 3.611655266}, "shuffle_z": {"L1": 1.210928, "L2": 2.21108, "SR": 1.14782, "SR2": -1.030061, "triple_var": 1.789221}}, "trial": 0, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1888500348059881088}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 192, "n_shuffle": 32, "replacement_feature_seed": 2549801745737587460, "seed": 20260517}, "reader_index": 2, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 173, "n_gaps_used": 173, "observables": {"L1": 0.080031955, "L2": 0.154514473, "SR": 0.482783965, "SR2": 0.440687963, "SR_local_rigidity": 0.522258227, "triple_var": 3.611655266}, "shuffle_z": {"L1": 1.021678, "L2": 1.88659, "SR": 1.160805, "SR2": -0.624827, "triple_var": 1.414206}}, "trial": 0, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 1888500348059881088}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 2, "n_gaps": 256, "n_shuffle": 32, "replacement_feature_seed": 4692079993826576603, "seed": 20260515}, "reader_index": 3, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 173, "n_gaps_used": 173, "observables": {"L1": 0.080031955, "L2": 0.154514473, "SR": 0.482783965, "SR2": 0.440687963, "SR_local_rigidity": 0.522258227, "triple_var": 3.611655266}, "shuffle_z": {"L1": 1.294354, "L2": 2.503136, "SR": 1.569242, "SR2": -0.333216, "triple_var": 2.02439}}, "trial": 0, "type": "cache_row"} exec /bin/bash -lc 'tail -5 tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 213798661275746807}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 1024, "n_shuffle": 32, "replacement_feature_seed": 235194419995870811, "seed": 20260517}, "reader_index": 59, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 179, "n_gaps_used": 179, "observables": {"L1": 0.173366467, "L2": 0.077805012, "SR": 0.479018134, "SR2": 0.429224487, "SR_local_rigidity": 0.398524884, "triple_var": 4.12354593}, "shuffle_z": {"L1": 1.813958, "L2": 0.759546, "SR": 2.411789, "SR2": -0.942456, "triple_var": -0.396056}}, "trial": 95, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 213798661275746807}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 1536, "n_shuffle": 32, "replacement_feature_seed": 2376291602671327052, "seed": 20260515}, "reader_index": 60, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 179, "n_gaps_used": 179, "observables": {"L1": 0.173366467, "L2": 0.077805012, "SR": 0.479018134, "SR2": 0.429224487, "SR_local_rigidity": 0.398524884, "triple_var": 4.12354593}, "shuffle_z": {"L1": 2.358187, "L2": 1.359229, "SR": 1.643512, "SR2": -0.703872, "triple_var": -0.049392}}, "trial": 95, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 213798661275746807}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 1536, "n_shuffle": 32, "replacement_feature_seed": 5886218488548077918, "seed": 20260516}, "reader_index": 61, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 179, "n_gaps_used": 179, "observables": {"L1": 0.173366467, "L2": 0.077805012, "SR": 0.479018134, "SR2": 0.429224487, "SR_local_rigidity": 0.398524884, "triple_var": 4.12354593}, "shuffle_z": {"L1": 2.428104, "L2": 0.974598, "SR": 1.979489, "SR2": -0.483872, "triple_var": -0.02602}}, "trial": 95, "type": "cache_row"} {"null_meta": {"breaks": "specific cluster geometry realization used by the original row", "lattice": 48, "null": "critical_site_percolation_cluster_geometry_resample", "p": 0.5927, "preserves": "critical percolation generator and largest-cluster observable", "samples": 200, "surrogate_seed": 213798661275746807}, "outputs": {"centroid_only_hit": true, "full_reader_hit": true, "knn_only_hit": true}, "reader": {"k": 4, "n_gaps": 1536, "n_shuffle": 32, "replacement_feature_seed": 5205688127052001917, "seed": 20260517}, "reader_index": 62, "source": {"domain": "percolation", "domain_seed": 2828479326, "row_spacings_seed_salt": "boundary-row-spacings-v1", "source_domain_type": "Poisson"}, "target": "percolation:cycle_9", "target_features": {"n_gaps_available": 179, "n_gaps_used": 179, "observables": {"L1": 0.173366467, "L2": 0.077805012, "SR": 0.479018134, "SR2": 0.429224487, "SR_local_rigidity": 0.398524884, "triple_var": 4.12354593}, "shuffle_z": {"L1": 2.302849, "L2": 1.250687, "SR": 1.848177, "SR2": -0.712389, "triple_var": -0.0232}}, "trial": 95, "type": "cache_row"} {"summary": {"percolation:cycle_9": {"centroid_hit_distribution": {"35": 1, "39": 1, "56": 1, "58": 2, "61": 1, "62": 2, "63": 88}, "full_hit_distribution": {"35": 1, "39": 1, "56": 1, "58": 2, "61": 1, "62": 2, "63": 88}, "knn_hit_distribution": {"63": 96}, "observed_hits": 63}}, "type": "summary"} exec /bin/bash -lc "sed -n '1,240p' tools/exp_boundary_transition_matrix.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ Build a transition matrix from a contextual transaction detector report. This is a compression layer above row-level cache audits. It turns the convergent/non-convergent signature into a small matrix: original state -> physical-internal null state States are defined by two operational predicates: - local: kNN cross-neighbor fraction > threshold; - global: centroid margin < threshold. The matrix is not a promotion gate. It is a projection aid for the Lab's resultant: where does a target keep local/global inclusion, and where does the null lose one side of the transaction? """ from __future__ import annotations import argparse import json from pathlib import Path from typing import Any STATE_LABELS = { "local=1,global=1,transaction=0": "local_global", "local=1,global=0,transaction=1": "local_only", "local=0,global=1,transaction=0": "global_only", "local=0,global=0,transaction=0": "neither", } def load_json(path: Path) -> dict[str, Any]: with path.open(encoding="utf-8") as f: data = json.load(f) if not isinstance(data, dict): raise ValueError(f"{path} must contain a JSON object") return data def normalize_counts(raw: dict[str, int]) -> dict[str, int]: out = {label: 0 for label in STATE_LABELS.values()} for key, value in raw.items(): out[STATE_LABELS.get(key, key)] = int(value) return out def rate(count: int, total: int) -> float: return round(count / total, 9) if total else 0.0 def load_reference_probe(path: str) -> dict[str, Any] | None: if not path: return None probe = load_json(Path(path)) variants = probe.get("variants", {}) if not isinstance(variants, dict): raise ValueError(f"{path} has no variants object") rows = {} candidate_ratios = [] for name, data in variants.items(): counts = data.get("state_counts", {}) total = sum(int(value) for value in counts.values()) local_global = int(counts.get("local_global", 0)) gap = data.get("gap_summary", {}) ratio = gap.get("max_q90_ratio") row = { "state_counts": counts, "dominance_ratio": ratio, "max_position_ratio": gap.get("max_position_ratio"), "all_local_global": total > 0 and local_global == total, } rows[name] = row if name.startswith("zero_") and row["all_local_global"] and ratio is not None: candidate_ratios.append(float(ratio)) zero_base = rows.get("zero_reference_base", {}) return { "source": path, "status": "candidate_reference_not_claim", "contract": "dominance_ratio = max / q90 on the target gap sequence", "zero_base_dominance_ratio": zero_base.get("dominance_ratio"), "candidate_recovery_dominance_ratio_min": min(candidate_ratios) if candidate_ratios else None, "interpretation": ( "Reference recovery is currently measured as a dominance threshold recognized " "by the closed reader transaction, not as scalar tail size alone and not as " "linear gap-index position alone." ), "variants": rows, } def run(args: argparse.Namespace) -> dict[str, Any]: detector = load_json(Path(args.detector)) counts = detector.get("counts", {}) metrics = detector.get("metrics", {}) params = detector.get("params", {}) total = int(counts.get("cache_rows", 0)) if total <= 0: raise ValueError("detector report has no cache_rows") original_margin = metrics.get("original_centroid_margin", {}) original_cross = metrics.get("original_cross_neighbor_fraction", {}) centroid_margin_max = float(params.get("centroid_margin_max", args.centroid_margin_max)) cross_min = float(params.get("cross_min", args.cross_min)) original_local_all = (original_cross.get("min") is not None) and float(original_cross["min"]) > cross_min original_global_all = (original_margin.get("max") is not None) and float(original_margin["max"]) < centroid_margin_max original_state = ( "local_global" if original_local_all and original_global_all else "mixed_or_unverified" ) null_state_counts = normalize_counts(counts.get("condition_patterns", {})) by_denominator = {} for denominator, raw_counts in sorted( counts.get("condition_by_denominator", {}).items(), key=lambda item: int(item[0]), ): denom_total = sum(int(v) for v in raw_counts.values()) state_counts = normalize_counts(raw_counts) by_denominator[denominator] = { "total": denom_total, "states": state_counts, "rates": {state: rate(value, denom_total) for state, value in state_counts.items()}, } local_global = null_state_counts.get("local_global", 0) local_only = null_state_counts.get("local_only", 0) global_only = null_state_counts.get("global_only", 0) neither = null_state_counts.get("neither", 0) output = { "experiment": "boundary_transition_matrix", "question": "How does the target transition from original local/global inclusion to physical-internal null inclusion states?", "detector": args.detector, "target": detector.get("target"), "source_cache": detector.get("cache"), "state_contract": { "local": f"cross_neighbor_fraction > {cross_min}", "global": f"centroid_margin < {centroid_margin_max}", "local_global": "local convergent and global convergent", "local_only": "local convergent and global non-convergent", "global_only": "local non-convergent and global convergent", "neither": "local non-convergent and global non-convergent", }, "original": { "reader_runs": counts.get("original_reader_runs"), "state": original_state, "centroid_margin": original_margin, "cross_neighbor_fraction": original_cross, }, "null": { "rows": total, "states": null_state_counts, "rates": {state: rate(value, total) for state, value in null_state_counts.items()}, "by_denominator": by_denominator, }, "transition_matrix": { original_state: { "local_global": local_global, "local_only": local_only, "global_only": global_only, "neither": neither, } }, "transition_rates": { original_state: { "local_global": rate(local_global, total), "local_only": rate(local_only, total), "global_only": rate(global_only, total), "neither": rate(neither, total), } }, "interpretation": { "dominant_state": max(null_state_counts, key=null_state_counts.get), "transaction_state": "local_only", "transaction_count": local_only, "transaction_rate": rate(local_only, total), "boundary": "projection aid only; not a promotion gate", }, "possibility_reference": { "status": "candidate_reference_not_claim", "definition": "The reference is the quality preserved/lost in transition, not either endpoint alone.", "preserved_quality": "local convergence", "lost_quality": "global/centroid convergence", "transition": f"{original_state}->local_only", "rate": rate(local_only, total), "interpretation": ( "If stable across independent verifiers, this rate/state pattern can act as a " "reference for the quality of possibility transferred by the transaction." ), "boundary": "Do not call this transcendental information unless it persists across independent physical-B tests.", }, } reference_probe = load_reference_probe(args.reference_probe) if reference_probe is not None: output["reference_probe"] = reference_probe out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") print(f"wrote={out}") print( json.dumps( { "original_state": original_state, "null_states": output["null"]["states"], "transition_rates": output["transition_rates"], "transaction_rate": output["interpretation"]["transaction_rate"], }, indent=2, sort_keys=True, ) ) return output def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--detector", required=True) parser.add_argument("--out", default="tools/data/boundary_transition_matrix.json") parser.add_argument("--reference-probe", default="") parser.add_argument("--centroid-margin-max", type=float, default=0.25) parser.add_argument("--cross-min", type=float, default=0.0) run(parser.parse_args()) if __name__ == "__main__": main() codex Sto trasformando l’audit manuale in un piccolo strumento riusabile: leggerà le cache JSONL, comprimerà distribuzioni, failure trial e recupero per denominatore. Questo mantiene l’esperimento come post-process deterministico sugli artefatti già generati, senza rilanciare simulazioni fisiche. exec /bin/bash -lc 'tail -1 tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"summary": {"logistica_biforcazione_var_3.5699:cycle_13": {"centroid_hit_distribution": {"27": 8}, "full_hit_distribution": {"27": 8}, "knn_hit_distribution": {"27": 8}, "observed_hits": 26}, "percolation:cycle_9": {"centroid_hit_distribution": {"27": 8}, "full_hit_distribution": {"27": 8}, "knn_hit_distribution": {"27": 8}, "observed_hits": 27}}, "type": "summary"} exec /bin/bash -lc 'tail -1 tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl' in /opt/MM_D-ND succeeded in 0ms: {"summary": {"percolation:cycle_9": {"centroid_hit_distribution": {"43": 1, "52": 2, "54": 61}, "full_hit_distribution": {"43": 1, "51": 1, "52": 1, "54": 61}, "knn_hit_distribution": {"52": 1, "54": 63}, "observed_hits": 54}}, "type": "summary"} exec /bin/bash -lc "sed -n '1,220p' tools/data/boundary_transition_matrix_percolation_band_20260529.json" in /opt/MM_D-ND succeeded in 0ms: { "detector": "tools/data/boundary_contextual_transaction_detector_percolation_band_20260529.json", "experiment": "boundary_transition_matrix", "interpretation": { "boundary": "projection aid only; not a promotion gate", "dominant_state": "local_global", "transaction_count": 73, "transaction_rate": 0.012070106, "transaction_state": "local_only" }, "null": { "by_denominator": { "1024": { "rates": { "global_only": 0.0, "local_global": 0.998842593, "local_only": 0.001157407, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 863, "local_only": 1, "neither": 0 }, "total": 864 }, "1536": { "rates": { "global_only": 0.0, "local_global": 1.0, "local_only": 0.0, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 864, "local_only": 0, "neither": 0 }, "total": 864 }, "192": { "rates": { "global_only": 0.0, "local_global": 0.96875, "local_only": 0.03125, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 837, "local_only": 27, "neither": 0 }, "total": 864 }, "256": { "rates": { "global_only": 0.0, "local_global": 0.991898148, "local_only": 0.008101852, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 857, "local_only": 7, "neither": 0 }, "total": 864 }, "384": { "rates": { "global_only": 0.0, "local_global": 0.976851852, "local_only": 0.023148148, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 844, "local_only": 20, "neither": 0 }, "total": 864 }, "512": { "rates": { "global_only": 0.0, "local_global": 0.989583333, "local_only": 0.010416667, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 855, "local_only": 9, "neither": 0 }, "total": 864 }, "768": { "rates": { "global_only": 0.0, "local_global": 0.989583333, "local_only": 0.010416667, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 855, "local_only": 9, "neither": 0 }, "total": 864 } }, "rates": { "global_only": 0.0, "local_global": 0.987929894, "local_only": 0.012070106, "neither": 0.0 }, "rows": 6048, "states": { "global_only": 0, "local_global": 5975, "local_only": 73, "neither": 0 } }, "original": { "centroid_margin": { "max": 0.21993605724649373, "mean": 0.17182890078100768, "min": 0.1170871757102433 }, "cross_neighbor_fraction": { "max": 1.0, "mean": 0.7103930461073316, "min": 0.5 }, "reader_runs": 63, "state": "local_global" }, "possibility_reference": { "boundary": "Do not call this transcendental information unless it persists across independent physical-B tests.", "definition": "The reference is the quality preserved/lost in transition, not either endpoint alone.", "interpretation": "If stable across independent verifiers, this rate/state pattern can act as a reference for the quality of possibility transferred by the transaction.", "lost_quality": "global/centroid convergence", "preserved_quality": "local convergence", "rate": 0.012070106, "status": "candidate_reference_not_claim", "transition": "local_global->local_only" }, "question": "How does the target transition from original local/global inclusion to physical-internal null inclusion states?", "source_cache": "tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl", "state_contract": { "global": "centroid_margin < 0.25", "global_only": "local non-convergent and global convergent", "local": "cross_neighbor_fraction > 0.0", "local_global": "local convergent and global convergent", "local_only": "local convergent and global non-convergent", "neither": "local non-convergent and global non-convergent" }, "target": "percolation:cycle_9", "transition_matrix": { "local_global": { "global_only": 0, "local_global": 5975, "local_only": 73, "neither": 0 } }, "transition_rates": { "local_global": { "global_only": 0.0, "local_global": 0.987929894, "local_only": 0.012070106, "neither": 0.0 } } } exec /bin/bash -lc "sed -n '1,220p' tools/data/boundary_contextual_transaction_detector_percolation_band_20260529.json" in /opt/MM_D-ND succeeded in 0ms: { "cache": "tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl", "counts": { "cache_rows": 6048, "condition_by_denominator": { "1024": { "local=1,global=0,transaction=1": 1, "local=1,global=1,transaction=0": 863 }, "1536": { "local=1,global=1,transaction=0": 864 }, "192": { "local=1,global=0,transaction=1": 27, "local=1,global=1,transaction=0": 837 }, "256": { "local=1,global=0,transaction=1": 7, "local=1,global=1,transaction=0": 857 }, "384": { "local=1,global=0,transaction=1": 20, "local=1,global=1,transaction=0": 844 }, "512": { "local=1,global=0,transaction=1": 9, "local=1,global=1,transaction=0": 855 }, "768": { "local=1,global=0,transaction=1": 9, "local=1,global=1,transaction=0": 855 } }, "condition_patterns": { "local=1,global=0,transaction=1": 73, "local=1,global=1,transaction=0": 5975 }, "original_reader_runs": 63, "output_patterns": { "full=0,centroid=0,knn=1": 73, "full=1,centroid=1,knn=1": 5975 }, "transactions": 73 }, "experiment": "boundary_contextual_transaction_detector", "metrics": { "original_centroid_margin": { "max": 0.21993605724649373, "mean": 0.17182890078100768, "min": 0.1170871757102433 }, "original_cross_neighbor_fraction": { "max": 1.0, "mean": 0.7103930461073316, "min": 0.5 }, "transaction_centroid_margin": { "max": 0.31393240599974714, "mean": 0.2734371936008301, "min": 0.25000554554310495 }, "transaction_cross_neighbor_fraction": { "max": 0.75, "mean": 0.5286584040008698, "min": 0.4 }, "transaction_feature_summary": { "obs_L1": { "max": 0.246222711, "mean": 0.03868125017808219, "min": -0.006215749 }, "obs_L2": { "max": 0.334665728, "mean": 0.31795268528767123, "min": 0.255910446 }, "obs_SR": { "max": 0.486586151, "mean": 0.4643413204931507, "min": 0.430936176 }, "obs_SR2": { "max": 0.495480489, "mean": 0.4819464605616439, "min": 0.447747561 }, "obs_SR_local_rigidity": { "max": 0.649072045, "mean": 0.45828197839726026, "min": 0.387458204 }, "obs_triple_var": { "max": 6.053491955, "mean": 5.371340608315068, "min": 4.112313602 }, "z_L1": { "max": 4.322979, "mean": 0.7134457808219178, "min": -0.23432 }, "z_L2": { "max": 9.831093, "mean": 5.970379493150685, "min": 3.487534 }, "z_SR": { "max": 2.466134, "mean": 0.5946528767123288, "min": -0.669973 }, "z_SR2": { "max": 3.416579, "mean": 1.505676315068493, "min": -0.411327 }, "z_triple_var": { "max": 5.642201, "mean": 0.5792694383561644, "min": -1.480477 } } }, "params": { "centroid_margin_max": 0.25, "cross_min": 0.0, "k_values": [ 2, 3, 4 ], "n_gaps_values": [ 192, 256, 384, 512, 768, 1024, 1536 ], "n_shuffle": 32, "scope": "tools/data/boundary_denominator_prescan_full_20260509_1500.json", "seeds": [ 20260515, 20260516, 20260517 ] }, "question": "Does the target keep local kNN convergence while losing global/centroid convergence under physical-internal nulls?", "target": "percolation:cycle_9", "transaction_records": [] } codex Sto aggiungendo un tool `exp_...` separato, non tocco i generatori esistenti. L’output sara un JSON di audit macro usabile dal report e dai cicli successivi. apply patch patch: completed /opt/MM_D-ND/tools/exp_boundary_contextual_robustness_macro_audit.py diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() codex Tool aggiunto. Lo eseguo ora sugli artefatti N=8, N=128, ladder N=64, banda N=96 e matrice di transizione gia presente. exec /bin/bash -lc 'python3 tools/exp_boundary_contextual_robustness_macro_audit.py' in /opt/MM_D-ND diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() succeeded in 337ms: wrote=tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json { "n128_summary": { "logistica_biforcazione_var_3.5699:cycle_13": { "centroid_hit_distribution": { "26": 1, "27": 127 }, "full_hit_distribution": { "26": 2, "27": 126 }, "knn_hit_distribution": { "26": 1, "27": 127 }, "observed_hits": 26 }, "percolation:cycle_9": { "centroid_hit_distribution": { "19": 1, "21": 1, "24": 2, "25": 2, "26": 2, "27": 120 }, "full_hit_distribution": { "19": 1, "21": 1, "24": 2, "25": 2, "26": 3, "27": 119 }, "knn_hit_distribution": { "26": 1, "27": 127 }, "observed_hits": 27 } }, "n8_summary": { "logistica_biforcazione_var_3.5699:cycle_13": { "centroid_hit_distribution": { "27": 8 }, "full_hit_distribution": { "27": 8 }, "knn_hit_distribution": { "27": 8 }, "observed_hits": 26 }, "percolation:cycle_9": { "centroid_hit_distribution": { "27": 8 }, "full_hit_distribution": { "27": 8 }, "knn_hit_distribution": { "27": 8 }, "observed_hits": 27 } }, "percolation_band_transition": { "global_only": 0, "local_global": 5975, "local_only": 73, "neither": 0 }, "promotion": "constraint_no_promotion" } codex Il macro-audit conferma il punto centrale: N=8 era cieco alle code rare; N=128 apre differenza tra logistica quasi ricostruita e percolation fragile in full/centroid. Ora leggo il JSON compresso per scrivere il report con numeri precisi e senza promozione. exec /bin/bash -lc "jq '.targets[\"percolation:cycle_9\"].n128.row_hit_rates_by_denominator, .targets[\"percolation:cycle_9\"].probe_trials_n128, .targets[\"percolation:cycle_9\"].band.row_hit_rates_by_denominator' tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json" in /opt/MM_D-ND succeeded in 0ms: { "1024": { "centroid_only_hit": { "hits": 1145, "misses": 7, "rate": 0.993923611, "total": 1152 }, "full_reader_hit": { "hits": 1144, "misses": 8, "rate": 0.993055556, "total": 1152 }, "knn_only_hit": { "hits": 1151, "misses": 1, "rate": 0.999131944, "total": 1152 } }, "2048": { "centroid_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 }, "full_reader_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 }, "knn_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 } }, "512": { "centroid_only_hit": { "hits": 1133, "misses": 19, "rate": 0.983506944, "total": 1152 }, "full_reader_hit": { "hits": 1133, "misses": 19, "rate": 0.983506944, "total": 1152 }, "knn_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 } } } { "14": { "centroid_only_hit": 24, "full_reader_hit": 24, "knn_only_hit": 27 }, "34": { "centroid_only_hit": 24, "full_reader_hit": 24, "knn_only_hit": 27 }, "68": { "centroid_only_hit": 19, "full_reader_hit": 19, "knn_only_hit": 27 }, "80": { "centroid_only_hit": 21, "full_reader_hit": 21, "knn_only_hit": 27 } } { "1024": { "centroid_only_hit": { "hits": 863, "misses": 1, "rate": 0.998842593, "total": 864 }, "full_reader_hit": { "hits": 863, "misses": 1, "rate": 0.998842593, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } }, "1536": { "centroid_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 }, "full_reader_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } }, "192": { "centroid_only_hit": { "hits": 837, "misses": 27, "rate": 0.96875, "total": 864 }, "full_reader_hit": { "hits": 837, "misses": 27, "rate": 0.96875, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } }, "256": { "centroid_only_hit": { "hits": 857, "misses": 7, "rate": 0.991898148, "total": 864 }, "full_reader_hit": { "hits": 857, "misses": 7, "rate": 0.991898148, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } }, "384": { "centroid_only_hit": { "hits": 844, "misses": 20, "rate": 0.976851852, "total": 864 }, "full_reader_hit": { "hits": 844, "misses": 20, "rate": 0.976851852, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } }, "512": { "centroid_only_hit": { "hits": 855, "misses": 9, "rate": 0.989583333, "total": 864 }, "full_reader_hit": { "hits": 855, "misses": 9, "rate": 0.989583333, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } }, "768": { "centroid_only_hit": { "hits": 855, "misses": 9, "rate": 0.989583333, "total": 864 }, "full_reader_hit": { "hits": 855, "misses": 9, "rate": 0.989583333, "total": 864 }, "knn_only_hit": { "hits": 864, "misses": 0, "rate": 1.0, "total": 864 } } } exec /bin/bash -lc "jq '.targets[\"logistica_biforcazione_var_3.5699:cycle_13\"].n128.row_hit_rates_by_denominator, .percolation_transition_band.null.by_denominator, .percolation_transition_band.original' tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json" in /opt/MM_D-ND succeeded in 0ms: { "1024": { "centroid_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 }, "full_reader_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 }, "knn_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 } }, "2048": { "centroid_only_hit": { "hits": 1151, "misses": 1, "rate": 0.999131944, "total": 1152 }, "full_reader_hit": { "hits": 1151, "misses": 1, "rate": 0.999131944, "total": 1152 }, "knn_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 } }, "512": { "centroid_only_hit": { "hits": 1152, "misses": 0, "rate": 1.0, "total": 1152 }, "full_reader_hit": { "hits": 1151, "misses": 1, "rate": 0.999131944, "total": 1152 }, "knn_only_hit": { "hits": 1151, "misses": 1, "rate": 0.999131944, "total": 1152 } } } { "1024": { "rates": { "global_only": 0.0, "local_global": 0.998842593, "local_only": 0.001157407, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 863, "local_only": 1, "neither": 0 }, "total": 864 }, "1536": { "rates": { "global_only": 0.0, "local_global": 1.0, "local_only": 0.0, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 864, "local_only": 0, "neither": 0 }, "total": 864 }, "192": { "rates": { "global_only": 0.0, "local_global": 0.96875, "local_only": 0.03125, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 837, "local_only": 27, "neither": 0 }, "total": 864 }, "256": { "rates": { "global_only": 0.0, "local_global": 0.991898148, "local_only": 0.008101852, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 857, "local_only": 7, "neither": 0 }, "total": 864 }, "384": { "rates": { "global_only": 0.0, "local_global": 0.976851852, "local_only": 0.023148148, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 844, "local_only": 20, "neither": 0 }, "total": 864 }, "512": { "rates": { "global_only": 0.0, "local_global": 0.989583333, "local_only": 0.010416667, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 855, "local_only": 9, "neither": 0 }, "total": 864 }, "768": { "rates": { "global_only": 0.0, "local_global": 0.989583333, "local_only": 0.010416667, "neither": 0.0 }, "states": { "global_only": 0, "local_global": 855, "local_only": 9, "neither": 0 }, "total": 864 } } { "centroid_margin": { "max": 0.21993605724649373, "mean": 0.17182890078100768, "min": 0.1170871757102433 }, "cross_neighbor_fraction": { "max": 1.0, "mean": 0.7103930461073316, "min": 0.5 }, "reader_runs": 63, "state": "local_global" } exec /bin/bash -lc "jq '.macro_cache_comparison, .targets[\"percolation:cycle_9\"].ladder.reader_distributions, .targets[\"percolation:cycle_9\"].band.reader_distributions' tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json" in /opt/MM_D-ND succeeded in 0ms: { "n128": { "logistica_biforcazione_var_3.5699:cycle_13": { "centroid_hit_distribution": { "26": 1, "27": 127 }, "full_hit_distribution": { "26": 2, "27": 126 }, "knn_hit_distribution": { "26": 1, "27": 127 }, "observed_hits": 26 }, "percolation:cycle_9": { "centroid_hit_distribution": { "19": 1, "21": 1, "24": 2, "25": 2, "26": 2, "27": 120 }, "full_hit_distribution": { "19": 1, "21": 1, "24": 2, "25": 2, "26": 3, "27": 119 }, "knn_hit_distribution": { "26": 1, "27": 127 }, "observed_hits": 27 } }, "n8": { "logistica_biforcazione_var_3.5699:cycle_13": { "centroid_hit_distribution": { "27": 8 }, "full_hit_distribution": { "27": 8 }, "knn_hit_distribution": { "27": 8 }, "observed_hits": 26 }, "percolation:cycle_9": { "centroid_hit_distribution": { "27": 8 }, "full_hit_distribution": { "27": 8 }, "knn_hit_distribution": { "27": 8 }, "observed_hits": 27 } } } { "centroid_only_hit": { "43": 1, "52": 2, "54": 61 }, "full_reader_hit": { "43": 1, "51": 1, "52": 1, "54": 61 }, "knn_only_hit": { "52": 1, "54": 63 } } { "centroid_only_hit": { "35": 1, "39": 1, "56": 1, "58": 2, "61": 1, "62": 2, "63": 88 }, "full_reader_hit": { "35": 1, "39": 1, "56": 1, "58": 2, "61": 1, "62": 2, "63": 88 }, "knn_only_hit": { "63": 96 } } diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() exec /bin/bash -lc "jq '{piano, direzione, tensioni: (.tensioni | if type==\"array\" then length else null end)}' tools/data/seme.json" in /opt/MM_D-ND succeeded in 0ms: { "piano": 137, "direzione": "Report giornaliero BOUNDARY Anderson focused chiuso come CONSTRAINT/NO PROMOTION. Bicono completo e falsifier coerente. Rerun fisico L=5,6,7 conferma W20 come unico local_global all-size e W16/W16.5 come zona intermedia, ma feature-scramble null p=0.887 e co-stability graph/localization null p=0.449/0.182 non passano. Misura evolutiva: tautology_risk=0.0, progress_score=0.857, verdict=evolves. Prossimo: perturbation/null fisico Anderson su W16/W16.5/W20, non altra metrica derivata.", "tensioni": 13 } diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() codex Ho verificato anche `seme.json`: piano 137, direzione viva Anderson/no-promotion; la direttiva one-shot sposta consapevolmente il ciclo sul cache/provenance/failure audit richiesto. Scrivo ora il report nel path indicato. apply patch patch: completed /opt/MM_D-ND/tools/data/reports/agent_20260531_2024.md diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..2bd6c59ed1868c15e545f28fc6e52b6a07a9dd6b --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report — Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..2bd6c59ed1868c15e545f28fc6e52b6a07a9dd6b --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report — Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() codex Report scritto. Faccio una verifica finale: file presenti, JSON valido, script rieseguibile e stato git ristretto alle nuove superfici prodotte. exec /bin/bash -lc 'wc -l tools/exp_boundary_contextual_robustness_macro_audit.py tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json tools/data/reports/agent_20260531_2024.md' in /opt/MM_D-ND succeeded in 0ms: 235 tools/exp_boundary_contextual_robustness_macro_audit.py 2534 tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json 142 tools/data/reports/agent_20260531_2024.md 2911 total exec /bin/bash -lc 'python3 -m json.tool tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json >/tmp/macro_audit_check.json' in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc 'git status --short -- tools/exp_boundary_contextual_robustness_macro_audit.py tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json tools/data/reports/agent_20260531_2024.md' in /opt/MM_D-ND succeeded in 0ms: ?? tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json ?? tools/data/reports/agent_20260531_2024.md ?? tools/exp_boundary_contextual_robustness_macro_audit.py exec /bin/bash -lc "sed -n '1,80p' tools/data/reports/agent_20260531_2024.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report — Boundary Contextual Robustness Macro Audit **Date**: 2026-05-31 20:24 **Piano**: 137 **Tension explored**: boundary physical-internal null cache/provenance/failure audit observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] **observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. ## Respiro fuori-tempo - **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. - **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. - **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. - **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. - **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. - **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. - **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. - **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. ## Aderenza alla direzione - `relation`: `follows_direction` - `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. - `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. ## Source directive Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. ## Claim Under Test Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. ## Question La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? ## Ritorno fisico - **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. - **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. - **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. - **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. - **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. - **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. - **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. ## Experiment Design Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. Input: - `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` - `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` - `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` - `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` - `tools/data/boundary_transition_matrix_percolation_band_20260529.json` Denominatori grezzi: - N=8 cache: 432 cache rows + summary. - N=128 cache: 6912 cache rows + summary. - percolation ladder N=64: 3456 cache rows. - percolation band N=96: 6048 cache rows. No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. ## Results ### N=8 vs N=128 | target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | |---|---:|---:|---:|---:|---:| | logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | | percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | ### Percolation N=128 by denominator | n_gaps | full misses | centroid misses | kNN misses | rows per reader | |---:|---:|---:|---:|---:| | 512 | 19 | 19 | 0 | 1152 | | 1024 | 8 | 7 | 1 | 1152 | diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..2bd6c59ed1868c15e545f28fc6e52b6a07a9dd6b --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report — Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'chmod +x tools/exp_boundary_contextual_robustness_macro_audit.py' in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc "LC_ALL=C grep -n '["'^ -~]'"' tools/data/reports/agent_20260531_2024.md tools/exp_boundary_contextual_robustness_macro_audit.py | head -20" in /opt/MM_D-ND succeeded in 0ms: tools/data/reports/agent_20260531_2024.md:1:# Agent Report — Boundary Contextual Robustness Macro Audit diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..2bd6c59ed1868c15e545f28fc6e52b6a07a9dd6b --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report — Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100755 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() codex Rimuovo l’unico carattere non ASCII introdotto nel report, cosi il nuovo artefatto resta coerente con il vincolo di editing. apply patch patch: completed /opt/MM_D-ND/tools/data/reports/agent_20260531_2024.md diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..fd11a95c6e08855118d8fa4b3e8c89da823cd4d2 --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report - Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100755 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..fd11a95c6e08855118d8fa4b3e8c89da823cd4d2 --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report - Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100755 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() exec /bin/bash -lc "LC_ALL=C grep -n '["'^ -~]'"' tools/data/reports/agent_20260531_2024.md tools/exp_boundary_contextual_robustness_macro_audit.py | head -20" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc 'git status --short -- tools/exp_boundary_contextual_robustness_macro_audit.py tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json tools/data/reports/agent_20260531_2024.md' in /opt/MM_D-ND succeeded in 0ms: ?? tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json ?? tools/data/reports/agent_20260531_2024.md ?? tools/exp_boundary_contextual_robustness_macro_audit.py exec /bin/bash -lc 'python3 tools/exp_boundary_contextual_robustness_macro_audit.py --out /tmp/boundary_macro_audit_rerun.json' in /opt/MM_D-ND diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..fd11a95c6e08855118d8fa4b3e8c89da823cd4d2 --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report - Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100755 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() succeeded in 320ms: wrote=/tmp/boundary_macro_audit_rerun.json { "n128_summary": { "logistica_biforcazione_var_3.5699:cycle_13": { "centroid_hit_distribution": { "26": 1, "27": 127 }, "full_hit_distribution": { "26": 2, "27": 126 }, "knn_hit_distribution": { "26": 1, "27": 127 }, "observed_hits": 26 }, "percolation:cycle_9": { "centroid_hit_distribution": { "19": 1, "21": 1, "24": 2, "25": 2, "26": 2, "27": 120 }, "full_hit_distribution": { "19": 1, "21": 1, "24": 2, "25": 2, "26": 3, "27": 119 }, "knn_hit_distribution": { "26": 1, "27": 127 }, "observed_hits": 27 } }, "n8_summary": { "logistica_biforcazione_var_3.5699:cycle_13": { "centroid_hit_distribution": { "27": 8 }, "full_hit_distribution": { "27": 8 }, "knn_hit_distribution": { "27": 8 }, "observed_hits": 26 }, "percolation:cycle_9": { "centroid_hit_distribution": { "27": 8 }, "full_hit_distribution": { "27": 8 }, "knn_hit_distribution": { "27": 8 }, "observed_hits": 27 } }, "percolation_band_transition": { "global_only": 0, "local_global": 5975, "local_only": 73, "neither": 0 }, "promotion": "constraint_no_promotion" } codex Ruolo/funzione: AI-Lab D-ND, ciclo manuale su audit macro boundary. Fonti lette: `tools/data/agent_field_live.md`, `tools/LAB_AGENT_CONTEXT.md`, `shared_memory/*`, `tools/data/seme.json`, cache JSONL indicate dalla direttiva. Azioni eseguite: - Creato tool riusabile: [tools/exp_boundary_contextual_robustness_macro_audit.py](/opt/MM_D-ND/tools/exp_boundary_contextual_robustness_macro_audit.py) - Eseguito esperimento e scritto output: [tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json](/opt/MM_D-ND/tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json) - Scritto report richiesto: [tools/data/reports/agent_20260531_2024.md](/opt/MM_D-ND/tools/data/reports/agent_20260531_2024.md) Verificato: - JSON valido con `python3 -m json.tool`. - Tool rieseguibile, rerun completato. - Report ASCII-only. - Nuove modifiche confinate ai 3 file sopra. Risultante: `CONSTRAINT / NO PROMOTION`. N=8 era cieco alle code rare; N=128 separa logistica quasi ricostruita da percolation fragile in full/centroid. Nella banda percolation il null produce `73/6048` stati `local_only`, con kNN preservato e globalita/centroide persa. diff --git a/tools/data/reports/agent_20260531_2024.md b/tools/data/reports/agent_20260531_2024.md new file mode 100644 index 0000000000000000000000000000000000000000..fd11a95c6e08855118d8fa4b3e8c89da823cd4d2 --- /dev/null +++ b/tools/data/reports/agent_20260531_2024.md @@ -0,0 +1,142 @@ +# Agent Report - Boundary Contextual Robustness Macro Audit +**Date**: 2026-05-31 20:24 +**Piano**: 137 +**Tension explored**: boundary physical-internal null cache/provenance/failure audit +observables_used: [reader_hit_count_distribution, row_hit_rate_by_denominator, trial_failure_from_full_coverage, local_global_transition_state] +**observable_contract**: claim=original percolation resta invariante sotto denominatore mentre il null fisico-interno perde robustezza contestuale in full/centroid e recupera quando il denominatore matura; observable=distribuzioni hit per reader, miss row-aligned per denominatore, transizione local/global; operator=post-process deterministico su cache JSONL esistenti; generator=logistic_gap_block_shuffle e critical_site_percolation_cluster_geometry_resample; denominator=N8/N128 cache, ladder N64, band N96, reader rows row-aligned; non_possible=se il null ricostruisce sempre piena copertura o se kNN/full/centroid collassano insieme, il claim diventa effetto reader generico; not_tested=nessuna nuova simulazione fisica, nessuna promozione fisica B. + +## Respiro fuori-tempo + +- **Combo**: A11 combo + QxG continuo/discreto + boundary fisico-interno + tensione seme su null fisici interni. Il ciclo misura se il passaggio fisica A -> null interno -> reader M conserva una qualita' locale mentre perde una proiezione globale. +- **Dipolo / punto-zero**: originale robusto / null fragile; punto-zero = stessa riga reader, stesso denominatore, stessa grammatica di hit, ma generatore fisico-interno diverso. +- **Piano superiore**: bicono-dipoli e grafo locale/globale. La misura non cerca un valore; classifica il passaggio local_global -> local_only. +- **Operatori laterali scelti**: nessun nuovo operatore laterale. La direttiva chiede audit macro e non apertura di dominio. +- **Contaminazione cognitiva**: CE-none: il campo letto contiene obbligo CE solo se archivio enzimi cognitivi e' presente nel campo vivo; nella superficie letta non e' emerso un archivio CE operativo da metabolizzare. +- **Proto-ipotesi**: la robustezza non e' "27/27" come numero; e' la capacita' del target originale di tenere insieme localita' kNN e proiezione globale quando il denominatore cambia. Il null puo' mantenere localita' e perdere globalita'. +- **Proiezione**: full/centroid/kNN separano proiezione globale e vicinato locale. Il denominatore mostra se la perdita e' banda contestuale o collasso assoluto. +- **Movimento A->M->B**: fisico A=percolation critical cluster geometry; M=matrice local/global su reader row-aligned; fisico B=vincolo per futuri test su domini fisici indipendenti. In questo ciclo B resta vincolo, non scoperta promuovibile. + +## Aderenza alla direzione + +- `relation`: `follows_direction` +- `why`: segue la direttiva one-shot su cache/provenance/failure audit e la direzione valutatore che chiedeva null fisici interni per logistica/percolation, separando dinamica fisica da ricostruzione del reader. +- `not_drift`: non introduce nuovi domini, fit o metriche derivate; comprime gli artefatti gia' prodotti in un audit macro row-aligned. + +## Source directive + +Vincolo seguito: audit macro della robustezza contestuale, separazione logistica/percolation, trial percolation 14/34/68/80 trattati come sonde, confronto N=8 vs N=128, nessuna promozione pubblica senza Veritas/Aeternitas. + +## Claim Under Test + +Il target percolation originale conserva la combo local/global sotto denominatore variabile; il null fisico-interno conserva quasi sempre il vicinato locale kNN ma perde full/centroid in bande contestuali, poi recupera quando il denominatore matura. + +## Question + +La differenza tra originale e null e' invarianza del target originale, fragilita' del surrogate fisico-interno, o semplice effetto di reader/contesto? + +## Ritorno fisico + +- **Punto fisico sorgente**: percolation critica su cluster geometry, confrontata con logistica come target GUE interno. +- **Attraversamento matematico**: cache row-aligned e matrice di transizione local/global. +- **Punto fisico di ritorno**: futuri domini fisici perturbati dove una geometria locale resta kNN-convergente mentre la proiezione globale cade. +- **Controllo concretezza**: il ritorno non viene dichiarato scoperta; resta criterio sperimentale per un dominio fisico indipendente. +- **Relazione nuova**: localita' preservata e globalita' persa sono separabili nel null percolation. +- **Osservabile/test fisico possibile**: ripetere il contratto local/global su un dominio fisico indipendente con null interno e denominatore maturo. +- **Se fallisce**: `ritorno_fisico_assente`; il ciclo resta contratto di audit e vincolo metodologico. + +## Experiment Design + +Post-process deterministico con `tools/exp_boundary_contextual_robustness_macro_audit.py`. + +Input: +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl` +- `tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl` +- `tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl` +- `tools/data/boundary_transition_matrix_percolation_band_20260529.json` + +Denominatori grezzi: +- N=8 cache: 432 cache rows + summary. +- N=128 cache: 6912 cache rows + summary. +- percolation ladder N=64: 3456 cache rows. +- percolation band N=96: 6048 cache rows. + +No p-value in questo ciclo: l'osservabile e' audit di copertura e transizione, non test Monte Carlo nuovo. + +## Results + +### N=8 vs N=128 + +| target | N=8 full/centroid/kNN | N=128 full | N=128 centroid | N=128 kNN | observed | +|---|---:|---:|---:|---:|---:| +| logistica | 8x 27/27 | {26:2, 27:126} | {26:1, 27:127} | {26:1, 27:127} | 26 | +| percolation | 8x 27/27 | {19:1, 21:1, 24:2, 25:2, 26:3, 27:119} | {19:1, 21:1, 24:2, 25:2, 26:2, 27:120} | {26:1, 27:127} | 27 | + +### Percolation N=128 by denominator + +| n_gaps | full misses | centroid misses | kNN misses | rows per reader | +|---:|---:|---:|---:|---:| +| 512 | 19 | 19 | 0 | 1152 | +| 1024 | 8 | 7 | 1 | 1152 | +| 2048 | 0 | 0 | 0 | 1152 | + +### Percolation probe trials N=128 + +| trial | full | centroid | kNN | reader rows | +|---:|---:|---:|---:|---:| +| 14 | 24 | 24 | 27 | 27 | +| 34 | 24 | 24 | 27 | 27 | +| 68 | 19 | 19 | 27 | 27 | +| 80 | 21 | 21 | 27 | 27 | + +### Percolation verifier band N=96 + +Original percolation: `local_global`, 63 reader runs; centroid_margin max `0.219936057`, cross_neighbor_fraction min `0.5`. + +Null transition states over 6048 rows: + +| state | rows | rate | +|---|---:|---:| +| local_global | 5975 | 0.987929894 | +| local_only | 73 | 0.012070106 | +| global_only | 0 | 0.0 | +| neither | 0 | 0.0 | + +Band misses full/centroid: 192 -> 27/864, 256 -> 7/864, 384 -> 20/864, 512 -> 9/864, 768 -> 9/864, 1024 -> 1/864, 1536 -> 0/864. kNN resta 864/864 su tutti i denominatori. + +## Key Findings + +1. N=8 era troppo piccolo: ricostruiva sempre `27/27` per entrambi i target e tutti i reader. +2. Logistica N=128 resta quasi totalmente ricostruita dal null: full ha solo 2 trial a `26/27`, centroid e kNN 1 trial a `26/27`. +3. Percolation N=128 separa i reader: full/centroid cedono, kNN quasi no. I trial 14/34/68/80 sono sonde della perdita globale, non oggetti finali. +4. La banda N=96 chiude la firma: il null produce `local_only` in 73/6048 righe; non produce `global_only` o `neither`. La topologia locale resta, la proiezione globale/centroide cade. +5. La lacuna attiva non e' "il null non ricostruisce sempre"; e' perche' l'originale resta local_global mentre il null, nello stesso contratto reader, perde globalita' in una banda di denominatori e recupera a denominatore maturo. + +## Verdict + +CONSTRAINT / NO PROMOTION + +Il ciclo conferma una robustezza contestuale per percolation come audit interno: originale invariato, null fragile in full/centroid, kNN preservato. Non formula ipotesi fisica B promuovibile. Logistica non apre lo stesso segnale: il null la ricostruisce quasi sempre. + +## Lacuna + +Resta da separare definitivamente: + +- invarianza propria del target originale; +- fragilita' del surrogate fisico-interno sotto denominatore povero/intermedio; +- recupero della combo quando il denominatore matura. + +La lacuna non si risolve con microscopia sui trial falliti. Si risolve con un secondo verifier indipendente o con ritorno fisico B che mantenga lo stesso contratto local/global. + +## Bicono della scoperta + +- **Due radici**: target originale local_global / null fisico-interno local_only. +- **Singolare**: la stessa riga reader prima della separazione locale/globale. +- **Invariante di passaggio**: kNN locale resta convergente anche quando full/centroid perdono copertura. +- **Campo di possibilita**: possibile usare la matrice local/global come contratto di audit per futuri domini fisici; non-possibile promuovere `27/27` o il picco percolation come legge fisica. + +## Files + +- `tools/exp_boundary_contextual_robustness_macro_audit.py` +- `tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json` +- `tools/data/reports/agent_20260531_2024.md` diff --git a/tools/exp_boundary_contextual_robustness_macro_audit.py b/tools/exp_boundary_contextual_robustness_macro_audit.py new file mode 100755 index 0000000000000000000000000000000000000000..aa2805337f706bd8bc3980084f81e09132c41e45 --- /dev/null +++ b/tools/exp_boundary_contextual_robustness_macro_audit.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +""" +Compress boundary physical-internal null caches into a macro robustness audit. + +This tool does not run new physics simulations. It reads existing row-aligned +cache JSONL files and asks whether the observed/original target stays stable +while the physical-internal null becomes contextual: reader-dependent, +denominator-dependent, or projection-dependent. +""" + +from __future__ import annotations + +import argparse +import json +from collections import Counter, defaultdict +from pathlib import Path +from typing import Any + + +READERS = ("full_reader_hit", "centroid_only_hit", "knn_only_hit") + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8") as f: + for line in f: + line = line.strip() + if line: + rows.append(json.loads(line)) + return rows + + +def rate(hits: int, total: int) -> float: + return round(hits / total, 9) if total else 0.0 + + +def summarize_cache(path: Path, label: str) -> dict[str, Any]: + raw = load_jsonl(path) + metadata = next((row for row in raw if row.get("type") == "metadata"), {}) + summary = next((row for row in raw if row.get("type") == "summary"), {}) + cache_rows = [row for row in raw if row.get("type") == "cache_row"] + + out: dict[str, Any] = { + "label": label, + "path": str(path), + "metadata_count": sum(1 for row in raw if row.get("type") == "metadata"), + "cache_row_count": len(cache_rows), + "summary_count": sum(1 for row in raw if row.get("type") == "summary"), + "params": metadata.get("params", {}), + "summary": summary.get("summary", {}), + "targets": {}, + } + + by_target: dict[str, list[dict[str, Any]]] = defaultdict(list) + for row in cache_rows: + by_target[row["target"]].append(row) + + for target, rows in sorted(by_target.items()): + reader_runs = len({row["reader_index"] for row in rows}) + trials = len({row["trial"] for row in rows}) + target_out: dict[str, Any] = { + "trials": trials, + "reader_runs": reader_runs, + "n_gaps_requested": sorted({row["reader"]["n_gaps"] for row in rows}), + "n_gaps_used": sorted({row["target_features"]["n_gaps_used"] for row in rows}), + "n_gaps_available": sorted({row["target_features"]["n_gaps_available"] for row in rows}), + "reader_distributions": {}, + "row_hit_rates_by_denominator": {}, + "trial_failures_from_full_coverage": {}, + "trial_counts": {}, + } + + by_trial: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_trial[int(row["trial"])].append(row) + + for reader in READERS: + distribution: Counter[int] = Counter() + trial_counts: dict[str, int] = {} + failures: dict[str, int] = {} + for trial, trial_rows in sorted(by_trial.items()): + count = sum(1 for row in trial_rows if row["outputs"][reader]) + distribution[count] += 1 + trial_counts[str(trial)] = count + if count < reader_runs: + failures[str(trial)] = count + target_out["reader_distributions"][reader] = { + str(key): value for key, value in sorted(distribution.items()) + } + target_out["trial_counts"][reader] = trial_counts + target_out["trial_failures_from_full_coverage"][reader] = failures + + denom_out: dict[str, Any] = {} + by_denom: dict[int, list[dict[str, Any]]] = defaultdict(list) + for row in rows: + by_denom[int(row["reader"]["n_gaps"])].append(row) + for denom, denom_rows in sorted(by_denom.items()): + denom_out[str(denom)] = {} + for reader in READERS: + hits = sum(1 for row in denom_rows if row["outputs"][reader]) + total = len(denom_rows) + denom_out[str(denom)][reader] = { + "hits": hits, + "total": total, + "misses": total - hits, + "rate": rate(hits, total), + } + target_out["row_hit_rates_by_denominator"] = denom_out + out["targets"][target] = target_out + + return out + + +def compact_probe_trials(cache_summary: dict[str, Any], target: str, trials: list[int]) -> dict[str, Any]: + target_data = cache_summary["targets"].get(target, {}) + compact: dict[str, Any] = {} + for trial in trials: + trial_key = str(trial) + compact[trial_key] = { + reader: target_data.get("trial_counts", {}).get(reader, {}).get(trial_key) + for reader in READERS + } + return compact + + +def load_json(path: Path) -> dict[str, Any]: + with path.open(encoding="utf-8") as f: + data = json.load(f) + if not isinstance(data, dict): + raise ValueError(f"{path} must contain a JSON object") + return data + + +def run(args: argparse.Namespace) -> dict[str, Any]: + n8 = summarize_cache(Path(args.n8), "N8_row_aligned_cache") + n128 = summarize_cache(Path(args.n128), "N128_independent_row_aligned_cache") + ladder = summarize_cache(Path(args.ladder), "percolation_ladder_N64") + band = summarize_cache(Path(args.band), "percolation_band_N96") + transition_band = load_json(Path(args.transition_band)) + + percolation_target = "percolation:cycle_9" + logistic_target = "logistica_biforcazione_var_3.5699:cycle_13" + + output = { + "experiment": "boundary_contextual_robustness_macro_audit", + "question": ( + "Does the original target show denominator invariance while the physical-internal " + "null shows contextual fragility and recovery?" + ), + "source_caches": { + "n8": args.n8, + "n128": args.n128, + "ladder": args.ladder, + "band": args.band, + "transition_band": args.transition_band, + }, + "observables": [ + "reader_hit_count_distribution", + "row_hit_rate_by_denominator", + "trial_failure_from_full_coverage", + "local_global_transition_state", + ], + "null_contract": { + "logistica": "logistic_gap_block_shuffle preserves local contiguous blocks and breaks long-range orbit order", + "percolation": "critical_site_percolation_cluster_geometry_resample preserves generator and largest-cluster observable but changes realization geometry", + }, + "macro_cache_comparison": { + "n8": n8["summary"], + "n128": n128["summary"], + }, + "targets": { + logistic_target: { + "n8": n8["targets"].get(logistic_target), + "n128": n128["targets"].get(logistic_target), + }, + percolation_target: { + "n8": n8["targets"].get(percolation_target), + "n128": n128["targets"].get(percolation_target), + "ladder": ladder["targets"].get(percolation_target), + "band": band["targets"].get(percolation_target), + "probe_trials_n128": compact_probe_trials(n128, percolation_target, [14, 34, 68, 80]), + }, + }, + "percolation_transition_band": { + "original": transition_band.get("original"), + "null": transition_band.get("null"), + "transition_rates": transition_band.get("transition_rates"), + "possibility_reference": transition_band.get("possibility_reference"), + }, + "macro_result": { + "logistica": ( + "The N128 null almost always reconstructs full coverage; rare 26/27 rows " + "do not separate a physical target from the reader strongly enough." + ), + "percolation": ( + "The original percolation target stays full across ladder and band verifier " + "denominators, while physical-internal null rows lose full/centroid coverage " + "in contextual bands and keep kNN coverage." + ), + "promotion": "constraint_no_promotion", + }, + } + + out = Path(args.out) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(output, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print(f"wrote={out}") + print( + json.dumps( + { + "n8_summary": output["macro_cache_comparison"]["n8"], + "n128_summary": output["macro_cache_comparison"]["n128"], + "percolation_band_transition": output["percolation_transition_band"]["null"]["states"], + "promotion": output["macro_result"]["promotion"], + }, + indent=2, + sort_keys=True, + ) + ) + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n8", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260528_2251_N8.jsonl") + parser.add_argument("--n128", default="tools/data/boundary_physical_internal_null_cache_row_aligned_20260529_independent_N128.jsonl") + parser.add_argument("--ladder", default="tools/data/boundary_contextual_robustness_percolation_ladder_20260529_N64.jsonl") + parser.add_argument("--band", default="tools/data/boundary_contextual_robustness_percolation_band_20260529_N96.jsonl") + parser.add_argument("--transition-band", default="tools/data/boundary_transition_matrix_percolation_band_20260529.json") + parser.add_argument("--out", default="tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() tokens used 82,912 Ruolo/funzione: AI-Lab D-ND, ciclo manuale su audit macro boundary. Fonti lette: `tools/data/agent_field_live.md`, `tools/LAB_AGENT_CONTEXT.md`, `shared_memory/*`, `tools/data/seme.json`, cache JSONL indicate dalla direttiva. Azioni eseguite: - Creato tool riusabile: [tools/exp_boundary_contextual_robustness_macro_audit.py](/opt/MM_D-ND/tools/exp_boundary_contextual_robustness_macro_audit.py) - Eseguito esperimento e scritto output: [tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json](/opt/MM_D-ND/tools/data/boundary_contextual_robustness_macro_audit_20260531_2024.json) - Scritto report richiesto: [tools/data/reports/agent_20260531_2024.md](/opt/MM_D-ND/tools/data/reports/agent_20260531_2024.md) Verificato: - JSON valido con `python3 -m json.tool`. - Tool rieseguibile, rerun completato. - Report ASCII-only. - Nuove modifiche confinate ai 3 file sopra. Risultante: `CONSTRAINT / NO PROMOTION`. N=8 era cieco alle code rare; N=128 separa logistica quasi ricostruita da percolation fragile in full/centroid. Nella banda percolation il null produce `73/6048` stati `local_only`, con kNN preservato e globalita/centroide persa.