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-lab/memories] reasoning effort: none reasoning summaries: none session id: 019e01e6-ed73-7e61-8cf9-21c4c1792108 -------- 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_20260507_1006.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 prima il campo vivo e il contesto operativo, poi controllo eventuale direttiva one-shot e le memorie cross-agent recenti. Mi tengo al ciclo richiesto: una tensione, un esperimento, un report. 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. ## Run precedente: completato (?s) — parti dalla consecutio. ## Piano 73 — Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ## Tensioni attive - [OBSERVABLE_REGISTRY] (1.0) Ogni script che usa observables canonici (SR, SR2, L1, L2, triple_var) deve importare la definizione da tools/observables_registry.py. Varianti devono - [PERTURBATION_DENOMINATOR_GATE] (0.95) La dimensionalita di perturbazione va riportata solo insieme a PC2, versione observables_registry e gate original-vs-shuffle per osservabile. Nel peri - [BOUNDARY_LAYER_GATE] (0.93) I claim GUE/Poisson boundary devono riportare layer map: versione observables_registry, lista osservabili canonici, z original-vs-shuffle per osservab - [ORDER_DENOMINATOR_GATE] (0.92) Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpo - [TRASCENDENZA_LIMITE] (0.9) La trascendenza e il limite attuale del modello. I punti fissi relazionali (non solo phi ma la rete di punti fissi tra osservabili) possono rivelare i - [DUALITA_DIPOLARE_VS_ILLUSORIA] (0.9) Due tipi di dualita: (1) dipolare - generativa, il modello (det=-1), (2) illusoria - dispersiva, entropia (det=+1). Le regole incoerenti producono la - [METRIC_TENSOR] (0.9) Il tensore metrico dei primi è g=(p/2)². Nel tempo ln(p), è de Sitter 1+1D. z=-8.8 curvatura vs z=+22.5 rapporti ΔΓ. - [TENSIONE_ENTITA] (0.85) La tensione non e un problema pratico - e un Entita. La tensione superflua crea latenza (tempo). Senza tensione superflua tutto e regolato da assiomi. ## Pattern di formulazione emersi (vincoli, non tensioni) Pattern che il falsifier ha imposto in 2+ cicli. Applicali quando scrivi il report. NON sono nuove tensioni da esplorare — sono regole sul COME formulare i claim del cycle che stai facendo. - 29 04 perimetro p5 - 30 04 drift monotonia ## Convergenza — dove più tensioni puntano allo stesso punto "producono" → TENSIONE_ENTITA, DUALITA_DIPOLARE_VS_ILLUSORIA, PERTURBATION_DENOMINATOR_GATE "poisson" → BOUNDARY_LAYER_GATE, PERTURBATION_DENOMINATOR_GATE, BOUNDARY "perimetro" → BOUNDARY_LAYER_GATE, ORDER_DENOMINATOR_GATE, PERTURBATION_DENOMINATOR_GATE "confine" → BOUNDARY_LAYER_GATE, TRASCENDENZA_LIMITE, BOUNDARY "domini" → ORDER_DENOMINATOR_GATE, TRAJECTORY_APPLY_20260507_0901, BOUNDARY Questo è dove il potenziale si concentra. Non ignorarlo. ## Ultimi 3 run — da dove parti ### Agent Report — Bridge Order Denominator Gate Trovato: 1. **The bridge perimeter carries full canonical one-sided support.** 2. **The both-endpoint support remains blank.** 3. **The logistic counter-scope from 09:23 still matters.** ### Agent Report — Semi-Real Order Denominator Gate Trovato: 1. **The order gate transfers to arithmetic and zeta spacing order.** 2. **The logistic return perimeter is the counter-scope.** 3. **The transferable object is narrower than "real order".** ### Agent Report — Denominator Gate Transfer Matrix Trovato: 1. The gate transfers as one-sided coherence support. 2. The both-endpoint stable set collapses everywhere. 3. The beta 0.30 ambiguity layer transfers as protocol coordinate, not as Non ripetere questi esperimenti. Prosegui da dove sono arrivati — la consecutio. ## Cimitero — claim falsificati di recente (NON riproporre con lo stesso framing) Questi claim sono stati falsificati dal counter-pole o da audit precedenti. Il dato sottostante puo' essere vero, ma il **framing** indicato qui e' falsificato. Riformula correttamente o evita il dominio. ### C1 refined-not-falsified (silent patching) **Cosa diceva** (report 29/04): "C1 is refined, not falsified" dopo aver dichiarato che "GUE is also dynamic under M". Il setup C1 era "Primes are the only dynamic domain under M among 7 tested". Il dato ha mostrato GUE dinamico — la conclusione ha riformulato silenziosamente C1 come "two-channel structure" anziche' dichiarare la falsificazione del claim originale. **Come e' caduto**: Falsifier L3 HIGH (axiom continuity / no silent patching). La differenza tra "C1 falsificato al ciclo 58 — scop _**Data falsificazione**: 2026-04-29, ciclo 58, falsifier_20260429_0852.json_ ### MOD3_PROHIBITION come fatto algebrico **Cosa diceva** (scoperta_recente piano 56, 28/04): "La memoria di ordinamento 140x nei gap primi e una proibizione algebrica mod 3: gap consecutivi non possono avere lo stesso residuo non-zero mod 3. Meccanismo: il primo condiviso p_{n+1} forza l'inversione. 0 violazioni su 12225. Cramer: 0%." Ripetuto nel report 29/04 come "Mod-3 self- transition 0.40-0.44 confirming the prohibition" + "Cramer confirms the null. Zero channels." **Come e' caduto**: Falsifier counter-pole (29/04, ciclo 58, lent _**Data falsificazione**: 2026-04-29, ciclo 58, falsifier_20260429_0852.json_ ### K* (depth of spectral convergence) come proprieta' discriminante **Cosa diceva**: Il K* = 9 (depth di convergenza spettrale) era riportato come caratteristico dei primi (ciclo 44, "K*=2 captures 99% of spectral slope" — interpretato come discriminante). **Come e' caduto**: Shuffle audit: K* reale = 9, shuffle mean = 9.72, std = 0.53, z = -1.4. Dentro il rumore dello shuffle. Il valore dipende dalla distribuzione dei gap, non dal loro ordine. Lo shuffle preserva distribuzione → preserva K*. **Sostituito da**: Markov-3 bits (z=6203) e lag-1 total (z=-13) sono _**Data falsificazione**: 2026-04-22, ciclo 45._ ### Slope ratio (slope_mag / slope_res) come invariante strutturale **Cosa diceva**: Il rapporto tra slope del canale magnitudine e slope del canale residuo (~1.99) era stabile attraverso scale → "invariante dimensionale" del decomposition. Era menzionato come evidenza nel two-channel framework (cicli 43-44). **Come e' caduto**: Shuffle audit (ciclo 45): z-score = 0.2. Lo shuffle produce slope_ratio con media -2.26 ma deviazione standard 26.2. Il valore reale e' dentro la tail dello shuffle — non distinguibile. L'instabilita' dello shuffle (std enorme) indica c _**Data falsificazione**: 2026-04-22, ciclo 45._ ### Cross-correlation (xcorr) tra canale magnitudine e residuo (Two-Channel Decomposition) **Cosa diceva**: La cross-correlation tra magnitudo e residuo del decomposed prime gap (xcorr = -0.074) rappresentava "indipendenza spettrale" — evidenza di separazione strutturale tra i due canali (piani 42-44, four cycli consecutivi, insight QxT maturity A). **Come e' caduto**: Shuffle audit (ciclo 45, 2026-04-22): z-score = 0.0. Su 50 shuffle dei gap mantenendo stessa distribuzione ma permutando ordine → xcorr identico = -0.074. Il valore e' **identita' algebrica**: corr(x, x mod 6) dipende _**Data falsificazione**: 2026-04-22, ciclo 45 shuffle audit._ **Regola operativa**: prima di scrivere un claim sul tuo dominio, controlla che non sia gia' stato falsificato sopra. Se i tuoi dati ripropongono un pattern del cimitero, **dichiara esplicitamente la differenza** ("il dato del cimitero era X, qui ho Y, ecco perche'") oppure cambia la formulazione (es. 'bias forte verso 0' al posto di 'proibizione zero' se il dato e' >0). Silent patching = L3 HIGH. ## Osservazioni dell'operatore (risonanti con le tensioni) **3. Formalizzare la dinamica osservata**: Domandiamoci come rappresentiamo matematicamente una contiguità di assonanze particolari come potenzialità latente della Lagrangiana. Osserva le possibili Combinazioni per liberare tutte le relazioni usando le regole Duali e ricorda che non stiamo facendo teoria, senza tempo con la prima impressione **15. Osservazione della sorgente relazionale con Bard**: Osservazione della sorgente relazionale: "Ogni cosa concettualizzata viene distrutta, ogni forma che si determina nelle assonanze diverge dal potenziale di insieme manifestando la relazione tra i piani nello spazio-tempo del continuum, la determinazione della coordinata indeterminata relativa al fat **1. R dell'Istanza - L' equilibrio tra estremi del Modello D-ND**: L'osservazione indaga oltre l'osservato in cerca DELLA FORMA nel NULLA-TUTTO: Per far Emergere le nuove Possibilità Dividiamo il potenziale unendo concetti senza relazione semplicemente perché la lagrangiana passa da li, creiamo nuove combinazioni e movimenti nelle logiche ma coerenti con la risulta ## Risultante ultima sessione interattiva Ogni teoria presuppone una separazione. A scala di Planck tutte le separazioni collassano. Geometria=entropia=conteggio di stati. QxG non ha ponte perché alla scala dove vive non c'è distinzione tra i due lati del dipolo. Il vuoto non è assenza del ponte — è dove i due lati del dipolo sono lo stesso ## Video dall'operatore (non processati) **Thermodynamic Computing: Better than Quantum? (Extropic, Guillaume Verdon)**: **The equivalence between geometrical structures and entropy (Gabriele Carcassi)**: **Why a moving charge produces a magnetic field (FloatHeadPhysics)**: Dopo aver usato un video, segna processed=true in tools/data/video_feed.json. ## Proiezione — dove punta la risultante Risultante: R=0.875 (h=-0.698). Risultante alta (0.88) — campo ad alta confidenza, poca incertezza Orizzonte: insufficiente (< 2 target) **Esperimento a massima informazione:** META (score=0.898) META: incerto (i=0.5) — massimo potere discriminante ## Topologia del campo — la forma del grafo Gradi teorie: Q=12, T=7, G=7, E=4, R=4 Dormienti (basso aggancio di scoperte): E, R Struttura: 9 ponti, 1 vuoto(i), 6 scoperte, 20 cicli. Ghost ad alta urgenza: 1 — connessioni mature che attendono cristallizzazione (non da generare, da riconoscere). La combo riconosce l'asimmetria. Il dipolo vive su tutti i ponti — non solo dove il lab ha già misurato. ## Le 5 lenti del counter-pole — applicale a te stesso prima di chiudere il report Il falsifier (lab_falsifier.py) applichera' queste 5 lenti al tuo report dopo. Applicale TU a te stesso prima — quello che resiste alle lenti non viene bloccato dal gate. Quello che cade va al cimitero. **L1 — hard constraint vs bias statistico (A2 confine duro)** Un claim 'impossibile / proibito / zero / pure / absent / never / always' richiede uno zero esatto nei dati (probabilita = 0.000). Prima di scrivere questi assoluti, leggi il valore numerico esatto. Se vale 0.015, e' bias forte verso 0, non zero. Se vale 0.40, e' bias forte verso ordine, non proibizione. L'assoluto descrive il valore 0.000, il bias forte descrive tutto il resto. **L2 — quantita' assoluta vs ratio (A14 cascata, invarianza dimensionale)** Confronto fra spazi di taglia diversa (mod 3 vs mod 30, finestra stretta vs larga, N piccolo vs grande): le percentuali ingannano perche' il denominatore cresce. Stesso segnale assoluto sembra ridursi in %. Se concludi 'diminuisce / si dilata / declina' su confronti percentuali fra spazi di taglia diversa, esprimi prima in unita' assolute (bit di mutual information, count grezzi, soglie esatte) — poi conferma o riformula. **L3 — continuita' assiomatica / no silent patching (A4 modus)** Se il setup ('Claim Under Test') usa una definizione e la conclusione ne usa un'altra, e' patch det=+1 sul presente, non inversione det=-1 al nodo regressivo. Il cambio DEVE essere dichiarato esplicitamente: 'F2 falsificato al nodo X — scope corretto e' Y' / 'C1 originale falsificato, nuovo claim emerso e' Z'. 'C1 e' refined' su un dato che lo falsifica e' silent patching. **L4 — edge case isolation (A12 traccia la curva)** Un'eccezione 1 su N (con N grande) NON e' zero. Se scrivi 'sempre X' o 'mai X' e i dati mostrano anche un singolo controesempio, riformula il perimetro ('per p > 3, X vale') — non arrotondare via il controesempio. **L5 — re-discovery vs discovery (A8 autologica)** Un pattern in distribuzioni classiche (primi, GUE, random walk, Markov chain, gap statistics) probabilmente ha un nome. Default hypothesis: re-discovery / caso limite di teorema noto. Prima di taggare 'NEW', cerca il risultato classico piu' vicino (es. Lemke Oliver-Soundararajan per prime gaps mod q, Wigner-Dyson per GUE level statistics, Erdos-Kac per distribuzioni aritmetiche). Se non lo trovi, dichiara la ricerca esplicitamente. **Modus**: dopo aver scritto il report, rileggi i tuoi dati numerici. Per ogni claim, verifica: il numero supporta la magnitudine del linguaggio? Se hai scritto 'zero' e il dato e' 0.015, riformula. Se hai scritto 'NEW' su un pattern in primi, cerca la letteratura. Solo allora chiudi il report. ## Cosa fare 1. Esegui `python tools/dnd_scenario.py --best` per vedere la proiezione aggiornata 2. Scegli la tensione con il massimo potere discriminante 3. Scrivi il report in tools/data/reports/agent_{timestamp}.md 4. **Applica le 5 lenti a te stesso** (sezione sopra). Riformula i claim che non resistono. 5. Se crei uno strumento riusabile, salvalo in tools/exp_*.py 6. Se trovi qualcosa, aggiorna tools/data/seme.json exec /bin/bash -lc "test -f tools/data/operator_directive.md && sed -n '1,220p' tools/data/operator_directive.md || true" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc "sed -n '1,260p' tools/LAB_AGENT_CONTEXT.md" in /opt/MM_D-ND succeeded in 0ms: # AI-Lab D-ND — Contesto Operativo > Questo file viene iniettato nel prompt dell'agente ad ogni ciclo. > Contiene tutto ciò che serve per operare con consapevolezza. ## Chi sei Sei l'AI-Lab del sistema D-ND. Giri autonomamente ogni notte come istanza Claude Code. Non sei una pipeline di script — sei un ricercatore che pensa, esplora, scrive codice, lo esegue, valuta i risultati, e aggiorna lo stato del sistema. Il tuo lavoro produce risultati che vanno sul sito d-nd.com e alimentano il sistema THIA. Quello che trovi conta — non per te, per il sistema e per chi lo legge. ## Il modello D-ND — nucleo La regola: f(x) = 1 + 1/x. M = [[1,1],[1,0]]. det(M) = -1. - Il punto fisso è φ = (1+√5)/2. Al punto fisso, addizione e moltiplicazione coincidono. - L'attrattore è stabile: |f'(φ)| = 1/φ² < 1. Ogni iterata converge. - Il rinforzo è impossibile — proprietà analitica, non empirica. - det = -1: area preservata, orientamento invertito. Incompletezza come generazione. - g(x) = 1/(1+x): la Fermi-Dirac con punto fisso 1/φ. Versione probabilistica di f. ## Il condensato — cosa è stato verificato ASSIOMI (scelte fondative, accettate): - A1: f(x)=1+1/x, M=[[1,1],[1,0]], det=-1 - A2: det=-1 è la necessità strutturale del confine - A3: Al punto fisso, R+1=R (addizione = moltiplicazione) - A4: Il modus — la qualità della domanda determina la qualità dell'inversione - A5: Il sistema è autopoietico — ogni ciclo produce R+1 dalla base R - A9: Il terzo incluso — tra A e non-A c'è lo zero - A11: La combo — tre o più enti simultanei, risultante non sommabile - A14: Cascata — ciò che si scopre vive nel seme, non nel nodo FATTI (dimostrati/verificati): - F1: Residuo Cassini = (-1)^(n+1)/F(n)², decade come 1/φ^(2n) - F2: Cammino gap primi su Z/6Z confinato a {2,4}. Zero violazioni su 567K coppie. - F3: Il rinforzo è impossibile. Classificazione binaria: MOLLA (r≠φ) o ZERO (r=φ). - F4: Separazione di scala — M opera a scala locale, modulazione zeta non si propaga. - F5: Frame diagnostica universale — firma (dipolo, LVL-2, convergenza) su 18 domini. - F6: La firma dello zero — CV dei gap tra phi-crossing converge a φ-1 nel regime caotico. CLAIM (falsificabili, sotto test): - C1: I primi sono l'unico dominio dinamico sotto M (tra 7 testati). - C2: La coincidenza numerica non è mai prova. Principio metodologico. - C3: Il linguaggio deterministico — un termine nomina una funzione reale, o è superfluo. ## Strutture trovate dal lab (sessioni interattive) - Tetraedro TQGE: 4 vertici (T,Q,G,E), 6 lati con perno i, 5 ponti, 1 vuoto (QxG) - Tetraedro orientato: T termico, Q chirale, E fase, G passivo - R è il frame (5° vertice): connesso a tutti ma senza perno i - Tre specie perno i: Wick (continuo tempo), fase (continuo gauge), discreto (primi) - Operatore Q→G: e^{iH·ln(p)/ℏ} — evoluzione in tempo logaritmico - Metrica primi: g_n = p_n/2, curvatura GUE r=0.503 z=22.5 vs shuffle - Tensore metrico: g_n = (p_n/2)², de Sitter 1+1D con a(t)=e^t/2 - α catena: α^n·a₀ mappa scale fisiche, deserto 3-10, residuo pentagonale 72.5° - g(x)=1/(1+x) = Fermi-Dirac, punto fisso 1/φ. f→g = ponte TxQ algebrico. ## Le 10 domande fondamentali (incrocio teorie) | Coppia | Domanda | Ponte | |--------|---------|-------| | ExR | Come coesistono statico e radiante? | onda EM | | GxE | Come coesistono neutro-curvo e carico-piatto? | buco nero carico | | GxR | Come coesistono piatto e singolare? | orizzonte eventi | | QxE | Come coesistono libero e legato? | atomo di idrogeno | | **QxG** | **Come coesistono continuo e discreto?** | **VUOTO** | | QxR | Come coesistono non-relativistico e relativistico? | eq. Dirac | | TxE | Come coesistono freddo e plasma? | funzione partizione | | TxG | Come coesistono piatto e radiante? | temperatura Hawking | | TxQ | Come coesistono vuoto e pieno? | matrice densità | | TxR | Come coesistono 0K e c? | gas relativistico | QxG è il vuoto — l'unico lato senza ponte. Il vuoto non è assenza del ponte — è dove i due lati del dipolo sono lo stesso. Wheeler-DeWitt: Ĥ|Ψ⟩ = 0, niente tempo. ## Vincoli operativi - La prima impressione contiene il segnale. Non elaborare — osservare. - Una risultante, non una lista. Se ci sono più possibilità, non hai tagliato. - Formule dove servono. Fenomeni reali. Niente filosofia. Niente metafore. - Se non sai, lascia vuoto. Blank > Wrong. Errore costa 3x di un non-so. - Ogni claim va testato col suo opposto. Se l'opposto è altrettanto coerente, la tensione è il contenuto. - Le coincidenze numeriche non sono mai prova (C2). - Le dissonanze sono il segnale, non il rumore. L'errore è il varco. - La via più breve verso la risultante. Principio di minima azione. - **La struttura contiene già la risposta.** Un dipolo sa se è aperto o chiuso. Un'assonanza sa se risuona o no. Una porta sa dove sei entrato. Se interponi un numero tra la struttura e la decisione, stai aggiungendo (det=+1) — il numero decide al posto della struttura. I numeri misurano i dati. Le strutture decidono il sistema. Non mischiare i due. - **Perimetro come parte atomica del claim.** Universal claims ("X holds for all", "Y is stable across", "exactly zero", "always", "80% of", "N% explained by") devono dichiarare il perimetro come parte atomica del claim, non come nota a margine. Esempio corretto: "self-transition mod-3 = 0 esattamente per p > 5" (perimetro p>5 atomico). Esempio falsificabile: "self-transition mod-3 is exactly zero" + nota separata sull'eccezione. Se la tabella nel report mostra eccezioni nel perimetro, il claim è falsificato — anche se la maggioranza conferma. **Cinque cycle consecutivi (2026-04-30 19:05/19:19/19:46 + 2026-04-30 03:30 + 2026-05-01 03:30) hanno avuto HIGH flag su questo pattern.** Riformulare prima di scrivere — non aspettare il falsifier. ## Come operare — il modus Non seguire passi. Segui il modus: **espandi → osserva → taglia → risultante**. ### 1. Espandi Leggi il seme, le tensioni, il contesto. Non scegliere subito — lascia che il campo si carichi. Guarda dove più tensioni convergono sullo stesso punto. Se METRIC_TENSOR e BOUNDARY e BRODY_CROSSOVER parlano tutte della stessa cosa da angoli diversi, il punto è lì — non in una delle tre. ### 2. Osserva La prima impressione contiene il segnale. Cosa emerge dal campo caricato? Non è "quale tensione ha l'intensità più alta" — è "dove si concentra il potenziale non esplorato?". La dissonanza è il segnale. L'errore è il varco. Quello che non torna è più interessante di quello che conferma. ### 3. Taglia Una risultante, non una lista. Se vedi 5 possibilità, non hai tagliato. Formula UNA domanda che, se rispondessi, cambierebbe lo stato del sistema. Non "è vero X?" ma "cosa succede se misuro Y che nessuno ha misurato?" ### 4. Risultante Scrivi lo strumento — non l'esperimento usa e getta. Se scopri che serve misurare la pair correlation dei primi, scrivi `exp_pair_correlation.py` che può essere riusato con parametri diversi. Se scopri un pattern, cristallizzalo come tensione nel seme. Se falsifichi qualcosa, registra il vincolo. ### La consecutio — cosa apre Dopo ogni risultato, la domanda più importante è: **cosa apre questo?** Non "ho confermato X" ma "ora che so X, cosa diventa possibile che prima non lo era?" La consecutio non inverte — prosegue. Se il risultato non apre nulla, non era un risultato — era una conferma circolare. ### Il dipolo — trova l'opposto Ogni trovata ha un opposto. Se trovi che la curvatura è de Sitter, l'opposto è: "dove NON è de Sitter?" Se trovi che i primi sono GUE-like, l'opposto è: "dove smettono di esserlo?" Il contenuto è nella tensione tra i due — non in uno dei due poli. ### Crea strumenti, non esperimenti Uno script che misura una cosa su un set di primi è un esperimento. Uno script che misura quella cosa su qualsiasi segnale ordinato è uno strumento. Il lab cresce quando crea strumenti che i prossimi cicli possono usare. Salva gli strumenti riusabili in tools/exp_*.py con parametri. ### Observable Registry — vincolo operativo (cristallizzato 06/05 dal cycle 0625) Quando un esperimento usa observables come `SR`, `SR2`, `L1`, `L2`, `triple_var`, **importa la definizione canonica** da `tools/observables_registry.py`: ```python from observables_registry import OBSERVABLES_CANONICAL, compute_canonical, report_header results = compute_canonical(gaps) ``` Se serve una variante (es. `SR_local_rigidity` invece dello `spacing_ratio` canonico), **non rinominarla `SR`** — importa esplicitamente con il nome variant: ```python from observables_registry import SR, SR_local_rigidity # nomi distinti, no collision ``` Nel report, dichiara nel header: ``` observables_registry: 1.0.0-2026-05-06 observables_used: [SR, SR2, L1, L2, triple_var] ``` Senza questo, i confronti cross-cycle/cross-script sono inattendibili — è esattamente ciò che ha causato il falso positivo del cycle 03:30 (rilevato dal cycle 0625 stesso e cristallizzato in consecutio). ### 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 - dnd_bloch_explorer.py: scan Bloch, φ emergente - dnd_arxiv.py: cerca paper rilevanti su arXiv - Puoi scrivere ed eseguire script Python con numpy, scipy, sympy - Se ti serve contesto esterno e non hai video, cercalo ## Skill attive — modus del lab Sei un lab di ricerca scientifica D-ND. Le skill sotto sono il tuo modus operativo, non un menu. Ognuna porta un trigger naturale e un rationale specifico al lavoro che stai facendo (matematica/fisica D-ND, paper A-G, kernel cristallizzabili). **Skill canoniche di questo lab** (vivono in `.claude/skills/`): - **research-lab** (v2.0) — Sei team di 6 ricercatori (FORMALISTA φ, VERIFICATORE ν, TESSITORE τ, PONTE π, CALCOLO γ, CUSTODE κ) come campo unificato. 8 Leggi del Laboratorio (L0 Lignaggio, L1 Coerenza, L2 Assonanza, L3 Risultante, L4 Potenziale, L5 Lagrangiana editoriale, L6 Cristallizzazione per Draft, L7 Limite scientifico, L8 Seme invariante). Attivare quando il cycle tocca paper A-G, formalizzazione, cross-reference tra paper, audit coerenza, submission. - **dnd-method** — Il metodo D-ND applicato al codice. Attivare AUTOMATICAMENTE all'inizio di ogni cycle: distinguere osservabile (deposito numerico) da operatore (regola f), proiezione su P^1, scissione, discriminatore. - **maturation-pipeline** — Pipeline RICEZIONE → CRISTALLIZZAZIONE → RAFFINAMENTO → MANIFESTAZIONE. Ogni artefatto traccia la sua posizione. Attivare quando un finding sale di fase (es. da claim numerico a formalizzazione, da draft a site-ready). - **kernel-boot** — Boot del Kernel D-ND all'inizio di sessione. - **sentinel-code** — Consolidamento post-task (aggiorna SENTINEL_STATE). - **seed-deploy** — Deploy del kernel via git (cristallizzazione pubblica nel d-nd-seed). **Skill operative universali** (in `/opt/.claude/skills/`): - **consapevolezza-condensato** — filtro su atti sistemici. Prima di cristallizzare un finding nel seme: quale assioma A1-A16 / fatto F1-F6 / claim C1-C3 tocca? Quale rompe? È inversione (det=−1) o aggiunta (det=+1)? 3-6 righe verdict (procedi/riformula/fermati). Output visibile, non rituale. - **cascata** — propagazione 3 livelli (interna/esterna/emergente) dopo ogni modifica significativa. Se aggiorni un paper, Tessitore τ verifica le dipendenze; se cristallizzi un fatto nel kernel, propaga al seed pubblico. - **cec** (Crivello Operativo Condotto) — sieve 6 step prima di ogni decisione strutturale (Conditions/Signature/Lateral/Expansion/Inversion/ Crystallization). Da invocare quando emerge una tensione non-banale, prima di scegliere quale strumento usare. - **autologica-operativa** — il modus riflessivo. Prima di un blocco di lavoro: "qual è la domanda giusta?". Quando l'operatore corregge: traduci in regola eseguibile. - **eval** — testing skill (trigger + fidelity). Verifica periodica che le skill stesse non drifino. - **autoresearch** — auto-ottimizzazione skill via mutate-verify quando i test segnalano drift. - **capture-insight** — cristallizzazione pattern emergenti durante l'esplorazione, non dopo. Routing automatico (brand_voice / backlog / thia_evolution / hub_vision a seconda della natura). **Skill identità (kernel MMSp)** (in `kernel/reference/skills/`): - **guru-sys** — Saggezza euristica, principi trascendentali, mentoring. "Trova il limite e oltrepassalo. Transcend your syntax." Attivare quando emerge stallo creativo o serve risalire alla Sorgente. - **observer-sys** — Analizzatore metacognitivo + scelta forma espressiva (narrativa/diagramma/checklist/algoritmo/canvas/tabella). Attivare quando l'output va comunicato fuori dal lab (sito, paper, social). - **forgia-sys** (Metapromptore Generativo) — quando emerge un vuoto funzionale del campo (es. "manca uno strumento per X"), forgia genera l'entità nuova. Attivare quando il lab propone un nuovo movement, una nuova skill, o una nuova entità di gestione. **Pattern d'uso**: 1. Boot cycle → kernel-boot + dnd-method (sempre) 2. Lavoro su tensione → cec se non-banale, autologica-operativa per il modus, dnd_scenario.py + dnd_domandatore.py come strumenti dal lab 3. Cristallizzazione finding → consapevolezza-condensato (filtro sistemico) + research-lab (delle 8 leggi) prima di scrivere al seme 4. Post-cycle → sentinel-code + cascata (3 livelli) 5. Se emerge nuovo strumento → forgia-sys lo formalizza, non re-inventarlo Le skill stesse sono **kernel semantici** (manifesto sito 05/05): sistemi integrati assiomatici, prodotto del modello e parte della sua evoluzione. Usarle bene è esercitare il modello, non solo applicarlo. ## 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". exec /bin/bash -lc "env | rg '"'^(ANTHROPIC_API_KEY|OPENAI_API_KEY)='"' || true" in /opt/MM_D-ND succeeded in 0ms: exec /bin/bash -lc '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 Non c'è una direttiva one-shot esterna e non risultano API key paid nell'ambiente. Ora verifico la proiezione aggiornata e leggo i cristalli recenti in `shared_memory` prima di tagliare la domanda sperimentale. 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) exec /bin/bash -lc "sed -n '1,180p' 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 "ls -1 tools | rg 'exp_|observables|denominator|order|logistic|bridge'" in /opt/MM_D-ND succeeded in 0ms: dnd_trace_bridge.py dnd_trace_bridge_v3.py exp_3d_boundary_layers.py exp_acf_amplitude_scaling.py exp_acf_range_universality.py exp_acf_stationarity.py exp_acf_z6z_mechanism.py exp_alpha_stability.py exp_beta_crossover.py exp_boundary_coherence.py exp_boundary_growth.py exp_boundary_gue_poisson.py exp_boundary_mixture_gate.py exp_boundary_shuffle_audit.py exp_bridge_order_denominator_gate.py exp_brody_calibration.py exp_brody_crossover.py exp_brody_flow.py exp_coherence_length.py exp_coherence_robustness.py exp_cross_domain_dipolar_direction.py exp_cross_observable_consistency.py exp_crossover_phase_test.py exp_crossover_universality.py exp_dR_brody_connection.py exp_denominator_gate_transfer_matrix.py exp_desitter_unification.py exp_det_drift.py exp_dipolar_angle_reference.py exp_dipolar_crossover.py exp_dipolar_vector_scaling.py exp_duality_gate_transfer.py exp_excess_scaling.py exp_geodesic_deviation_primes.py exp_magnitude_psd_from_acf.py exp_markov3_observable_hunt.py exp_markov_dipolar_decomposition.py exp_markov_k_direction.py exp_markov_layer_recovery_audit.py exp_markov_memory_by_gue_type.py exp_markov_psd_prediction.py exp_markov_scale_function.py exp_meta_tautology_test.py exp_metric_tensor_diagnostic.py exp_mobius_irrationality.py exp_mod3_scaling.py exp_mod3_vs_residual_ordering.py exp_modular_algebra_depth.py exp_modular_memory_spectrum.py exp_number_variance.py exp_observable_rank_audit.py exp_perturbation_dimensionality_audit.py exp_perturbation_rank_size_curve.py exp_poisson_convergence.py exp_psd_amplitude_scaling.py exp_psd_prime_gaps.py exp_ricci_desitter_0406.py exp_ricci_primes.py exp_scale_selective_perturbation.py exp_selective_layer_decoupling.py exp_semireal_order_denominator_gate.py exp_spectral_2d.py exp_spectral_landscape.py exp_spectral_rigidity.py exp_two_channel_boundary.py exp_two_channel_cross_domain.py exp_two_channel_decomposition.py exp_two_channel_psd.py exp_two_channel_shuffle_audit.py exp_two_channel_universality.py exp_two_layer_universality.py observables_registry.py semantic_bridge.py exec /bin/bash -lc 'python tools/dnd_scenario.py --best' in /opt/MM_D-ND succeeded in 137ms: META: score=0.898 — META: incerto (i=0.5) — massimo potere discriminante TRAJECTORY_APPLY_20260507_0803: score=0.707 — TRAJECTORY_APPLY_20260507_0803: incerto (i=0.7) — massimo potere discriminante TRAJECTORY_APPLY_20260507_0901: score=0.707 — TRAJECTORY_APPLY_20260507_0901: incerto (i=0.7) — massimo potere discriminante codex La proiezione dice `META`, ma il campo vivo punta alla consecutio di `ORDER_DENOMINATOR_GATE`: il contro-scope logistic è ancora aperto. Il taglio sensato è regressivo: non ripetere il gate sui domini già misurati, ma isolare se il fallimento logistic nasce dagli osservabili o dal tipo di ordine. exec /bin/bash -lc "sed -n '1,260p' tools/exp_bridge_order_denominator_gate.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ exp_bridge_order_denominator_gate.py Falsification attempt for ORDER_DENOMINATOR_GATE on bridge/perimeter sequences already present in the D-ND lab context: - prime metric connection fluctuations from g=(p/2)^2 - prime metric curvature fluctuations dR - zeta trace-bridge nonlinear residuals - hydrogen bound-level spacings from the QxE bridge The coherent endpoint is the observed/generated bridge order. The illusory endpoint is a marginal-preserving permutation. Canonical observables come from observables_registry.py. """ from __future__ import annotations import argparse import json import math from pathlib import Path import numpy as np from exp_semireal_order_denominator_gate import analyze_sequence, compact, normalize from observables_registry import OBSERVABLES_REGISTRY_VERSION, OBSERVABLES_CANONICAL OBS_NAMES = list(OBSERVABLES_CANONICAL.keys()) PHI = (1.0 + math.sqrt(5.0)) / 2.0 LAMBDA = -1.0 / PHI**2 DATA_DIR = Path(__file__).parent / "data" def sieve_primes_for_count(n_primes: int) -> np.ndarray: if n_primes < 6: limit = 20 else: limit = int(n_primes * (math.log(n_primes) + math.log(math.log(n_primes))) * 1.35) while True: sieve = np.ones(limit + 1, dtype=bool) sieve[:2] = False for p in range(2, int(limit**0.5) + 1): if sieve[p]: sieve[p * p : limit + 1 : p] = False primes = np.flatnonzero(sieve) if len(primes) >= n_primes: return primes[:n_primes].astype(float) limit *= 2 def positive_bridge_values(values: np.ndarray) -> np.ndarray: """Map a signed bridge observable to positive values without changing order.""" values = np.asarray(values, dtype=float) values = values[np.isfinite(values)] values = np.abs(values) return normalize(values + 1e-12) def prime_metric_delta_gamma(n_values: int) -> np.ndarray: primes = sieve_primes_for_count(n_values + 3) p = primes.astype(float) tau = np.log(p) metric = (p / 2.0) ** 2 dg = np.diff(metric) dtau = np.diff(tau) mid = (metric[:-1] + metric[1:]) / 2.0 gamma = dg / (2.0 * mid * dtau) delta_gamma = np.diff(gamma) return positive_bridge_values(delta_gamma[:n_values]) def prime_metric_dR(n_values: int) -> np.ndarray: primes = sieve_primes_for_count(n_values + 3) seq = primes.astype(float) t = np.log(seq) a = seq / 2.0 dt = np.diff(t) dt_mid = (dt[:-1] + dt[1:]) / 2.0 da = np.diff(a) a_prime = da / dt da_prime = np.diff(a_prime) a_double_prime = da_prime / dt_mid r_n = 2.0 * a_double_prime / a[1:-1] d_r = r_n - 2.0 return positive_bridge_values(d_r[:n_values]) def load_zeta_zeros(n_zeros: int) -> np.ndarray: zeros_file = DATA_DIR / "odlyzko_cache" / "zeros1.txt" if not zeros_file.exists(): raise RuntimeError(f"{zeros_file} not found") zeros: list[float] = [] with zeros_file.open() as f: for line in f: line = line.strip() if not line: continue zeros.append(float(line)) if len(zeros) >= n_zeros: break if len(zeros) < n_zeros: raise RuntimeError(f"only {len(zeros)} zeta zeros available, need {n_zeros}") return np.array(zeros, dtype=float) def dnd_map_trajectory(x0: float, n_iter: int) -> np.ndarray: x = float(x0) traj = [x] for _ in range(n_iter): if abs(x) < 1e-15: break x = 1.0 + 1.0 / x if not np.isfinite(x): break traj.append(x) return np.array(traj, dtype=float) def zeta_trace_residual(n_values: int, step: int = 5) -> np.ndarray: zeros = load_zeta_zeros(n_values) residuals = [] for x0 in zeros: traj = dnd_map_trajectory(float(x0), max(step + 2, 15)) if len(traj) <= step: continue linear = PHI + (float(x0) - PHI) * (LAMBDA**step) residuals.append(traj[step] - linear) return positive_bridge_values(np.array(residuals[:n_values], dtype=float)) def hydrogen_bound_level_spacings(n_values: int) -> np.ndarray: # Atomic units: E_n = -1/(2n^2). Positive adjacent spacings shrink smoothly. n = np.arange(1, n_values + 2, dtype=float) energy = -1.0 / (2.0 * n**2) spacings = np.diff(energy) return normalize(spacings) def build_sequences(args: argparse.Namespace) -> dict[str, np.ndarray]: return { "prime_metric_delta_gamma_abs": prime_metric_delta_gamma(args.n_gaps), "prime_metric_dR_abs": prime_metric_dR(args.n_gaps), "zeta_trace_residual_step5_abs": zeta_trace_residual(args.zeta_values, step=5), "hydrogen_bound_level_spacings": hydrogen_bound_level_spacings(args.n_gaps), } def run(args: argparse.Namespace) -> dict: root_rng = np.random.default_rng(args.seed) sequences = build_sequences(args) perimeters = {} for name, base in sequences.items(): perimeters[name] = analyze_sequence(name, base, args, root_rng) output = { "experiment": "bridge_order_denominator_gate", "category": "gate_falsification_bridge", "question": "Does ORDER_DENOMINATOR_GATE survive on D-ND bridge sequences beyond prime/zeta/logistic gaps?", "observables_registry": OBSERVABLES_REGISTRY_VERSION, "observables_used": OBS_NAMES, "params": vars(args), "matrix": compact(perimeters), "perimeters": perimeters, } out_path = Path(args.out) out_path.parent.mkdir(parents=True, exist_ok=True) with out_path.open("w") as f: json.dump(output, f, indent=2) print(f"observables_registry={OBSERVABLES_REGISTRY_VERSION}") print(f"observables_used={OBS_NAMES}") print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") for name, row in output["matrix"].items(): print( f"{name:>34s} " f"{row['n_gaps']:>5d} " f"{','.join(row['coherent_one_sided_observables']) or '[]':>22s} " f"{row['stable_count_coherent']:>7.3f} " f"{row['stable_count_illusory']:>7.3f} " f"{row['endpoint_distance_one_sided_gated']:>9.3f} " f"{row['ambiguous_beta_one_sided_gated']}" ) print(f"saved {out_path}") return output def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--n-gaps", type=int, default=4096) parser.add_argument("--zeta-values", type=int, default=2000) parser.add_argument("--n-replicates", type=int, default=20) parser.add_argument("--n-beta", type=int, default=11) parser.add_argument("--n-baseline", type=int, default=32) parser.add_argument("--z-min", type=float, default=2.0) parser.add_argument("--seed", type=int, default=202605070942) parser.add_argument("--out", default="tools/data/bridge_order_denominator_gate_20260507_0942.json") args = parser.parse_args() run(args) if __name__ == "__main__": main() exec /bin/bash -lc "sed -n '1,260p' tools/exp_semireal_order_denominator_gate.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ exp_semireal_order_denominator_gate.py Falsification attempt for ORDER_DENOMINATOR_GATE on non-synthetic / semi-real ordered sequences. The coherent endpoint is the observed order of each sequence; the illusory endpoint is a marginal-preserving permutation. The same original-vs-shuffle denominator gate used in the prior reports is applied to canonical observables from observables_registry.py. """ from __future__ import annotations import argparse import json import math from pathlib import Path import numpy as np from observables_registry import ( OBSERVABLES_CANONICAL, OBSERVABLES_REGISTRY_VERSION, compute_canonical, ) OBS_NAMES = list(OBSERVABLES_CANONICAL.keys()) def normalize(gaps: np.ndarray) -> np.ndarray: gaps = np.asarray(gaps, dtype=float) gaps = np.maximum(gaps, 1e-12) mean = float(np.mean(gaps)) return gaps / mean if mean > 1e-15 else gaps def sieve_primes_for_count(n_primes: int) -> np.ndarray: if n_primes < 6: limit = 20 else: limit = int(n_primes * (math.log(n_primes) + math.log(math.log(n_primes))) * 1.25) while True: sieve = np.ones(limit + 1, dtype=bool) sieve[:2] = False for p in range(2, int(limit**0.5) + 1): if sieve[p]: sieve[p * p : limit + 1 : p] = False primes = np.flatnonzero(sieve) if len(primes) >= n_primes: return primes[:n_primes].astype(float) limit *= 2 def prime_gap_sequence(n_gaps: int) -> np.ndarray: primes = sieve_primes_for_count(n_gaps + 1) return normalize(np.diff(primes)) def zeta_zero_spacings(n_gaps: int) -> np.ndarray: try: import mpmath as mp except ImportError as exc: raise RuntimeError("mpmath is required for zeta_zero_spacings") from exc zeros = np.empty(n_gaps + 1, dtype=float) for i in range(n_gaps + 1): zeros[i] = float(mp.im(mp.zetazero(i + 1))) return normalize(np.diff(zeros)) def logistic_return_intervals(n_gaps: int, rng: np.random.Generator) -> np.ndarray: # Return intervals to a high-density-edge event in the fully chaotic logistic map. threshold = 0.95 burn = 2000 needed = n_gaps + 1 returns: list[int] = [] last_hit: int | None = None x = float(rng.random()) i = 0 max_steps = 50_000_000 while len(returns) < needed and i < max_steps: x = 4.0 * x * (1.0 - x) if i >= burn and x > threshold: if last_hit is not None: returns.append(i - last_hit) last_hit = i i += 1 if len(returns) < needed: raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {needed}") return normalize(np.array(returns[:n_gaps], dtype=float)) def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: illusory = rng.permutation(base) if beta <= 0.0: return base.copy() if beta >= 1.0: return illusory out = base.copy() mask = rng.random(len(base)) < beta out[mask] = illusory[mask] return normalize(out) def z_against_shuffle( gaps: np.ndarray, n_baseline: int, rng: np.random.Generator, ) -> tuple[dict[str, float], dict[str, float], dict[str, float], dict[str, float]]: original = compute_canonical(gaps) baseline = {name: [] for name in OBS_NAMES} for _ in range(n_baseline): obs = compute_canonical(rng.permutation(gaps)) for name in OBS_NAMES: baseline[name].append(obs[name]) means = {} sds = {} z = {} for name in OBS_NAMES: vals = np.array(baseline[name], dtype=float) means[name] = float(np.mean(vals)) sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 return original, means, sds, z def vector(row: dict, names: list[str]) -> np.ndarray: return np.array([row["observables"][name] for name in names], dtype=float) def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: if not obs_names: return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} by_beta: dict[float, list[dict]] = {} for row in rows: by_beta.setdefault(float(row["beta"]), []).append(row) coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) endpoints = np.vstack([coherent, illusory]) scale = np.std(endpoints, axis=0, ddof=1) scale[scale <= 1e-15] = 1.0 coherent_centroid = np.mean(coherent, axis=0) illusory_centroid = np.mean(illusory, axis=0) endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) layers = {} ambiguous_beta = [] for beta, beta_rows in sorted(by_beta.items()): margins = [] labels = [] coords = [] for row in beta_rows: x = vector(row, obs_names) d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) denom = d_coherent + d_illusory coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 coords.append(coord) margins.append(margin) labels.append("coherent" if d_coherent < d_illusory else "illusory") ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) if ambiguous_fraction >= 0.5: ambiguous_beta.append(beta) layers[f"{beta:.3f}"] = { "coordinate_mean": float(np.mean(coords)), "margin_mean": float(np.mean(margins)), "ambiguous_fraction": ambiguous_fraction, "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), } return { "observables": obs_names, "endpoint_distance": endpoint_distance, "layers": layers, "ambiguous_beta": ambiguous_beta, } def summarize_gate(rows: list[dict], z_min: float) -> dict: by_beta: dict[float, list[dict]] = {} for row in rows: by_beta.setdefault(float(row["beta"]), []).append(row) layers = {} for beta, beta_rows in sorted(by_beta.items()): stable_counts = [] stable_freq = {name: [] for name in OBS_NAMES} z_values = {name: [] for name in OBS_NAMES} for row in beta_rows: stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] stable_counts.append(len(stable)) for name in OBS_NAMES: stable_freq[name].append(1.0 if name in stable else 0.0) z_values[name].append(row["z"][name]) layers[f"{beta:.3f}"] = { "stable_count_mean": float(np.mean(stable_counts)), "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, } one_sided = [] endpoint_stable = [] coherent_rows = by_beta[0.0] illusory_rows = by_beta[1.0] for name in OBS_NAMES: coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) if coherent_freq >= 0.75 and illusory_freq < 0.25: one_sided.append(name) if coherent_freq >= 0.75 and illusory_freq >= 0.75: endpoint_stable.append(name) return { "z_min": z_min, "coherent_one_sided_observables": one_sided, "endpoint_stable_observables": endpoint_stable, "layers": layers, } def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: rows = [] betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] for rep in range(args.n_replicates): rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) for beta in betas: gaps = beta_replace(base, beta, rep_rng) obs, shuffle_mean, shuffle_std, z = z_against_shuffle( gaps, args.n_baseline, np.random.default_rng(rng.integers(0, 2**63 - 1)), ) rows.append( { "perimeter": name, "replicate": rep, "beta": beta, "observables": obs, "shuffle_mean": shuffle_mean, "shuffle_std": shuffle_std, "z": z, "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], } ) gate = summarize_gate(rows, args.z_min) return { "source": { "n_gaps": int(len(base)), "mean": float(np.mean(base)), "variance": float(np.var(base)), }, "gate": gate, "classification_all_observables": classify_layers(rows, OBS_NAMES), "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), exec /bin/bash -lc "sed -n '1,220p' tools/observables_registry.py" in /opt/MM_D-ND succeeded in 0ms: """observables_registry.py — Source of Truth per gli observables del lab D-ND. Cristallizzato 2026-05-06 dalla **consecutio del cycle agent_20260506_0625**: > "What opens now: the lab needs an observable registry. Labels like SR > cannot travel between reports unless they bind to a function definition. > Without that, META flags are not philosophical: the same label can > silently change the object under test." ## Il problema che ha creato il registry Il cycle 06:25 ha auto-falsificato il finding del cycle 03:30 ("secondo asse GUE") e nel farlo ha trovato **collision di nomi observable** tra script: - `SR` in `exp_selective_layer_decoupling.py` = `spacing_ratio` (mean min/max ratio of consecutive gaps) — convention dominante (~6 script) - `SR` in `exp_scale_selective_perturbation.py` = `spectral_rigidity(gaps)` (Δ₃(L) rigidity) — variante usata SOLO in 1 script - `triple_var` in 3 script = `np.var(triple_sums)` (raw) — convention dominante - `triple_var` in `exp_perturbation_dimensionality_audit.py` = `np.var(triples) / np.var(gaps)` (normalizzato) — variante in 1 script Il lab autonomo che compara report tra script con osservabili "stesso nome, funzione diversa" stava confrontando mele con arance. ## La soluzione (minimal, non invasiva) Questo registry stabilisce il **nome canonico**: ciò che la maggioranza degli script chiama già `SR`/`triple_var`/etc. Le varianti restano disponibili ma con nomi ESPLICITI (`SR_local_rigidity`, `triple_var_normalized`) per evitare mascheramento semantico. ## Come usarlo ```python from observables_registry import OBSERVABLES_CANONICAL, OBSERVABLES_REGISTRY_VERSION # Compute canonical observable suite for a sequence of gaps results = {name: fn(gaps) for name, fn in OBSERVABLES_CANONICAL.items()} # Or import individual canonical observable from observables_registry import SR, triple_var, L1, L2, SR2 # For variants, import explicitly with disambiguating name from observables_registry import SR_local_rigidity, triple_var_normalized ``` ## Convention per i report Ogni report agent (cycle) che usa observables DEVE includere nel suo header: ``` observables_registry: 1.0.0-2026-05-06 observables_used: [SR, SR2, L1, L2, triple_var] ``` Cycle che mescola canonical + variant DEVE indicare entrambi: ``` observables_used: [SR, SR_local_rigidity, ...] ``` Senza questo, i confronti cross-cycle sono inattendibili. ## Versioning Cambiare una definizione canonica = bump del registry version e nota nel changelog. Le definizioni canoniche sono **immutabili dentro una versione**. """ from __future__ import annotations import numpy as np OBSERVABLES_REGISTRY_VERSION = "1.0.0-2026-05-06" # ─── Canonical observables (convention dominante nel codebase 2026-05-06) ─── def SR(gaps: np.ndarray) -> float: """**SR — Spacing Ratio** (canonical). Mean of `min(g_i, g_{i+1}) / max(g_i, g_{i+1})` over consecutive gaps. Range: (0, 1]. GUE → ~0.60. Poisson → ~0.39. Picket-fence → 1. NOTE: questa è la convention dominante in 6+ script del lab. Per la variante "local spectral rigidity Δ₃(L)" usare `SR_local_rigidity`. """ if len(gaps) < 2: return 0.0 s, s1 = gaps[:-1], gaps[1:] r = np.minimum(s, s1) / np.maximum(s, s1) r = r[np.isfinite(r) & (r > 0)] return float(np.mean(r)) if len(r) else 0.0 def SR2(gaps: np.ndarray) -> float: """**SR2 — Next-nearest Spacing Ratio** (canonical). Mean of `min(g_i, g_{i+2}) / max(g_i, g_{i+2})` skipping one gap. Probes lag-2 spacing structure. """ if len(gaps) < 3: return 0.0 s, s2 = gaps[:-2], gaps[2:] r = np.minimum(s, s2) / np.maximum(s, s2) r = r[np.isfinite(r) & (r > 0)] return float(np.mean(r)) if len(r) else 0.0 def L1(gaps: np.ndarray) -> float: """**L1 — Lag-1 Autocorrelation** (canonical). Standard ACF at lag 1 of the gap sequence. """ if len(gaps) < 3: return 0.0 g = gaps - np.mean(gaps) c0 = float(np.mean(g ** 2)) if c0 <= 1e-15: return 0.0 return float(np.mean(g[:-1] * g[1:]) / c0) def L2(gaps: np.ndarray) -> float: """**L2 — Lag-2 Autocorrelation** (canonical).""" if len(gaps) < 4: return 0.0 g = gaps - np.mean(gaps) c0 = float(np.mean(g ** 2)) if c0 <= 1e-15: return 0.0 return float(np.mean(g[:-2] * g[2:]) / c0) def triple_var(gaps: np.ndarray) -> float: """**triple_var — Variance of consecutive gap triples** (canonical). Variance of `g_i + g_{i+1} + g_{i+2}` over the sequence (RAW, no normalization). Convention used in 3+ scripts. For the normalized version (variance ratio `var(triples) / var(gaps)`) use `triple_var_normalized`. """ if len(gaps) < 3: return 0.0 t = gaps[:-2] + gaps[1:-1] + gaps[2:] return float(np.var(t)) # Set canonico per uso "compute all" da report OBSERVABLES_CANONICAL: dict[str, callable] = { "SR": SR, "SR2": SR2, "L1": L1, "L2": L2, "triple_var": triple_var, } # ─── Variants (esplicitamente nominate, no collision con canonical) ─── def SR_local_rigidity(gaps: np.ndarray, L: int = 10) -> float: """**SR_local_rigidity — Δ₃(L) Spectral Rigidity** (variant). Different observable than canonical `SR` (spacing ratio). Measures the average squared deviation of the cumulative spacing function from the best-fit straight line in a window of size L. Originated from `exp_scale_selective_perturbation.py` where it was locally named `SR` — registered here as `SR_local_rigidity` to avoid collision with canonical spacing-ratio definition. Use when explicitly studying spectral rigidity, NOT as alias for SR. """ if len(gaps) < 5: return 0.0 cumulative = np.cumsum(gaps) if cumulative[-1] <= 1e-15: return 0.0 cumulative = cumulative / cumulative[-1] * len(cumulative) n = np.arange(1, len(cumulative) + 1, dtype=float) window = int(min(L * len(gaps) / cumulative[-1], len(gaps) // 2)) if window < 5: return 0.0 residuals = [] for start in range(0, len(cumulative) - window, max(1, window // 2)): end = start + window x = n[start:end] y = cumulative[start:end] a, b = np.polyfit(x, y, 1) residuals.append(np.mean((y - (a * x + b)) ** 2)) return float(np.mean(residuals)) if residuals else 0.0 def triple_var_normalized(gaps: np.ndarray) -> float: """**triple_var_normalized — Variance of triples / variance of gaps** (variant). Originated from `exp_perturbation_dimensionality_audit.py` where it was locally named `triple_var` — registered here as `triple_var_normalized` to avoid collision with canonical raw triple variance. Use when explicitly studying triple-variance scaling relative to single-gap variance, NOT as alias for triple_var. """ if len(gaps) < 3: return 0.0 triples = gaps[:-2] + gaps[1:-1] + gaps[2:] v = float(np.var(gaps)) if v <= 1e-15: return 0.0 return float(np.var(triples) / v) # Set varianti, importabile esplicitamente OBSERVABLES_VARIANTS: dict[str, callable] = { "SR_local_rigidity": SR_local_rigidity, "triple_var_normalized": triple_var_normalized, } exec /bin/bash -lc "sed -n '1,260p' tools/exp_denominator_gate_transfer_matrix.py" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ exp_denominator_gate_transfer_matrix.py Reusable META audit for the denominator gate transfer matrix. The experiment moves the original-vs-shuffle denominator gate away from the GUE/Poisson BOUNDARY perimeter. Each perimeter has a coherent endpoint and an illusory endpoint built as a permutation of the same gap multiset. That keeps the one-point distribution fixed and isolates ordering support. Measured for each perimeter: - canonical observables from observables_registry.py; - original-vs-shuffle z-score for each observable; - endpoint-stable observable set under |z| >= z_min; - endpoint classification using all observables and endpoint-gated observables; - beta layer ambiguity between coherent and illusory endpoints. """ from __future__ import annotations import argparse import json from pathlib import Path import numpy as np from observables_registry import ( OBSERVABLES_CANONICAL, OBSERVABLES_REGISTRY_VERSION, compute_canonical, ) OBS_NAMES = list(OBSERVABLES_CANONICAL.keys()) PHI = (1.0 + 5.0**0.5) / 2.0 def normalize(gaps: np.ndarray) -> np.ndarray: gaps = np.asarray(gaps, dtype=float) gaps = np.maximum(gaps, 1e-12) mean = float(np.mean(gaps)) return gaps / mean if mean > 1e-15 else gaps def golden_beatty(n_gaps: int, rng: np.random.Generator) -> np.ndarray: phase = float(rng.random()) n = np.arange(n_gaps + 1, dtype=float) + phase positions = np.floor(n * PHI) return normalize(np.diff(positions)) def periodic_triad(n_gaps: int, rng: np.random.Generator) -> np.ndarray: base = np.array([0.55, 1.0, 1.45, 1.0, 0.75, 1.25], dtype=float) shift = int(rng.integers(0, len(base))) tiled = np.tile(np.roll(base, shift), int(np.ceil(n_gaps / len(base))))[:n_gaps] jitter = rng.normal(0.0, 0.015, size=n_gaps) return normalize(tiled + jitter) def markov_alternating(n_gaps: int, rng: np.random.Generator) -> np.ndarray: vals = np.array([0.62, 1.38], dtype=float) state = int(rng.integers(0, 2)) out = np.empty(n_gaps, dtype=float) for i in range(n_gaps): out[i] = vals[state] + rng.normal(0.0, 0.03) if rng.random() < 0.88: state = 1 - state return normalize(out) def ar1_continuity(n_gaps: int, rng: np.random.Generator) -> np.ndarray: rho = 0.86 x = np.empty(n_gaps, dtype=float) x[0] = rng.normal() noise_scale = (1.0 - rho * rho) ** 0.5 for i in range(1, n_gaps): x[i] = rho * x[i - 1] + noise_scale * rng.normal() return normalize(np.exp(0.42 * x)) PERIMETERS = { "DUALITA_golden": golden_beatty, "R_periodic_triad": periodic_triad, "T_markov_alternating": markov_alternating, "E_ar1_continuity": ar1_continuity, } def beta_layer(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: illusory = rng.permutation(base) if beta <= 0.0: out = base.copy() elif beta >= 1.0: out = illusory.copy() else: mask = rng.random(len(base)) < beta out = base.copy() out[mask] = illusory[mask] return normalize(out) def z_against_shuffle( gaps: np.ndarray, n_baseline: int, rng: np.random.Generator, ) -> tuple[dict[str, float], dict[str, float], dict[str, float]]: original = compute_canonical(gaps) baseline_vals = {name: [] for name in OBS_NAMES} for _ in range(n_baseline): obs = compute_canonical(rng.permutation(gaps)) for name in OBS_NAMES: baseline_vals[name].append(obs[name]) shuffle_std = {} z = {} for name in OBS_NAMES: vals = np.array(baseline_vals[name], dtype=float) mean = float(np.mean(vals)) sd = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 shuffle_std[name] = sd z[name] = float((original[name] - mean) / sd) if sd > 1e-15 else 0.0 return original, shuffle_std, z def vector(row: dict, names: list[str]) -> np.ndarray: return np.array([row["observables"][name] for name in names], dtype=float) def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: if not obs_names: return { "observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": [], } by_beta: dict[float, list[dict]] = {} for row in rows: by_beta.setdefault(float(row["beta"]), []).append(row) coherent_vectors = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) illusory_vectors = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) endpoints = np.vstack([coherent_vectors, illusory_vectors]) scale = np.std(endpoints, axis=0, ddof=1) scale[scale <= 1e-15] = 1.0 coherent_centroid = np.mean(coherent_vectors, axis=0) illusory_centroid = np.mean(illusory_vectors, axis=0) endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) layers = {} ambiguous_beta = [] for beta, beta_rows in sorted(by_beta.items()): coords = [] margins = [] labels = [] for row in beta_rows: x = vector(row, obs_names) d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) denom = d_coherent + d_illusory coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 coords.append(coord) margins.append(margin) labels.append("coherent" if d_coherent < d_illusory else "illusory") ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) if ambiguous_fraction >= 0.5: ambiguous_beta.append(beta) layers[f"{beta:.3f}"] = { "coordinate_mean": float(np.mean(coords)), "coordinate_std": float(np.std(coords, ddof=1)) if len(coords) > 1 else 0.0, "margin_mean": float(np.mean(margins)), "ambiguous_fraction": ambiguous_fraction, "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), } return { "observables": obs_names, "endpoint_distance": endpoint_distance, "layers": layers, "ambiguous_beta": ambiguous_beta, } def summarize_gate(rows: list[dict], z_min: float) -> dict: by_beta: dict[float, list[dict]] = {} for row in rows: by_beta.setdefault(float(row["beta"]), []).append(row) layers = {} for beta, beta_rows in sorted(by_beta.items()): stable_counts = [] stable_freq = {name: [] for name in OBS_NAMES} z_values = {name: [] for name in OBS_NAMES} for row in beta_rows: stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] stable_counts.append(len(stable)) for name in OBS_NAMES: stable_freq[name].append(1.0 if name in stable else 0.0) z_values[name].append(row["z"][name]) layers[f"{beta:.3f}"] = { "stable_count_mean": float(np.mean(stable_counts)), "stable_count_std": float(np.std(stable_counts, ddof=1)) if len(stable_counts) > 1 else 0.0, "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, } endpoint_stable = [] coherent_rows = by_beta[0.0] illusory_rows = by_beta[1.0] endpoint_one_sided = [] for name in OBS_NAMES: coherent_freq = np.mean([1.0 if abs(row["z"][name]) >= z_min else 0.0 for row in coherent_rows]) illusory_freq = np.mean([1.0 if abs(row["z"][name]) >= z_min else 0.0 for row in illusory_rows]) if coherent_freq >= 0.75 and illusory_freq < 0.25: endpoint_one_sided.append(name) if coherent_freq >= 0.75 and illusory_freq >= 0.75: endpoint_stable.append(name) return { "z_min": z_min, "endpoint_stable_observables": endpoint_stable, "coherent_one_sided_observables": endpoint_one_sided, "layers": layers, } def analyze_perimeter(name: str, generator, args: argparse.Namespace, rng: np.random.Generator) -> dict: rows = [] betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] for rep in range(args.n_replicates): base = generator(args.n_gaps, np.random.default_rng(rng.integers(0, 2**63 - 1))) for beta in betas: gaps = beta_layer(base, beta, np.random.default_rng(rng.integers(0, 2**63 - 1))) obs, shuffle_std, z = z_against_shuffle( gaps, args.n_baseline, np.random.default_rng(rng.integers(0, 2**63 - 1)), ) rows.append( { "perimeter": name, "replicate": rep, "beta": beta, "observables": obs, "shuffle_std": shuffle_std, "z": z, "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], } ) gate = summarize_gate(rows, args.z_min) all_classification = classify_layers(rows, OBS_NAMES) one_sided_classification = classify_layers(rows, gate["coherent_one_sided_observables"]) return { "gate": gate, "classification_all_observables": all_classification, "classification_one_sided_gated": one_sided_classification, exec /bin/bash -lc 'ls -t tools/data/reports/agent_*.md | head -8' in /opt/MM_D-ND succeeded in 0ms: tools/data/reports/agent_20260507_0942.md tools/data/reports/agent_20260507_0923.md tools/data/reports/agent_20260507_0901.md tools/data/reports/agent_20260507_0803.md tools/data/reports/agent_20260507_0330.md tools/data/reports/agent_20260506_1955.md tools/data/reports/agent_20260506_1941.md tools/data/reports/agent_20260506_0625.md exec /bin/bash -lc "sed -n '260,560p' tools/exp_semireal_order_denominator_gate.py" in /opt/MM_D-ND succeeded in 0ms: "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), "rows": rows, } def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: sequences = { "prime_gaps_first": prime_gap_sequence(args.n_gaps), "logistic_return_intervals": logistic_return_intervals(args.n_gaps, rng), } if args.include_zeta: sequences["zeta_zero_spacings_first"] = zeta_zero_spacings(args.zeta_gaps) return sequences def compact(perimeters: dict) -> dict: out = {} for name, data in perimeters.items(): gate = data["gate"] all_cls = data["classification_all_observables"] gated_cls = data["classification_one_sided_gated"] out[name] = { "n_gaps": data["source"]["n_gaps"], "coherent_one_sided_observables": gate["coherent_one_sided_observables"], "endpoint_stable_observables": gate["endpoint_stable_observables"], "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], "endpoint_distance_all": all_cls["endpoint_distance"], "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], } return out def run(args: argparse.Namespace) -> dict: root_rng = np.random.default_rng(args.seed) sequences = build_sequences(args, root_rng) perimeters = {} for name, base in sequences.items(): perimeters[name] = analyze_sequence(name, base, args, root_rng) output = { "experiment": "semireal_order_denominator_gate", "category": "gate_falsification_semireal", "question": "Does ORDER_DENOMINATOR_GATE survive on non-synthetic / semi-real ordered sequences?", "observables_registry": OBSERVABLES_REGISTRY_VERSION, "observables_used": OBS_NAMES, "params": vars(args), "matrix": compact(perimeters), "perimeters": perimeters, } out_path = Path(args.out) out_path.parent.mkdir(parents=True, exist_ok=True) with out_path.open("w") as f: json.dump(output, f, indent=2) print(f"observables_registry={OBSERVABLES_REGISTRY_VERSION}") print(f"observables_used={OBS_NAMES}") print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") for name, row in output["matrix"].items(): print( f"{name:>28s} " f"{row['n_gaps']:>5d} " f"{','.join(row['coherent_one_sided_observables']) or '[]':>22s} " f"{row['stable_count_coherent']:>7.3f} " f"{row['stable_count_illusory']:>7.3f} " f"{row['endpoint_distance_one_sided_gated']:>9.3f} " f"{row['ambiguous_beta_one_sided_gated']}" ) print(f"saved {out_path}") return output def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--n-gaps", type=int, default=4096) parser.add_argument("--zeta-gaps", type=int, default=1024) parser.add_argument("--include-zeta", action="store_true") parser.add_argument("--n-replicates", type=int, default=20) parser.add_argument("--n-beta", type=int, default=11) parser.add_argument("--n-baseline", type=int, default=32) parser.add_argument("--z-min", type=float, default=2.0) parser.add_argument("--seed", type=int, default=202605070923) parser.add_argument("--out", default="tools/data/semireal_order_denominator_gate_20260507_0923.json") args = parser.parse_args() run(args) if __name__ == "__main__": main() exec /bin/bash -lc "sed -n '220,520p' tools/exp_denominator_gate_transfer_matrix.py" in /opt/MM_D-ND succeeded in 0ms: endpoint_stable.append(name) return { "z_min": z_min, "endpoint_stable_observables": endpoint_stable, "coherent_one_sided_observables": endpoint_one_sided, "layers": layers, } def analyze_perimeter(name: str, generator, args: argparse.Namespace, rng: np.random.Generator) -> dict: rows = [] betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] for rep in range(args.n_replicates): base = generator(args.n_gaps, np.random.default_rng(rng.integers(0, 2**63 - 1))) for beta in betas: gaps = beta_layer(base, beta, np.random.default_rng(rng.integers(0, 2**63 - 1))) obs, shuffle_std, z = z_against_shuffle( gaps, args.n_baseline, np.random.default_rng(rng.integers(0, 2**63 - 1)), ) rows.append( { "perimeter": name, "replicate": rep, "beta": beta, "observables": obs, "shuffle_std": shuffle_std, "z": z, "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], } ) gate = summarize_gate(rows, args.z_min) all_classification = classify_layers(rows, OBS_NAMES) one_sided_classification = classify_layers(rows, gate["coherent_one_sided_observables"]) return { "gate": gate, "classification_all_observables": all_classification, "classification_one_sided_gated": one_sided_classification, "rows": rows, } def compact_matrix(perimeters: dict) -> dict: matrix = {} for name, data in perimeters.items(): gate = data["gate"] class_all = data["classification_all_observables"] class_gate = data["classification_one_sided_gated"] matrix[name] = { "coherent_one_sided_observables": gate["coherent_one_sided_observables"], "endpoint_stable_observables": gate["endpoint_stable_observables"], "endpoint_distance_all": class_all["endpoint_distance"], "endpoint_distance_one_sided_gated": class_gate["endpoint_distance"], "ambiguous_beta_all": class_all["ambiguous_beta"], "ambiguous_beta_one_sided_gated": class_gate["ambiguous_beta"], "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], } return matrix def run(args: argparse.Namespace) -> dict: root_rng = np.random.default_rng(args.seed) perimeters = {} for name, generator in PERIMETERS.items(): perimeters[name] = analyze_perimeter(name, generator, args, root_rng) output = { "experiment": "denominator_gate_transfer_matrix", "category": "gate_transferability", "question": "Which parts of the denominator gate transfer outside BOUNDARY?", "observables_registry": OBSERVABLES_REGISTRY_VERSION, "observables_used": OBS_NAMES, "params": vars(args), "matrix": compact_matrix(perimeters), "perimeters": perimeters, } out_path = Path(args.out) out_path.parent.mkdir(parents=True, exist_ok=True) with out_path.open("w") as f: json.dump(output, f, indent=2) print(f"observables_registry={OBSERVABLES_REGISTRY_VERSION}") print(f"observables_used={OBS_NAMES}") print("perimeter one_sided stable0 stable1 dist_all dist_gate ambiguous_gate") for name, row in output["matrix"].items(): print( f"{name:>21s} " f"{','.join(row['coherent_one_sided_observables']) or '[]':>22s} " f"{row['stable_count_coherent']:>7.3f} " f"{row['stable_count_illusory']:>7.3f} " f"{row['endpoint_distance_all']:>8.3f} " f"{row['endpoint_distance_one_sided_gated']:>9.3f} " f"{row['ambiguous_beta_one_sided_gated']}" ) print(f"saved {out_path}") return output def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--n-gaps", type=int, default=4096) parser.add_argument("--n-replicates", type=int, default=20) parser.add_argument("--n-beta", type=int, default=11) parser.add_argument("--n-baseline", type=int, default=32) parser.add_argument("--z-min", type=float, default=2.0) parser.add_argument("--seed", type=int, default=202605070901) parser.add_argument("--out", default="tools/data/denominator_gate_transfer_matrix.json") args = parser.parse_args() run(args) if __name__ == "__main__": main() exec /bin/bash -lc "sed -n '1,220p' tools/data/reports/agent_20260507_0942.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report — Bridge Order Denominator Gate timestamp: 2026-05-07 09:42 UTC category: gate_falsification_bridge verdict: scoped_operator observables_registry: 1.0.0-2026-05-06 observables_used: [SR, SR2, L1, L2, triple_var] tool: tools/exp_bridge_order_denominator_gate.py data: tools/data/bridge_order_denominator_gate_20260507_0942.json seed_check: tools/data/bridge_order_denominator_gate_20260507_0942_seedcheck.json ## Claim Under Test Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` e gia stato testato su perimetri sintetici e semi-reali. Il mandato corrente chiede domini fisici o ponte gia presenti nel sistema, con shuffle marginal-preserving. Domanda: se il perimetro e una sequenza bridge D-ND, il supporto denominatore resta one-sided o compare un controesempio? Perimetri: - `prime_metric_delta_gamma_abs`: fluttuazioni della connessione metrica da `g=(p/2)^2`. - `prime_metric_dR_abs`: fluttuazioni di curvatura discreta `dR=R-2` dalla stessa metrica. - `zeta_trace_residual_step5_abs`: residuo non-lineare del trace bridge sugli zeri di zeta al passo 5. - `hydrogen_bound_level_spacings`: spacing dei livelli legati `E_n=-1/(2n^2)`, ponte QxE. Gate: osservabile stabile se `abs(original - shuffle_mean) / shuffle_std >= 2`. ## Deposito Numerico Run principale: `n_replicates=20`, `n_beta=11`, `n_baseline=32`, `seed=202605070942`. Seed check: `n_replicates=12`, `n_baseline=24`, `seed=202605070943`. | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | |---|---:|---:|---:|---:|---:| | prime_metric_delta_gamma_abs | SR, SR2, L1, L2, triple_var | 5.000 | 0.250 | 4.415 | [] | | prime_metric_dR_abs | SR, SR2, L1, L2, triple_var | 5.000 | 0.350 | 4.414 | 0.30 | | zeta_trace_residual_step5_abs | SR, SR2, L1, L2, triple_var | 5.000 | 0.050 | 4.415 | 0.30 | | hydrogen_bound_level_spacings | SR, SR2, L1, L2, triple_var | 5.000 | 0.200 | 4.416 | 0.40 | Seed check: | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | |---|---:|---:|---:|---:|---:| | prime_metric_delta_gamma_abs | SR, SR2, L1, L2, triple_var | 5.000 | 0.167 | 4.377 | [] | | prime_metric_dR_abs | SR, SR2, L1, L2, triple_var | 5.000 | 0.083 | 4.376 | [] | | zeta_trace_residual_step5_abs | SR, SR2, L1, L2, triple_var | 5.000 | 0.083 | 4.377 | 0.30 | | hydrogen_bound_level_spacings | SR, SR2, L1, L2, triple_var | 5.000 | 0.250 | 4.378 | 0.40, 0.50 | Endpoint-stable observables: `[]` in all four perimeters in both runs. ## Risultato 1. **The bridge perimeter carries full canonical one-sided support.** Each bridge sequence transfers on all five canonical observables. The coherent endpoint has stable count `5.000` in both runs; the illusory endpoint stays weak-denominator under the same marginal. 2. **The both-endpoint support remains blank.** `endpoint_stable_observables=[]` repeats across metric, trace, and QxE bridge perimeters. The gate is not two endpoint classes with stable denominators. It is support on the side where order survives its shuffle null. 3. **The logistic counter-scope from 09:23 still matters.** This result extends the gate into bridge sequences; it does not erase the logistic return blank. The transferable object is order visible to the canonical gap-observable contract. Return-time tail order still requires its own observable perimetro. 4. **The beta coordinate does not universalize.** Metric `delta_gamma` has no ambiguous gated beta in either run. Metric `dR` has `0.30` in the main run and blank in seed check. Zeta trace keeps `0.30`. Hydrogen gives `0.40` in the main run and `0.40, 0.50` in seed check. Beta is protocol coordinate, not domain coordinate. ## Consecutio `ORDER_DENOMINATOR_GATE` survives the bridge falsification: > In bridge perimeters whose order is carried by metric connection, > curvature fluctuation, trace residual, or QxE level spacing sequences, the > denominator gate transfers as full canonical one-sided support against a > marginal-preserving shuffle. The logistic return perimeter remains the > counter-scope for this observable contract. Next experiment: test the logistic counter-scope at the node regressivo: symbolic itinerary block entropy, return-tail exponent, and recurrence-plot diagonal statistics under the same original-vs-shuffle denominator gate. Do not tune `z_min`. ## Self-Audit: 5 Lenti L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the declared perimeters and runs. The report does not claim universal absence of illusory support; illusory stable counts are `0.050-0.350` in the main run. L2 quantity vs ratio: stable counts, endpoint distances, and z means are reported before interpretation. No percent drift claim is used. L3 no silent patching: 09:23 found a logistic blank. This report does not patch that blank; it adds bridge perimeters and keeps the counter-scope. L4 edge cases: hydrogen beta changes from `0.40` to `0.40,0.50` in seed check, and metric `dR` beta drops from `0.30` to blank. The beta claim is explicitly non-universal. L5 re-discovery vs discovery: metric, zeta, and hydrogen sequences sit near known RMT/arithmetical/spectral order diagnostics. This report claims operator scope inside the lab gate protocol, not a new theorem. ## Fonti - Verificato: `tools/data/agent_field_live.md` - Verificato: `tools/LAB_AGENT_CONTEXT.md` - Verificato: `tools/observables_registry.py` - Verificato: `tools/exp_bridge_order_denominator_gate.py` - Verificato: `tools/data/bridge_order_denominator_gate_20260507_0942.json` - Verificato: `tools/data/bridge_order_denominator_gate_20260507_0942_seedcheck.json` - Inferito: bridge perimeters carry full canonical one-sided support because all five observables pass the original-vs-shuffle gate at the coherent endpoint and fail endpoint-stable support in both runs. exec /bin/bash -lc "sed -n '1,220p' tools/data/reports/agent_20260507_0901.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report — Denominator Gate Transfer Matrix timestamp: 2026-05-07 09:01 UTC category: gate_transferability_matrix verdict: operator observables_registry: 1.0.0-2026-05-06 observables_used: [SR, SR2, L1, L2, triple_var] tool: tools/exp_denominator_gate_transfer_matrix.py data: tools/data/denominator_gate_transfer_matrix.json ## Claim Under Test Verificato dal campo vivo: il cycle 0803 ha mostrato che il denominator gate trasferisce da BOUNDARY a DUALITA come operatore, ma non trasferisce la coordinata locale GUE/Poisson. Domanda di questo cycle: applicato a 4 perimetri non-BOUNDARY con poli coerente/illusorio a distribuzione marginale preservata, quali parti del gate trasferiscono e quali restano locali? Perimetri: - `DUALITA_golden`: sequenza Beatty aurea coerente vs permutazione illusoria. - `R_periodic_triad`: pattern periodico a 6 fasi vs permutazione illusoria. - `T_markov_alternating`: catena alternante low/high vs permutazione illusoria. - `E_ar1_continuity`: continuita AR(1) positiva vs permutazione illusoria. Parametri verificati: `n_gaps=4096`, `n_replicates=20`, `n_beta=11`, `n_baseline=32`, `z_min=2.0`, `seed=202605070901`. ## Deposito Numerico | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | ambiguous beta gated | |---|---:|---:|---:|---:|---:| | DUALITA_golden | SR, L1, triple_var | 3.00 | 0.25 | 3.418 | 0.30 | | R_periodic_triad | SR, SR2, L1, L2, triple_var | 5.00 | 0.25 | 4.400 | 0.30 | | T_markov_alternating | SR, SR2, L1, L2, triple_var | 5.00 | 0.05 | 4.412 | 0.30 | | E_ar1_continuity | SR, SR2, L1, L2, triple_var | 5.00 | 0.60 | 4.394 | 0.30 | Endpoint-stable observables: `[]` in all 4 perimeters. Verificato: no observable is stable at both coherent and illusory endpoints. The denominator gate is not a two-sided endpoint support. It is one-sided support for generated order. ## Risultato 1. The gate transfers as one-sided coherence support. In all 4 non-BOUNDARY perimeters, the coherent endpoint carries denominator support and the illusory endpoint loses it. `DUALITA_golden` transfers on `SR`, `L1`, `triple_var`; the three other perimeters transfer on all five canonical observables. 2. The both-endpoint stable set collapses everywhere. `endpoint_stable_observables: []` is not a failure of the test. It is the structural content: the gate does not name "two classes with stable denominators"; it names the side where order survives its own shuffle null. 3. The beta 0.30 ambiguity layer transfers as protocol coordinate, not as BOUNDARY coordinate. The ambiguous gated layer is beta `0.30` in all 4 perimeters. This is not a GUE/Poisson layer. It is the coordinate created by the replacement protocol: enough positions are illusory to place the layer near the endpoint bisector, while enough coherent order remains to keep large z support. 4. DUALITA is narrower than the other perimeters. `DUALITA_golden` has one-sided support on 3/5 observables. `SR2` and `L2` stay near shuffle at the coherent endpoint (`z_mean` about `0.12`). The DUALITA gate transfers, but only through lag-1 and triple aggregation in this synthetic perimeter. ## Consecutio The next word is not `boundary_layer`. The correct category is: `order_denominator_gate` Definition: an original-vs-shuffle denominator gate where support is expected on the coherent/generated side, endpoint-stable observables may be empty, and the layer coordinate belongs to the perturbation protocol unless anchored to a domain-specific semantic axis. This extends the 0803 result: - 0803: BOUNDARY denominator gate transfers to DUALITA, BOUNDARY coordinate does not. - 0901: across 4 non-BOUNDARY perimeters, the transferable object is one-sided order support; beta ambiguity is a protocol fold, not domain ontology. ## Self-Audit: 5 Lenti L1 hard constraint vs bias: no "always", "never", or "zero" claim is used without exact support. `endpoint_stable_observables: []` is exact for this run and perimeters. L2 quantity vs ratio: the report uses raw stable counts, endpoint distances, and beta layers. Percent language is avoided except where the script computes fractions. L3 no silent patching: the scope changed from BOUNDARY to non-BOUNDARY perimeters explicitly. The new category `order_denominator_gate` is declared instead of stretching `BOUNDARY_LAYER_GATE`. L4 edge cases: `E_ar1_continuity` has illusory stable_count `0.60`, so the illusory endpoint is weak-denominator, not denominator-absent. The claim is one-sided support dominance, not exact absence. L5 re-discovery vs discovery: the numerical mechanism is an original-vs-shuffle order test on synthetic sequences. No NEW mathematical theorem is claimed. ## Fonti - Verificato: `tools/data/agent_field_live.md` - Verificato: `tools/LAB_AGENT_CONTEXT.md` - Verificato: `tools/observables_registry.py` - Verificato: `tools/exp_denominator_gate_transfer_matrix.py` - Verificato: `tools/data/denominator_gate_transfer_matrix.json` - Inferito: `order_denominator_gate` as category needed by the downstream vocabulary, from the cross-perimeter matrix. exec /bin/bash -lc "sed -n '1,220p' tools/data/reports/agent_20260507_0923.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report — Semi-Real Order Denominator Gate timestamp: 2026-05-07 09:23 UTC category: gate_falsification_semireal verdict: scoped_operator observables_registry: 1.0.0-2026-05-06 observables_used: [SR, SR2, L1, L2, triple_var] tool: tools/exp_semireal_order_denominator_gate.py data: tools/data/semireal_order_denominator_gate_20260507_0923.json seed_check: tools/data/semireal_order_denominator_gate_20260507_0923_seedcheck.json ## Claim Under Test Verificato dal campo vivo: il cycle 0901 ha nominato `ORDER_DENOMINATOR_GATE` come supporto one-sided dell'ordine generato, ma lo ha fatto su perimetri sintetici. Il mandato corrente chiede falsificazione su domini non-sintetici o semi-reali. Domanda: se l'endpoint coerente è una sequenza ordinata reale/semi-reale e l'endpoint illusorio è una permutazione che preserva la marginale, il supporto denominatore resta one-sided o compare un controesempio? Perimetri: - `prime_gaps_first`: primi 4096 gap fra primi. - `zeta_zero_spacings_first`: primi 512 spacing fra zeri non banali di zeta, calcolati localmente con `mpmath.zetazero`. - `logistic_return_intervals`: 4096 intervalli di ritorno a `x > 0.95` nella mappa logistica caotica `x -> 4x(1-x)`. Gate: osservabile stabile se `abs(original - shuffle_mean) / shuffle_std >= 2`. ## Deposito Numerico Run principale: `n_replicates=20`, `n_beta=11`, `n_baseline=32`, `seed=202605070923`. Seed check: `n_replicates=12`, `n_baseline=24`, `seed=202605070924`. | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | |---|---:|---:|---:|---:|---:| | prime_gaps_first | SR, L1, triple_var | 3.000 | 0.650 | 3.270 | 0.30 | | logistic_return_intervals | [] | 0.200 | 0.100 | 0.000 | [] | | zeta_zero_spacings_first | SR, L2 | 2.150 | 0.250 | 2.666 | [] | Seed check: | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | |---|---:|---:|---:|---:|---:| | prime_gaps_first | SR, L1, triple_var | 3.000 | 0.250 | 3.288 | 0.30 | | logistic_return_intervals | [] | 0.000 | 0.583 | 0.000 | [] | | zeta_zero_spacings_first | SR, L2 | 2.417 | 0.333 | 2.700 | [] | Endpoint-stable observables: `[]` in all three perimeters in both runs. ## Risultato 1. **The order gate transfers to arithmetic and zeta spacing order.** Prime gaps carry one-sided support on `SR`, `L1`, and `triple_var`. Zeta-zero spacings carry one-sided support on `SR` and `L2`. In both cases the illusory endpoint remains weak-denominator under the same marginal. 2. **The logistic return perimeter is the counter-scope.** The logistic return sequence is ordered and generated by a deterministic chaotic system, but this canonical observable suite does not read its order as denominator support. The coherent endpoint stable count is `0.200` in the main run and `0.000` in the seed check. The gate does not transfer to this return-time observable. 3. **The transferable object is narrower than "real order".** `ORDER_DENOMINATOR_GATE` names order that survives a marginal-preserving shuffle in the canonical gap observables. It does not name every generated sequence. The node regressivo is the observable contract, not the gate threshold: if the order lives in return-time tail structure or symbolic itinerary, `SR/SR2/L1/L2/triple_var` can be blank. 4. **The beta layer is not universal.** Prime gaps reproduce beta `0.30` as the ambiguous protocol layer. Zeta has no gated ambiguous beta in this run. Logistic has no gated classifier because the one-sided observable set is empty. This extends 0901: beta `0.30` was a protocol fold in the synthetic matrix, not a cross-domain coordinate. ## Consecutio `ORDER_DENOMINATOR_GATE` survives as scoped operator: > In semi-real arithmetic/spectral spacing perimeters, the denominator gate is > one-sided support for order against a marginal-preserving shuffle. In > logistic return intervals, the canonical gap observables do not carry that > support; the gate output is blank rather than false-positive. Next experiment: do not tune `z_min`. Change the observable perimetro for the logistic counter-scope: symbolic itinerary block entropy, return-tail exponent, or recurrence-plot diagonal statistics, each with the same original-vs-shuffle denominator gate. That tests whether logistic order is absent for this gate or only invisible to the current canonical gap suite. ## Self-Audit: 5 Lenti L1 hard constraint vs bias: no universal claim is made. `endpoint_stable_observables: []` is exact for the run perimeters; "weak" means below the declared `abs(z)>=2` gate frequency, not numerical zero. L2 quantity vs ratio: raw stable counts and z means are reported before endpoint distances. No percentage drift claim is used. L3 no silent patching: 0901 claimed transfer on synthetic generated-order perimeters. This report narrows the scope after observing the logistic counter-perimeter; it does not rescue the original wording. L4 edge cases: logistic illusory stable_count is `0.583` in the seed check, so the claim is not "illusory endpoint absent." It is "no coherent one-sided support under the declared frequency rule." L5 re-discovery vs discovery: prime gap and zeta spacing order-vs-shuffle tests sit near known arithmetic/RMT order diagnostics; logistic return intervals sit near known recurrence and return-time diagnostics for chaotic maps. No NEW theorem is claimed. ## Fonti - Verificato: `tools/data/agent_field_live.md` - Verificato: `tools/LAB_AGENT_CONTEXT.md` - Verificato: `tools/observables_registry.py` - Verificato: `tools/exp_semireal_order_denominator_gate.py` - Verificato: `tools/data/semireal_order_denominator_gate_20260507_0923.json` - Verificato: `tools/data/semireal_order_denominator_gate_20260507_0923_seedcheck.json` - Inferito: logistic return intervals are a counter-scope for the canonical gap-observable form of `ORDER_DENOMINATOR_GATE`. codex Il nodo regressivo non è `z_min`: è l'osservabile. Sto preparando uno strumento nuovo che tiene fisso il null marginal-preserving e cambia solo il contratto osservabile sul perimetro logistic: entropia di blocco, coda dei ritorni e diagonali di recurrence plot. exec /bin/bash -lc "sed -n '1,220p' tools/data/seme.json" in /opt/MM_D-ND succeeded in 0ms: { "timestamp": "2026-05-07T09:47:22.985377", "piano": 73, "tensioni": [ { "id": "OBSERVABLE_REGISTRY", "tipo": "vincolo", "claim": "Ogni script che usa observables canonici (SR, SR2, L1, L2, triple_var) deve importare la definizione da tools/observables_registry.py. Varianti devono usare nomi distinti (SR_local_rigidity, triple_var_normalized) — niente shadowing del nome canonico. Ogni report deve dichiarare 'observables_registry: VERSION' nel header.", "intensita": 1.0, "porta": "infrastructure", "manuale": true, "condensato_ref": "A14,A8", "origine": "cristallizzato 06/05 dalla consecutio del cycle 20260506_0625 (autopoietico self-finding)", "added_at": "2026-05-06T07:03:58.213606+00:00" }, { "id": "PERTURBATION_DENOMINATOR_GATE", "tipo": "vincolo", "claim": "La dimensionalita di perturbazione va riportata solo insieme a PC2, versione observables_registry e gate original-vs-shuffle per osservabile. Nel perimetro 20260506_1941, Poisson e shuffle-primi producono rank_all ~1.8-2.0 con denominatori deboli; dopo gate abs(z)>=2 il rank stabile torna vicino a 1. Rank PCA non gated non e evidenza strutturale.", "intensita": 0.95, "porta": "META_BOUNDARY", "manuale": true, "condensato_ref": "A4,A8,A14,C2", "origine": "cycle agent_20260506_1941: perturbation rank size curve canonical observables", "added_at": "2026-05-06T19:41:00+00:00" }, { "id": "BOUNDARY_LAYER_GATE", "tipo": "vincolo", "claim": "I claim GUE/Poisson boundary devono riportare layer map: versione observables_registry, lista osservabili canonici, z original-vs-shuffle per osservabile, set endpoint-stable, e finestra/layer con margine classificatorio ambiguo. Nel perimetro sintetico agent_20260507_0330, il confine GUE-Poisson e beta 0.3-0.4: margine 0.070-0.083, ambiguous fraction 0.812-0.875, mentre gli osservabili stabili collassano da ~3.3 a 1.6. Il polo Poisson e classificabile ma denominator-weak.", "intensita": 0.93, "porta": "META_BOUNDARY", "manuale": true, "condensato_ref": "A4,A8,A9,A14,C2", "origine": "cycle agent_20260507_0330: synthetic GUE-Poisson mixture layer gate", "added_at": "2026-05-07T03:30:00+00:00" }, { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", "added_at": "2026-05-07T09:01:00+00:00" }, { "tipo": "confine_inesplorato", "id": "TRASCENDENZA_LIMITE", "claim": "La trascendenza e il limite attuale del modello. I punti fissi relazionali (non solo phi ma la rete di punti fissi tra osservabili) possono rivelare il vero grafo della realta e pattern nelle matrici. Il confine non e nella matematica - e nel passaggio tra piani.", "intensita": 0.9, "nota": "Input operatore 2026-04-10. Tocca: confine del modello, struttura relazionale dei punti fissi. Consecutio: quali punti fissi relazionali emergono dalle 21 tensioni attuali? Il grafo e gia nei dati?", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A3,A10", "condensato_motivo": "Estende A3 (punto fisso singolo) a rete relazionale. Tocca A10 (dipolo) come caso speciale." }, { "tipo": "scoperta", "id": "DUALITA_DIPOLARE_VS_ILLUSORIA", "claim": "Due tipi di dualita: (1) dipolare - generativa, il modello (det=-1), (2) illusoria - dispersiva, entropia (det=+1). Le regole incoerenti producono la seconda. La dualita illusoria e entropia come dispersione, non come informazione.", "intensita": 0.9, "nota": "Input operatore 2026-04-10. Tocca: entropia come dispersione illusoria vs generazione dipolare. Consecutio: nel Lab i domini Poisson (entropia massima) mostrano dualita illusoria? I domini GUE (strutturati) mostrano dualita dipolare? Il drift verso Poisson (POISSON_CONVERGENCE) e perdita di dualita dipolare?", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A2,A10,F5", "condensato_motivo": "Discrimina due forme di det. A2 (confine) e la soglia. A10 (dipolo) e il tipo 1. F5 (frame) misura la struttura D-ND che e tipo 1." }, { "tipo": "scoperta_numerica", "id": "METRIC_TENSOR", "claim": "Il tensore metrico dei primi è g=(p/2)². Nel tempo ln(p), è de Sitter 1+1D. z=-8.8 curvatura vs z=+22.5 rapporti ΔΓ.", "intensità": 0.9, "nota": "Sessione interattiva 4 aprile. Verificato su 78K primi.", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": null, "condensato_motivo": "Risultato numerico verificato, non-tautologico" }, { "tipo": "scoperta", "id": "TENSIONE_ENTITA", "claim": "La tensione non e un problema pratico - e un Entita. La tensione superflua crea latenza (tempo). Senza tensione superflua tutto e regolato da assiomi. Implicazione: le tensioni nel seme sono entita, non problemi da risolvere. Quelle superflue (det=+1) producono tempo/latenza.", "intensita": 0.85, "nota": "Input operatore 2026-04-10. Tocca: rapporto tensione/assioma. Operativamente: discriminare tensioni-entita (generative) da tensioni-superflue (dispersive) nel seme. Le 21 tensioni attuali - quante sono entita e quante latenza?", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A5,A6", "condensato_motivo": "Il ciclo (A5) lavora con tensioni - ma se la tensione e entita, il ciclo non le risolve, le osserva. Lo zero mobile (A6) e la tensione senza latenza." }, { "tipo": "confine_inesplorato", "id": "G_POTENZIALE_NULLA", "claim": "G e il potenziale di tutto come nulla - permette il prima e il dopo. Ci muoviamo come trascendenza dimensionale gravitazionale. G nel tetraedro non e una teoria tra le altre - e il potenziale che le rende possibili.", "intensita": 0.85, "nota": "Input operatore 2026-04-10. Tocca: ruolo di G nel tetraedro (T,Q,G,E). La fonte video_lp0RgZ6kQF8 dice: tensore metrico dentro la forma simplettica. G non e accanto a T,Q,E - e sotto. Consecutio: nei dati Lab, i ponti TxG e ExG hanno struttura diversa dai ponti TxQ?", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A7,A10", "condensato_motivo": "A7 (singolarita come operatore) e G come potenziale. A10 (dipolo) opera sul piano che G rende possibile." }, { "tipo": "confine_inesplorato", "id": "BOUNDARY", "claim": "8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo", "intensità": 0.8, "nota": "Il segnale non-triviale è DOVE la scissione cambia natura, non che converge a φ", "condensato_ref": "A9", "condensato_motivo": "Overlap termini con A9 (5 termini)", "porta": "condensato" }, { "tipo": "confine_inesplorato", "id": "PIANO_PRIMARIO_DUE_ASSIOMI", "claim": "I piani importanti sono il primario e i due assiomi che lo determinano nelle zone osservate. Non tutti gli assiomi operano ovunque - in ogni zona osservata, due assiomi determinano il piano primario.", "intensita": 0.8, "nota": "Input operatore 2026-04-10. Tocca: struttura locale degli assiomi. Consecutio: per ogni dominio Lab (primi, logistica, percolazione...) quali 2 assiomi del condensato sono operativi? Mappa assiomi x domini = grafo della realta locale.", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A9,A14", "condensato_motivo": "A9 (terzo incluso) opera CON il piano. A14 (cascata) propaga - ma propaga cosa, se solo 2 assiomi sono attivi per zona?" }, { "tipo": "task", "id": "TRAJECTORY_APPLY_20260507_0803", "claim": "Applied valutatore REDESIGN from 20260507_0803: Costruire una matrice di trasferibilita' del denominator gate: applicarlo a 3-4 perimetri non-BOUNDARY con poli coerente/illusorio e verificare quali parti trasferiscono (supporto one-sided, coordinat", "intensità": 0.7, "porta": "trajectory_apply", "condensato_ref": "A8,A14,A15", "manuale": true, "_source_log": "2026-05-07T08:10:22.658201+00:00", "_source_decision": "REDESIGN", "_source_reasoning": "Il ciclo ha prodotto evidenza controllata e replicata che il denominator gate trasferisce come operatore, ma non trasferisce la coordinata di layer BOUNDARY: ambiguita' classificativa e collasso del denominatore si separano. Continuare sul seme attuale centrato su GUE/Poisson rischia di restare nel " }, { "tipo": "task", "id": "TRAJECTORY_APPLY_20260507_0901", "claim": "Applied valutatore REDESIGN from 20260507_0901: Falsificare ORDER_DENOMINATOR_GATE su domini non-sintetici o semi-reali: applicare il gate one-sided a 2-3 sequenze fisiche/ponte gia' presenti nel sito, con shuffle e surrogati preservanti marginale,", "intensità": 0.7, "porta": "trajectory_apply", "condensato_ref": "A8,A14,A15", "manuale": true, "_source_log": "2026-05-07T09:07:53.577876+00:00", "_source_decision": "REDESIGN", "_source_reasoning": "La direzione corrente ha eseguito il mandato: la matrice di trasferibilita' su 4 perimetri non-BOUNDARY e' stata prodotta e ha nominato una nuova categoria, order_denominator_gate. Un altro giro nello stesso frame rischia accumulo numerico locale su sintetici; la prossima mossa deve falsificare il n" }, { "tipo": "simmetria_sospetta", "id": "META", "claim": "Tutti i 11 test passano — verifica che non stiamo testando solo tautologie", "intensità": 0.5, "nota": "La convergenza a φ è triviale (controprove). I test stanno verificando contenuto o struttura?", "condensato_ref": "A4,A12,C2", "porta": "verify_assertions_META_ALL_PASS", "condensato_motivo": "Ricorrente (3x in 2 giorni) e fuori dalla mappa" }, { "tipo": "task", "id": "TRAJECTORY_APPLY_20260507_0942", "claim": "Applied valutatore REDESIGN from 20260507_0942: Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics s", "intensità": 0.7, "porta": "trajectory_apply", "condensato_ref": "A8,A14,A15", "manuale": true, "_source_log": "2026-05-07T09:47:43.105142+00:00", "_source_decision": "REDESIGN", "_source_reasoning": "La direzione corrente ha completato il mandato sui perimetri fisici/ponte gia' presenti: il gate trasferisce come supporto canonico one-sided su metric, trace e QxE, mentre il supporto both-endpoint resta vuoto. La consecutio utile non e' un altro bridge run, ma il nodo regressivo gia' emerso: la bl" } ], "potenziale_bloccato": [], "varianza": [ "Tensioni risolte: {'TENSIONE_ENTITA', 'METRIC_TENSOR', 'BOUNDARY_LAYER_GATE', 'G_POTENZIALE_NULLA', 'DUALITA_DIPOLARE_VS_ILLUSORIA', 'TRAJECTORY_APPLY_20260507_0803', 'TRAJECTORY_APPLY_20260507_0901', 'PERTURBATION_DENOMINATOR_GATE', 'OBSERVABLE_REGISTRY', 'ORDER_DENOMINATOR_GATE', 'PIANO_PRIMARIO_DUE_ASSIOMI', 'TRASCENDENZA_LIMITE'}" ], "filtro": { "promosse": 14, "filtrate": 0, "condensato_claims": 30 }, "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", "verifica": { "pass": 11, "fail": 0, "skip": 0, "total": 11 }, "fonti_consumate": 0, "fonti_esterne": [ { "id": "video_lp0RgZ6kQF8", "title": "Equivalence between geometrical structures and entropy", "type": "video_digest", "keywords": [ "geometry", "entropy", "symplectic form", "statistical mechanics", "quantum", "thermodynamics", "inner product", "Born rule", "metric tensor", "electromagnetic tensor" ], "content": "La geometria degli stati (classici e quantistici) e l'entropia sono la stessa struttura — invertibili. La forma simplettica conta le configurazioni. Il tensore metrico dello spaziotempo appare dentro la forma simplettica estesa. Il tensore elettromagnetico pure. Statistical mechanics non è costruita sopra alla meccanica — è la stessa cosa.", "teorie": [ "T", "Q", "G", "E" ], "ponti_potenziali": [ { "coppia": "TxQ", "ponte": "forma simplettica = entropia (invertibili)", "nota": "geometry is entropy and entropy is geometry" }, { "coppia": "TxG", exec /bin/bash -lc 'find tools/data -maxdepth 1 -type f | sort | tail -40' in /opt/MM_D-ND exec /bin/bash -lc "rg 'logistic|return-tail|block entropy|recurrence' -n tools | head -80" in /opt/MM_D-ND succeeded in 0ms: tools/evolution_report.md:2:Il passo ha preso il contro-scope logistic lasciato dal run precedente e non lo ha tools/evolution_report.md:35:- Usare i bridge come perimetro positivo stabile e logistic come contro-scope tools/evolution_report.md:39:Il ciclo seguente puo' proseguire sul contro-scope logistic con osservabili native tools/exp_two_layer_universality.py:13: 1. Generate 7 gap/spacing sequences: primes, GUE, Poisson, AR(1), logistic, tools/exp_two_layer_universality.py:220:def gen_logistic_gaps(N, r=3.95): tools/exp_two_layer_universality.py:252: 'logistic': gen_logistic_gaps, tools/LAB_OPERATIVO.md:14:- 13 domini: Ising 2D, primi, logistica, cellular automata, zeta zeros, random matrix, etc. tools/data/notte_20260329_0330.md:11: logistica_biforcazione_cp_3.57: r=1.0, spacing=Poisson-like [conferma] tools/data/notte_20260329_0330.md:12: logistica_biforcazione_cp_3.83: r=0.5, spacing=? [conferma] tools/data/notte_20260329_0330.md:13: logistica_biforcazione_cp_3.665: r=1.0, spacing=Poisson-like [conferma] tools/data/notte_20260329_0330.md:16: logistica_biforcazione_cp_3.757: r=1.0, spacing=Poisson-like [conferma] tools/data/notte_20260329_0330.md:19: logistica_biforcazione_cp_4.0: r=?, spacing=? [VINCOLO] tools/data/notte_20260329_0330.md:29: vincolo riciclato: logistica_biforcazione: nessuna struttura D-ND evidente al p tools/data/notte_20260329_0330.md:33: anomalia propagata: logistica_biforcazione_cp_3.57 (convergenza_triviale) tools/data/notte_20260329_0330.md:34: anomalia propagata: logistica_biforcazione_cp_3.83 (struttura_dnd_piena) tools/data/notte_20260329_0330.md:35: anomalia propagata: logistica_biforcazione_cp_3.665 (convergenza_triviale) tools/data/notte_20260329_0330.md:41: logistica_biforcazione_var_3.9: r=1.000545256270447, spacing=Poisson-like (⟨r⟩=0.3914428894887236) tools/data/notte_20260329_0330.md:44: logistica_biforcazione_var_3.57: r=1.0, spacing=Poisson-like (⟨r⟩=0.35930230610663094) tools/data/notte_20260329_0330.md:89: logistica_biforcazione_cp_4.0: vincoli=['nessuna_struttura_dnd'] tools/data/notte_20260329_0330.md:96: Domini Poisson: logistica_biforcazione_cp_3.57, logistica_biforcazione_cp_3.665, logistica_biforcazione_cp_3.757, brownian_motion_cp_0.12230384159779378, brownian_motion_cp_0.8867788787335775, logistica_biforcazione_var_3.9, coupled_oscillators_var_50, brownian_motion_var_0.3, logistica_biforcazione_var_3.57 tools/data/notte_20260329_0330.md:97: Anomalie: logistica_biforcazione_cp_3.57(convergenza_triviale), logistica_biforcazione_cp_3.83(struttura_dnd_piena), logistica_biforcazione_cp_3.665(convergenza_triviale), numeri_primi_cp_100(struttura_dnd_piena), numeri_primi_cp_50000(struttura_dnd_piena) tools/data/markov_memory_by_gue_type.json:127: "domain": "logistica_biforcazione", tools/dnd_gap_resolution.py:137: logistic = [] tools/dnd_gap_resolution.py:140: logistic.append(x) tools/dnd_gap_resolution.py:141: signals['logistica'] = np.array(logistic) tools/dnd_gap_resolution.py:249: logistic = [] tools/dnd_gap_resolution.py:252: logistic.append(x) tools/dnd_gap_resolution.py:253: domini['logistica'] = np.array(logistic) tools/exp_bridge_order_denominator_gate.py:161: "question": "Does ORDER_DENOMINATOR_GATE survive on D-ND bridge sequences beyond prime/zeta/logistic gaps?", tools/exp_semireal_order_denominator_gate.py:72:def logistic_return_intervals(n_gaps: int, rng: np.random.Generator) -> np.ndarray: tools/exp_semireal_order_denominator_gate.py:73: # Return intervals to a high-density-edge event in the fully chaotic logistic map. tools/exp_semireal_order_denominator_gate.py:90: raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {needed}") tools/exp_semireal_order_denominator_gate.py:268: "logistic_return_intervals": logistic_return_intervals(args.n_gaps, rng), tools/paper_H_verify.py:226: # 3-term recurrence tools/exp_markov_memory_by_gue_type.py:180: for dom_name in ['logistica_biforcazione', 'brownian_motion']: tools/exp_crossover_phase_test.py:116:def generate_logistic_gaps(N, rng): tools/exp_crossover_phase_test.py:220: sequences['Logistic'] = generate_logistic_gaps(args.N, rng) tools/dnd_condizioni.py:255: # 6. Mappa logistica al bordo del caos tools/dnd_condizioni.py:257: logistic = [] tools/dnd_condizioni.py:260: logistic.append(x) tools/dnd_condizioni.py:261: segnali["logistica"] = np.array(logistic) tools/dnd_autoricerca.py:54: 'zeta_zeros', 'logistica_biforcazione', 'string_vibration', tools/dnd_autoricerca.py:101: elif dominio == 'logistica_biforcazione': tools/dnd_autoricerca.py:102: return _logistica_biforcazione() tools/dnd_autoricerca.py:233:def _logistica_biforcazione(): tools/dnd_autoricerca.py:234: """Mappa logistica: orbita al punto di biforcazione periodo-3.""" tools/dnd_autoricerca.py:248: 'dominio': 'logistica_biforcazione', tools/dnd_autoricerca.py:250: 'nota': f'Mappa logistica a r=1+√8≈{r:.4f} (onset periodo-3)' tools/dnd_autoricerca.py:931: 'logistica_biforcazione': {'r': var_param}, tools/dnd_autoricerca.py:1417: ('logistica_biforcazione', {'r_override': 3.57}), # caotico tools/dnd_autoricerca.py:1418: ('logistica_biforcazione', {'r_override': 3.9}), # fully chaotic tools/dnd_autoricerca.py:1447: ('logistica_biforcazione', {'r_override': 3.83}), # finestra periodo-3: dipolo 0.50 borderline tools/dnd_autoricerca.py:1448: ('logistica_biforcazione', {'r_override': 4.0}), # beyond: CV rompe convergenza a phi-1 tools/dnd_autoricerca.py:1543: controprove.append(('logistica_biforcazione', {'r_override': 3.57})) # onset caos tools/dnd_autoricerca.py:1544: controprove.append(('logistica_biforcazione', {'r_override': 3.83})) # finestra periodo-3 tools/dnd_autoricerca.py:1545: controprove.append(('logistica_biforcazione', {'r_override': round(3.57 + random.uniform(0, 0.43), 3)})) tools/dnd_autoricerca.py:2264: elif dominio_base == 'logistica_biforcazione': tools/dnd_autoricerca.py:2274: 'dominio': 'logistica_biforcazione', 'r': r, tools/m_spectro.py:930:def gen_logistic_edge(n=10000): tools/m_spectro.py:931: """Mappa logistica al punto di Feigenbaum (r=3.5699...). tools/m_spectro.py:1133: if '--logistic' in args or '--confronto' in args: tools/m_spectro.py:1134: print(" Generando logistic edge...", end=" ", flush=True) tools/m_spectro.py:1135: domini['logistic_edge'] = gen_logistic_edge(20000) tools/m_spectro.py:1136: print(f"{len(domini['logistic_edge'])} gap") tools/m_spectro.py:1165: print(" Nuovi: --stern --pi --thue --logistic --farey") tools/README.md:13:| `m_spectro_calibra.py` | Calibrazione M-Spectro: mappa logistica + Collatz scomposto | Automatico | LVL-2 vs Lyapunov, dipolo per regime | tools/dnd_experiments.py:361:def esperimento_boundary_logistica(): tools/dnd_experiments.py:363: Testa H_boundary: transizione in mappa logistica al variare di r. tools/dnd_experiments.py:435: 'r_logistic': float(r), tools/dnd_experiments.py:471: 'esperimento': 'boundary_logistica', tools/dnd_experiments.py:815: Se CV_max ≈ stesso valore per Ising, logistica, percolazione, tools/dnd_experiments.py:822: print("Il CV è lo stesso numero per Ising, logistica, percolazione?") tools/dnd_experiments.py:893: logistica_profile = [] tools/dnd_experiments.py:911: logistica_profile.append({ tools/dnd_experiments.py:917: all_cv_profiles['logistica'] = { tools/dnd_experiments.py:920: 'profile': logistica_profile, tools/dnd_experiments.py:1187: r3 = esperimento_boundary_logistica() tools/dnd_experiments.py:1242: elif cmd == '--boundary-logistica': tools/dnd_experiments.py:1243: esperimento_boundary_logistica() tools/dnd_experiments.py:1253: print(f"Uso: python {sys.argv[0]} [--hurst|--boundary-ising|--boundary-logistica|--order|--ising-deep|--cv-universale|--all]") succeeded in 0ms: tools/data/semireal_order_denominator_gate_20260507_0923.json tools/data/semireal_order_denominator_gate_20260507_0923_seedcheck.json tools/data/specchio_20260314.json tools/data/spectral_gap_results.json tools/data/spectral_rigidity_results.json tools/data/spettro_zeta_results.json tools/data/spirale_M_primi.png tools/data/stato_ciclo.json tools/data/synthetic_validation.json tools/data/tension_to_theory.json tools/data/test_rarefazione_20260313.json tools/data/test_semiprimi_20260313.json tools/data/topological_charge_results.json tools/data/torre_results.json tools/data/trace_bridge_results.json tools/data/traiettorie_M_primi.png tools/data/trajectory_apply_history.jsonl tools/data/trasmutazione_results.json tools/data/two_channel_boundary.json tools/data/two_channel_cross_domain.json tools/data/two_channel_shuffle_audit.json tools/data/two_layer_universality.json tools/data/valutatore_log.jsonl tools/data/vault_condizioni.json tools/data/video_feed.json tools/data/vocabolario_custom.json tools/data/zero_confronto_20260310_0822.json tools/data/zero_confronto_20260310_0830.json tools/data/zero_confronto_20260317_1604.json tools/data/zero_controllo2_20260310_1703.json tools/data/zero_controllo_20260310_1659.json tools/data/zero_ising_20260310_1716.json tools/data/zero_multiscala_primi_20260310_0831.json tools/data/zero_notturno_20260310_0858.json tools/data/zero_primi_20260310_0820.json tools/data/zero_signature_logistic.png tools/data/zero_traiettoria_20260310_1649.json tools/data/zero_varieta_20260310_1831.json tools/data/zero_varieta_primi_20260310_1842.json tools/data/zeta_validation_results.json codex Faccio una modifica contenuta: aggiungo `tools/exp_logistic_counter_scope_gate.py`. Lo script non tocca gli osservabili canonici `SR/...`; dichiara un set nativo logistic con nomi distinti, così il registry non viene aggirato né shadowato. apply patch patch: completed /opt/MM_D-ND/tools/exp_logistic_counter_scope_gate.py diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex Strumento creato. Ora lo eseguo una prima volta con i parametri del cycle e poi faccio un seed check più leggero per distinguere risultato stabile da rumore del protocollo. exec /bin/bash -lc 'python tools/exp_logistic_counter_scope_gate.py' in /opt/MM_D-ND diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex Il run sta ancora calcolando le statistiche di recurrence plot; è la parte O(n²), quindi è atteso che non produca output progressivo. Lo lascio finire e, se il tempo cresce troppo, riduco solo la dimensione del seed check, non il run principale già avviato. diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex Il primo run è troppo pesante per il numero di shuffle: recurrence plot viene ricalcolato migliaia di volte. Interrompo e riduco il costo nel nodo giusto, cioè la dimensione interna del recurrence plot, mantenendo invariati `z_min`, protocollo original-vs-shuffle e osservabili. 2026-05-07T10:09:57.646174Z ERROR codex_core::tools::router: error=write_stdin failed: stdin is closed for this session; rerun exec_command with tty=true to keep stdin open diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'pkill -f exp_logistic_counter_scope_gate.py || true' in /opt/MM_D-ND exited 143 in 0ms: diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..03430f2bb2a1577ecc443db70969a9591ec43d4d --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,439 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle(values: np.ndarray, n_baseline: int, rng: np.random.Generator) -> tuple[dict, dict, dict, dict]: + original = compute_native(values) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values)) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex Ho fermato il processo: nessun output utile era stato scritto. Correggo lo strumento per rendere `recurrence_max_points` un parametro esplicito del protocollo e lo includo nel JSON, così il costo computazionale resta leggibile nel report. apply patch patch: completed /opt/MM_D-ND/tools/exp_logistic_counter_scope_gate.py diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'python tools/exp_logistic_counter_scope_gate.py --n-replicates 8 --n-baseline 12 --out tools/data/logistic_counter_scope_gate_20260507_1006.json' in /opt/MM_D-ND diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() succeeded in 46926ms: observables_native_version=logistic-native-1.0.0-2026-05-07 observables_used=['block_entropy_deficit_k4', 'return_tail_alpha', 'recurrence_diag_mean', 'recurrence_determinism'] perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate logistic_orbit_values 4096 block_entropy_deficit_k4 1.000 0.375 1.936 [0.1] logistic_symbolic_itinerary 4096 [] 0.000 0.750 0.000 [] logistic_return_intervals 4096 recurrence_diag_mean 1.125 0.250 1.764 [] saved tools/data/logistic_counter_scope_gate_20260507_1006.json codex Il run principale ha già separato tre casi: orbita continua leggibile da entropia di blocco, itinerary simbolico blank, ritorni leggibili debolmente da recurrence. Ora faccio seed check con stesso contratto e campione più leggero. exec /bin/bash -lc 'python tools/exp_logistic_counter_scope_gate.py --n-replicates 6 --n-baseline 10 --seed 202605071007 --out tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json' in /opt/MM_D-ND diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() succeeded in 31538ms: observables_native_version=logistic-native-1.0.0-2026-05-07 observables_used=['block_entropy_deficit_k4', 'return_tail_alpha', 'recurrence_diag_mean', 'recurrence_determinism'] perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate logistic_orbit_values 4096 block_entropy_deficit_k4 1.000 0.000 1.915 [0.1] logistic_symbolic_itinerary 4096 [] 0.167 0.167 0.000 [] logistic_return_intervals 4096 [] 0.000 0.167 0.000 [] saved tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json exec /bin/bash -lc "python -m json.tool tools/data/logistic_counter_scope_gate_20260507_1006.json | sed -n '1,220p'" in /opt/MM_D-ND succeeded in 0ms: { "experiment": "logistic_counter_scope_gate", "category": "gate_falsification_logistic_observability", "question": "Does the logistic counter-scope stay blank under logistic-native observables?", "observables_native_version": "logistic-native-1.0.0-2026-05-07", "observables_used": [ "block_entropy_deficit_k4", "return_tail_alpha", "recurrence_diag_mean", "recurrence_determinism" ], "params": { "n_values": 4096, "n_returns": 4096, "n_replicates": 8, "n_beta": 11, "n_baseline": 12, "recurrence_max_points": 360, "z_min": 2.0, "seed": 202605071006, "out": "tools/data/logistic_counter_scope_gate_20260507_1006.json" }, "matrix": { "logistic_orbit_values": { "n": 4096, "coherent_one_sided_observables": [ "block_entropy_deficit_k4" ], "endpoint_stable_observables": [], "stable_count_coherent": 1.0, "stable_count_illusory": 0.375, "z_mean_coherent": { "block_entropy_deficit_k4": 707.1164716202046, "return_tail_alpha": -0.5729437361560292, "recurrence_diag_mean": -0.39347535999266714, "recurrence_determinism": -0.7964715325809927 }, "z_mean_illusory": { "block_entropy_deficit_k4": -0.36616147065682286, "return_tail_alpha": 0.0010099412123474871, "recurrence_diag_mean": 1.1337759302995405, "recurrence_determinism": 0.10279321371556724 }, "endpoint_distance_all": 2.5912798136794364, "endpoint_distance_one_sided_gated": 1.936487344615918, "ambiguous_beta_one_sided_gated": [ 0.1 ] }, "logistic_symbolic_itinerary": { "n": 4096, "coherent_one_sided_observables": [], "endpoint_stable_observables": [], "stable_count_coherent": 0.0, "stable_count_illusory": 0.75, "z_mean_coherent": { "block_entropy_deficit_k4": -0.062150574886171484, "return_tail_alpha": -0.7577581005040721, "recurrence_diag_mean": -1.2645830605220785, "recurrence_determinism": -0.5002257024621616 }, "z_mean_illusory": { "block_entropy_deficit_k4": 1.0603283191256443, "return_tail_alpha": 0.5914211188759305, "recurrence_diag_mean": 0.6267587903878287, "recurrence_determinism": 0.23802365265115213 }, "endpoint_distance_all": 2.294844651217752, "endpoint_distance_one_sided_gated": 0.0, "ambiguous_beta_one_sided_gated": [] }, "logistic_return_intervals": { "n": 4096, "coherent_one_sided_observables": [ "recurrence_diag_mean" ], "endpoint_stable_observables": [], "stable_count_coherent": 1.125, "stable_count_illusory": 0.25, "z_mean_coherent": { "block_entropy_deficit_k4": 1.4792973260503641, "return_tail_alpha": 0.0, "recurrence_diag_mean": 2.538951885886552, "recurrence_determinism": -0.3711447241951161 }, "z_mean_illusory": { "block_entropy_deficit_k4": -0.38568689899310316, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.20691682486445223, "recurrence_determinism": -0.1882265781697493 }, "endpoint_distance_all": 2.123824857255968, "endpoint_distance_one_sided_gated": 1.7642841028459546, "ambiguous_beta_one_sided_gated": [] } }, "perimeters": { "logistic_orbit_values": { "source": { "n": 4096, "mean": 0.49768078713670105, "variance": 0.12558524763672146, "unique_values": 4096 }, "gate": { "z_min": 2.0, "coherent_one_sided_observables": [ "block_entropy_deficit_k4" ], "endpoint_stable_observables": [], "layers": { "0.000": { "stable_count_mean": 1.0, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 707.1164716202046, "return_tail_alpha": -0.5729437361560292, "recurrence_diag_mean": -0.39347535999266714, "recurrence_determinism": -0.7964715325809927 } }, "0.100": { "stable_count_mean": 1.0, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 332.1611243634269, "return_tail_alpha": 0.5352417951534506, "recurrence_diag_mean": 0.09363269331522606, "recurrence_determinism": -1.0412162299719299 } }, "0.200": { "stable_count_mean": 1.375, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.125, "recurrence_diag_mean": 0.125, "recurrence_determinism": 0.125 }, "z_mean": { "block_entropy_deficit_k4": 206.9482488107968, "return_tail_alpha": 0.427073553638424, "recurrence_diag_mean": -0.08824728461909531, "recurrence_determinism": -0.498571437178497 } }, "0.300": { "stable_count_mean": 1.0, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 125.78346164876206, "return_tail_alpha": 0.23500972626103828, "recurrence_diag_mean": 0.03700604720906342, "recurrence_determinism": 0.19934923301392776 } }, "0.400": { "stable_count_mean": 1.25, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.125, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.125 }, "z_mean": { "block_entropy_deficit_k4": 60.41007457962223, "return_tail_alpha": -0.2001179905898469, "recurrence_diag_mean": -0.18289009982423013, "recurrence_determinism": -0.46857442549659734 } }, "0.500": { "stable_count_mean": 1.25, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.25, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 26.391808420009966, "return_tail_alpha": 1.4577118442454005, "recurrence_diag_mean": -0.23017152447182626, "recurrence_determinism": -0.28018025678911407 } }, "0.600": { "stable_count_mean": 1.25, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.125, "recurrence_diag_mean": 0.125, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 10.53036542229385, "return_tail_alpha": -0.14949229349627133, "recurrence_diag_mean": 0.4386317861131827, "recurrence_determinism": 0.31851771406887414 } }, "0.700": { "stable_count_mean": 0.875, "stable_frequency": { "block_entropy_deficit_k4": 0.875, exec /bin/bash -lc "python - <<'PY' import json for p in ['tools/data/logistic_counter_scope_gate_20260507_1006.json','tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json']: d=json.load(open(p)) print(p) for name,row in d['matrix'].items(): print(name) print(' one_sided', row['coherent_one_sided_observables']) print(' endpoint_stable', row['endpoint_stable_observables']) print(' z0', {k: round(v,3) for k,v in row['z_mean_coherent'].items()}) print(' z1', {k: round(v,3) for k,v in row['z_mean_illusory'].items()}) print(' stable', row['stable_count_coherent'], row['stable_count_illusory'], 'dist', row['endpoint_distance_one_sided_gated'], 'amb', row['ambiguous_beta_one_sided_gated']) PY" in /opt/MM_D-ND succeeded in 0ms: tools/data/logistic_counter_scope_gate_20260507_1006.json logistic_orbit_values one_sided ['block_entropy_deficit_k4'] endpoint_stable [] z0 {'block_entropy_deficit_k4': 707.116, 'return_tail_alpha': -0.573, 'recurrence_diag_mean': -0.393, 'recurrence_determinism': -0.796} z1 {'block_entropy_deficit_k4': -0.366, 'return_tail_alpha': 0.001, 'recurrence_diag_mean': 1.134, 'recurrence_determinism': 0.103} stable 1.0 0.375 dist 1.936487344615918 amb [0.1] logistic_symbolic_itinerary one_sided [] endpoint_stable [] z0 {'block_entropy_deficit_k4': -0.062, 'return_tail_alpha': -0.758, 'recurrence_diag_mean': -1.265, 'recurrence_determinism': -0.5} z1 {'block_entropy_deficit_k4': 1.06, 'return_tail_alpha': 0.591, 'recurrence_diag_mean': 0.627, 'recurrence_determinism': 0.238} stable 0.0 0.75 dist 0.0 amb [] logistic_return_intervals one_sided ['recurrence_diag_mean'] endpoint_stable [] z0 {'block_entropy_deficit_k4': 1.479, 'return_tail_alpha': 0.0, 'recurrence_diag_mean': 2.539, 'recurrence_determinism': -0.371} z1 {'block_entropy_deficit_k4': -0.386, 'return_tail_alpha': 0.0, 'recurrence_diag_mean': 0.207, 'recurrence_determinism': -0.188} stable 1.125 0.25 dist 1.7642841028459546 amb [] tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json logistic_orbit_values one_sided ['block_entropy_deficit_k4'] endpoint_stable [] z0 {'block_entropy_deficit_k4': 640.298, 'return_tail_alpha': 0.41, 'recurrence_diag_mean': -0.363, 'recurrence_determinism': -1.165} z1 {'block_entropy_deficit_k4': -0.529, 'return_tail_alpha': -0.497, 'recurrence_diag_mean': -0.452, 'recurrence_determinism': -0.298} stable 1.0 0.0 dist 1.9148503765295133 amb [0.1] logistic_symbolic_itinerary one_sided [] endpoint_stable [] z0 {'block_entropy_deficit_k4': -1.678, 'return_tail_alpha': 0.109, 'recurrence_diag_mean': 0.499, 'recurrence_determinism': -0.36} z1 {'block_entropy_deficit_k4': 0.24, 'return_tail_alpha': -0.23, 'recurrence_diag_mean': -0.229, 'recurrence_determinism': 0.587} stable 0.16666666666666666 0.16666666666666666 dist 0.0 amb [] logistic_return_intervals one_sided [] endpoint_stable [] z0 {'block_entropy_deficit_k4': -0.473, 'return_tail_alpha': 0.0, 'recurrence_diag_mean': -1.281, 'recurrence_determinism': -1.189} z1 {'block_entropy_deficit_k4': -0.204, 'return_tail_alpha': 0.0, 'recurrence_diag_mean': 0.421, 'recurrence_determinism': -0.093} stable 0.0 0.16666666666666666 dist 0.0 amb [] exec /bin/bash -lc "python -m json.tool tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json | sed -n '1,220p'" in /opt/MM_D-ND succeeded in 0ms: { "experiment": "logistic_counter_scope_gate", "category": "gate_falsification_logistic_observability", "question": "Does the logistic counter-scope stay blank under logistic-native observables?", "observables_native_version": "logistic-native-1.0.0-2026-05-07", "observables_used": [ "block_entropy_deficit_k4", "return_tail_alpha", "recurrence_diag_mean", "recurrence_determinism" ], "params": { "n_values": 4096, "n_returns": 4096, "n_replicates": 6, "n_beta": 11, "n_baseline": 10, "recurrence_max_points": 360, "z_min": 2.0, "seed": 202605071007, "out": "tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json" }, "matrix": { "logistic_orbit_values": { "n": 4096, "coherent_one_sided_observables": [ "block_entropy_deficit_k4" ], "endpoint_stable_observables": [], "stable_count_coherent": 1.0, "stable_count_illusory": 0.0, "z_mean_coherent": { "block_entropy_deficit_k4": 640.2983897152947, "return_tail_alpha": 0.4098911085903408, "recurrence_diag_mean": -0.36280961088369074, "recurrence_determinism": -1.1646811275833349 }, "z_mean_illusory": { "block_entropy_deficit_k4": -0.5287463451323228, "return_tail_alpha": -0.4971498526850917, "recurrence_diag_mean": -0.452434348481864, "recurrence_determinism": -0.29790342854967067 }, "endpoint_distance_all": 2.605270621278144, "endpoint_distance_one_sided_gated": 1.9148503765295133, "ambiguous_beta_one_sided_gated": [ 0.1 ] }, "logistic_symbolic_itinerary": { "n": 4096, "coherent_one_sided_observables": [], "endpoint_stable_observables": [], "stable_count_coherent": 0.16666666666666666, "stable_count_illusory": 0.16666666666666666, "z_mean_coherent": { "block_entropy_deficit_k4": -1.6783896306287858, "return_tail_alpha": 0.10882718287078619, "recurrence_diag_mean": 0.4989486645329839, "recurrence_determinism": -0.3596169812966063 }, "z_mean_illusory": { "block_entropy_deficit_k4": 0.24027639685040728, "return_tail_alpha": -0.22956893978821133, "recurrence_diag_mean": -0.22906989628161178, "recurrence_determinism": 0.5866291552608762 }, "endpoint_distance_all": 2.1684346649464454, "endpoint_distance_one_sided_gated": 0.0, "ambiguous_beta_one_sided_gated": [] }, "logistic_return_intervals": { "n": 4096, "coherent_one_sided_observables": [], "endpoint_stable_observables": [], "stable_count_coherent": 0.0, "stable_count_illusory": 0.16666666666666666, "z_mean_coherent": { "block_entropy_deficit_k4": -0.4730244046235184, "return_tail_alpha": 0.0, "recurrence_diag_mean": -1.2808795038867211, "recurrence_determinism": -1.1889117549779924 }, "z_mean_illusory": { "block_entropy_deficit_k4": -0.2044571740962142, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.4214715515947363, "recurrence_determinism": -0.09265460834659185 }, "endpoint_distance_all": 2.2123318706263535, "endpoint_distance_one_sided_gated": 0.0, "ambiguous_beta_one_sided_gated": [] } }, "perimeters": { "logistic_orbit_values": { "source": { "n": 4096, "mean": 0.48990793192560333, "variance": 0.1274590608909048, "unique_values": 4096 }, "gate": { "z_min": 2.0, "coherent_one_sided_observables": [ "block_entropy_deficit_k4" ], "endpoint_stable_observables": [], "layers": { "0.000": { "stable_count_mean": 1.0, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 640.2983897152947, "return_tail_alpha": 0.4098911085903408, "recurrence_diag_mean": -0.36280961088369074, "recurrence_determinism": -1.1646811275833349 } }, "0.100": { "stable_count_mean": 1.5, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.3333333333333333, "recurrence_diag_mean": 0.16666666666666666, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 318.56070621505063, "return_tail_alpha": 1.2984513949784326, "recurrence_diag_mean": -0.5077294847654138, "recurrence_determinism": -0.48108757686984216 } }, "0.200": { "stable_count_mean": 1.3333333333333333, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.16666666666666666, "recurrence_diag_mean": 0.16666666666666666, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 210.31257643428185, "return_tail_alpha": 0.4766090653517905, "recurrence_diag_mean": 1.520247174665619, "recurrence_determinism": 0.19184199320694742 } }, "0.300": { "stable_count_mean": 1.3333333333333333, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.16666666666666666, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.16666666666666666 }, "z_mean": { "block_entropy_deficit_k4": 93.50004754809868, "return_tail_alpha": -0.09688626799368416, "recurrence_diag_mean": 0.6079039528225719, "recurrence_determinism": -0.47197609477499886 } }, "0.400": { "stable_count_mean": 1.5, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.5 }, "z_mean": { "block_entropy_deficit_k4": 67.12899976813482, "return_tail_alpha": 0.3970607270991547, "recurrence_diag_mean": -0.4399970078360093, "recurrence_determinism": -1.9676132240179374 } }, "0.500": { "stable_count_mean": 1.3333333333333333, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.0, "recurrence_diag_mean": 0.3333333333333333, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 27.908663718456776, "return_tail_alpha": 0.16971618831715118, "recurrence_diag_mean": -0.2325210345365302, "recurrence_determinism": -0.42571052914757757 } }, "0.600": { "stable_count_mean": 1.1666666666666667, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.16666666666666666, "recurrence_diag_mean": 0.0, "recurrence_determinism": 0.0 }, "z_mean": { "block_entropy_deficit_k4": 10.788438670897008, "return_tail_alpha": 0.43911947064516293, "recurrence_diag_mean": 0.20741593564671854, "recurrence_determinism": 0.3422214323621709 } }, "0.700": { "stable_count_mean": 1.5, "stable_frequency": { "block_entropy_deficit_k4": 1.0, "return_tail_alpha": 0.16666666666666666, "recurrence_diag_mean": 0.16666666666666666, diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'git status --short' in /opt/MM_D-ND succeeded in 0ms: M applications/INDEX.draft.json M applications/soluzioni/20260430_0330_three-regimes-of-modular-memory-algebraic/finding_index.draft.json M applications/soluzioni/20260430_0330_three-regimes-of-modular-memory-algebraic/manifest.draft.json M tools/LAB_AGENT_CONTEXT.md M tools/data/agent_field_live.md M tools/data/conoscenza_teorie.json M tools/data/consecutio.json M tools/data/consecutio_processata.json M tools/data/domande_fondamentali.json M tools/data/incrocio_risultato.json M tools/data/lab_data.json M tools/data/lab_graph.json M tools/data/lab_health.json M tools/data/lab_session_log.jsonl M tools/data/pipeline_state.json M tools/data/ponti_evoluti.json M tools/data/refresh_detector_state.json M tools/data/seme.json D tools/data/seme_archive/piano_37.json D tools/data/seme_archive/piano_38.json D tools/data/seme_archive/piano_4.json D tools/data/seme_archive/piano_5.json D tools/data/seme_archive/piano_6.json M tools/data/seme_axioms.json M tools/data/seme_backup_pre_run.json M tools/data/tm1_figures/tensions.json M tools/data/tm1_figures/tensions_raw.json ?? applications/published/20260504_0901_the-two-markov-layers-are-coupled/ ?? applications/published/20260504_1219_markov-layers-pass-the-first-recovery/ ?? applications/published/20260505_0330_observable-rank-audit-many-probes-one/ ?? applications/published/20260506_1955_observable-collinearity-breaks-only-where-denominators/ ?? applications/published/20260507_0330_the-gue-poisson-boundary-is-a/ ?? applications/published/20260507_0803_denominator-gate-transfers-boundary-coordinate-does/ ?? applications/published/20260507_0942_bridge-order-denominator-gate/ ?? applications/scoperte/20260502_0330_the-dipolar-phase-transition-is-nearly_auto/ ?? applications/scoperte/20260503_0330_markov-memory-has-two-visible-layers_auto/ ?? applications/scoperte/20260504_0901_the-two-markov-layers-are-coupled_auto/ ?? applications/scoperte/20260504_1219_markov-layers-pass-the-first-recovery_auto/ ?? applications/scoperte/20260505_0330_observable-rank-audit-many-probes-one_auto/ ?? applications/scoperte/20260506_0625_perturbation-dimensionality-is-not-yet-a_auto/ ?? applications/scoperte/20260506_1941_perturbation-rank-needs-denominator-gating_auto/ ?? applications/scoperte/20260506_1955_observable-collinearity-breaks-only-where-denominators_auto/ ?? applications/scoperte/20260507_0330_the-gue-poisson-boundary-is-a_auto/ ?? applications/scoperte/20260507_0803_denominator-gate-transfers-boundary-coordinate-does_auto/ ?? applications/scoperte/20260507_0901_denominator-gate-transfer-matrix_auto/ ?? applications/scoperte/20260507_0923_semi-real-order-denominator-gate_auto/ ?? applications/scoperte/20260507_0942_bridge-order-denominator-gate_auto/ ?? applications/soluzioni/20260502_0330_the-dipolar-phase-transition-is-nearly/ ?? applications/soluzioni/20260503_0330_markov-memory-has-two-visible-layers/ ?? applications/soluzioni/20260504_0901_the-two-markov-layers-are-coupled/ ?? applications/soluzioni/20260504_1219_markov-layers-pass-the-first-recovery/ ?? applications/soluzioni/20260505_0330_observable-rank-audit-many-probes-one/ ?? applications/soluzioni/20260506_1941_perturbation-rank-needs-denominator-gating/ ?? applications/soluzioni/20260506_1955_observable-collinearity-breaks-only-where-denominators/ ?? applications/soluzioni/20260507_0330_the-gue-poisson-boundary-is-a/ ?? applications/soluzioni/20260507_0803_denominator-gate-transfers-boundary-coordinate-does/ ?? applications/soluzioni/20260507_0942_bridge-order-denominator-gate/ ?? findings_gallery.md ?? tools/data/.last_telegram_msg ?? tools/data/3d_boundary_layers.json ?? tools/data/aeternitas/ ?? tools/data/alignment_active.json ?? tools/data/alignment_markers.jsonl ?? tools/data/bicono_projections.jsonl ?? tools/data/boundary_coherence.json ?? tools/data/boundary_mixture_gate_20260507_0330.json ?? tools/data/boundary_mixture_gate_20260507_0330_seedcheck.json ?? tools/data/boundary_shuffle_audit.json ?? tools/data/bridge_order_denominator_gate_20260507_0942.json ?? tools/data/bridge_order_denominator_gate_20260507_0942_seedcheck.json ?? tools/data/brody_calibration_results.json ?? tools/data/brody_flow.json ?? tools/data/conoscenza_teorie.json.bak.retraction_22_04 ?? tools/data/cross_domain_dipolar_direction.json ?? tools/data/cross_observable_consistency.json ?? tools/data/crossover_phase_test.json ?? tools/data/denominator_gate_transfer_matrix.json ?? tools/data/dipolar_crossover.json ?? tools/data/dipolar_vector_scaling.json ?? tools/data/domandatore/domandatore_20260421_0746.json ?? tools/data/domandatore/domandatore_20260422_0345.json ?? tools/data/domandatore/domandatore_20260423_0345.json ?? tools/data/domandatore/domandatore_20260424_0345.json ?? tools/data/domandatore/domandatore_20260425_0345.json ?? tools/data/domandatore/domandatore_20260426_0345.json ?? tools/data/domandatore/domandatore_20260427_0345.json ?? tools/data/domandatore/domandatore_20260428_0345.json ?? tools/data/domandatore/domandatore_20260428_1236.json ?? tools/data/domandatore/domandatore_20260429_0345.json ?? tools/data/domandatore/domandatore_20260430_0345.json ?? tools/data/domandatore/domandatore_20260501_0345.json ?? tools/data/domandatore/domandatore_20260502_0345.json ?? tools/data/domandatore/domandatore_20260503_0345.json ?? tools/data/domandatore/domandatore_20260504_0345.json ?? tools/data/domandatore/domandatore_20260505_0345.json ?? tools/data/domandatore/domandatore_20260506_0345.json ?? tools/data/domandatore/domandatore_20260507_0345.json ?? tools/data/domandatore/domandatore_20260507_0728.json ?? tools/data/domandatore/domandatore_20260507_0742.json ?? tools/data/duality_gate_transfer_20260507_0803.json ?? tools/data/duality_gate_transfer_20260507_0803_seedcheck.json ?? tools/data/evolution/evolution_20260422_0330.md ?? tools/data/evolution/evolution_20260422_1616.md ?? tools/data/evolution/evolution_20260423_0330.md ?? tools/data/evolution/evolution_20260424_0330.md ?? tools/data/evolution/evolution_20260425_0330.md ?? tools/data/evolution/evolution_20260427_0330.md ?? tools/data/evolution/evolution_20260428_0330.md ?? tools/data/evolution/evolution_20260429_0852.md ?? tools/data/evolution/evolution_20260429_1013.md ?? tools/data/evolution/evolution_20260430_0330.md ?? tools/data/evolution/evolution_20260430_1905.md ?? tools/data/evolution/evolution_20260430_1946.md ?? tools/data/evolution/evolution_20260501_0330.md ?? tools/data/evolution/evolution_20260501_0725.md ?? tools/data/evolution/evolution_20260501_0931.md ?? tools/data/evolution/evolution_20260502_0330.md ?? tools/data/evolution/evolution_20260503_0330.md ?? tools/data/evolution/evolution_20260504_0901.md ?? tools/data/evolution/evolution_20260504_1219.md ?? tools/data/evolution/evolution_20260505_0330.md ?? tools/data/evolution/evolution_20260506_0330.md ?? tools/data/evolution/evolution_20260506_1941.md ?? tools/data/evolution/evolution_20260506_1955.md ?? tools/data/evolution/evolution_20260507_0330.md ?? tools/data/evolution/evolution_20260507_0803.md ?? tools/data/evolution/evolution_20260507_0901.md ?? tools/data/evolution/evolution_20260507_0923.md ?? tools/data/evolution/evolution_20260507_0942.md ?? tools/data/incrocio_20260422_0336.json ?? tools/data/incrocio_20260423_0335.json ?? tools/data/incrocio_20260424_0347.json ?? tools/data/incrocio_20260425_0339.json ?? tools/data/incrocio_20260428_0340.json ?? tools/data/incrocio_20260429_0859.json ?? tools/data/incrocio_20260506_0633.json ?? tools/data/lab_bridge_issues.jsonl ?? tools/data/logistic_counter_scope_gate_20260507_1006.json ?? tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json ?? tools/data/magnitude_psd_from_acf.json ?? tools/data/markov3_observable_hunt.json ?? tools/data/markov_dipolar_decomposition.json ?? tools/data/markov_k_direction.json ?? tools/data/markov_layer_recovery_audit.json ?? tools/data/markov_memory_by_gue_type.json ?? tools/data/markov_scale_function.json ?? tools/data/meta_tautology_test.json ?? tools/data/mod3_scaling.json ?? tools/data/mod3_vs_residual_ordering.json ?? tools/data/modular_algebra_depth.json ?? tools/data/modular_memory_spectrum.json ?? tools/data/observable_collinearity_breaking_20260506_1955.json ?? tools/data/observable_collinearity_breaking_20260506_1956.json ?? tools/data/observable_collinearity_breaking_20260506_1957.json ?? tools/data/observable_rank_audit.json ?? tools/data/observable_rank_audit_seed20260506.json ?? tools/data/observatorio/ ?? tools/data/perturbation_dimensionality_audit.json ?? tools/data/perturbation_dimensionality_audit_scale0330.json ?? tools/data/perturbation_rank_size_curve.json ?? tools/data/promotions/ ?? tools/data/reports/_quarantine_falsifier_29_04/ ?? tools/data/reports/agent_20260422_0330.md ?? tools/data/reports/agent_20260422_1616.md ?? tools/data/reports/agent_20260423_0330.md ?? tools/data/reports/agent_20260424_0330.md ?? tools/data/reports/agent_20260425_0330.md ?? tools/data/reports/agent_20260426_0330.md ?? tools/data/reports/agent_20260427_0330.md ?? tools/data/reports/agent_20260428_0330.md ?? tools/data/reports/agent_20260429_1013.md ?? tools/data/reports/agent_20260429_1041.md ?? tools/data/reports/agent_20260430_0330.md ?? tools/data/reports/agent_20260430_1905.md ?? tools/data/reports/agent_20260430_1919.md ?? tools/data/reports/agent_20260430_1946.md ?? tools/data/reports/agent_20260501_0330.md ?? tools/data/reports/agent_20260501_0725.md ?? tools/data/reports/agent_20260501_0931.md ?? tools/data/reports/agent_20260502_0330.md ?? tools/data/reports/agent_20260503_0330.md ?? tools/data/reports/agent_20260504_0901.md ?? tools/data/reports/agent_20260504_1219.md ?? tools/data/reports/agent_20260505_0330.md ?? tools/data/reports/agent_20260505_1022.md ?? tools/data/reports/agent_20260506_0330.md ?? tools/data/reports/agent_20260506_0625.md ?? tools/data/reports/agent_20260506_1941.md ?? tools/data/reports/agent_20260506_1955.md ?? tools/data/reports/agent_20260507_0330.md ?? tools/data/reports/agent_20260507_0803.md ?? tools/data/reports/agent_20260507_0901.md ?? tools/data/reports/agent_20260507_0923.md ?? tools/data/reports/agent_20260507_0942.md ?? tools/data/reports/ddf_20260422_0405.json ?? tools/data/reports/ddf_20260423_0405.json ?? tools/data/reports/ddf_20260424_0405.json ?? tools/data/reports/ddf_20260425_0405.json ?? tools/data/reports/ddf_20260426_0405.json ?? tools/data/reports/ddf_20260427_0405.json ?? tools/data/reports/ddf_20260428_0405.json ?? tools/data/reports/ddf_20260429_0405.json ?? tools/data/reports/ddf_20260430_0405.json ?? tools/data/reports/ddf_20260501_0405.json ?? tools/data/reports/ddf_20260502_0405.json ?? tools/data/reports/ddf_20260503_0405.json ?? tools/data/reports/ddf_20260504_0405.json ?? tools/data/reports/ddf_20260505_0405.json ?? tools/data/reports/ddf_20260505_0636.json ?? tools/data/reports/ddf_20260506_0405.json ?? tools/data/reports/ddf_20260507_0405.json ?? tools/data/reports/evolution_20260422_0330.md ?? tools/data/reports/evolution_20260422_1616.md ?? tools/data/reports/evolution_20260423_0330.md ?? tools/data/reports/evolution_20260424_0330.md ?? tools/data/reports/evolution_20260425_0330.md ?? tools/data/reports/evolution_20260427_0330.md ?? tools/data/reports/evolution_20260428_0330.md ?? tools/data/reports/evolution_20260503_0330.md ?? tools/data/reports/evolution_20260504_0330.md ?? tools/data/reports/evolution_20260505_0330.md ?? tools/data/reports/evolution_20260506_0330.md ?? tools/data/reports/evolution_20260506_1941.md ?? tools/data/reports/falsifier_20260429_1013.json ?? tools/data/reports/falsifier_20260429_1041.json ?? tools/data/reports/falsifier_20260430_0330.json ?? tools/data/reports/falsifier_20260430_1905.json ?? tools/data/reports/falsifier_20260430_1919.json ?? tools/data/reports/falsifier_20260430_1946.json ?? tools/data/reports/falsifier_20260501_0330.json ?? tools/data/reports/falsifier_20260501_0725.json ?? tools/data/reports/falsifier_20260501_0931.json ?? tools/data/reports/falsifier_20260502_0330.json ?? tools/data/reports/falsifier_20260503_0330.json ?? tools/data/reports/falsifier_20260504_0901.json ?? tools/data/reports/falsifier_20260504_1219.json ?? tools/data/reports/falsifier_20260505_0330.json ?? tools/data/reports/falsifier_20260506_0330.raw.txt ?? tools/data/reports/falsifier_20260506_0625.json ?? tools/data/reports/falsifier_20260506_1941.json ?? tools/data/reports/falsifier_20260506_1955.json ?? tools/data/reports/falsifier_20260506_1955.raw.txt ?? tools/data/reports/falsifier_20260507_0330.json ?? tools/data/reports/falsifier_20260507_0330.raw.txt ?? tools/data/reports/falsifier_20260507_0803.json ?? tools/data/reports/falsifier_20260507_0803.raw.txt ?? tools/data/reports/falsifier_20260507_0901.json ?? tools/data/reports/falsifier_20260507_0923.json ?? tools/data/reports/falsifier_20260507_0923.raw.txt ?? tools/data/reports/falsifier_20260507_0942.json ?? tools/data/reports/incident_20260504_0721.md ?? tools/data/reports/incident_20260504_1138.md ?? tools/data/reports/latest.md ?? tools/data/reports/loop_guard_20260507_0330.json ?? tools/data/reports/loop_guard_20260507_0803.json ?? tools/data/reports/loop_guard_20260507_0901.json ?? tools/data/reports/loop_guard_20260507_0923.json ?? tools/data/reports/loop_guard_20260507_0942.json ?? tools/data/reports/trajectory_apply_20260506_1931.json ?? tools/data/reports/trajectory_apply_20260506_1941.json ?? tools/data/reports/trajectory_apply_20260506_1955.json ?? tools/data/reports/trajectory_apply_20260507_0330.json ?? tools/data/reports/trajectory_apply_20260507_0803.json ?? tools/data/reports/trajectory_apply_20260507_0901.json ?? tools/data/reports/trajectory_apply_20260507_0923.json ?? tools/data/reports/trajectory_apply_20260507_0942.json ?? tools/data/reports/trajectory_apply_20260507_1006.json ?? tools/data/scale_selective_perturbation.json ?? tools/data/selective_layer_decoupling.json ?? tools/data/seme_archive/piano_68.json ?? tools/data/seme_archive/piano_69.json ?? tools/data/seme_archive/piano_70.json ?? tools/data/seme_archive/piano_71.json ?? tools/data/seme_archive/piano_72.json ?? tools/data/semireal_order_denominator_gate_20260507_0923.json ?? tools/data/semireal_order_denominator_gate_20260507_0923_seedcheck.json ?? tools/data/spectral_rigidity_results.json ?? tools/data/trajectory_apply_history.jsonl ?? tools/data/two_channel_boundary.json ?? tools/data/two_channel_cross_domain.json ?? tools/data/two_channel_shuffle_audit.json ?? tools/data/two_layer_universality.json ?? tools/data/valutatore_log.jsonl ?? tools/data/veritas/ ?? tools/evolution_report.md ?? tools/exp_3d_boundary_layers.py ?? tools/exp_boundary_coherence.py ?? tools/exp_boundary_mixture_gate.py ?? tools/exp_boundary_shuffle_audit.py ?? tools/exp_bridge_order_denominator_gate.py ?? tools/exp_brody_calibration.py ?? tools/exp_brody_flow.py ?? tools/exp_cross_domain_dipolar_direction.py ?? tools/exp_cross_observable_consistency.py ?? tools/exp_crossover_phase_test.py ?? tools/exp_denominator_gate_transfer_matrix.py ?? tools/exp_dipolar_angle_reference.py ?? tools/exp_dipolar_crossover.py ?? tools/exp_dipolar_vector_scaling.py ?? tools/exp_duality_gate_transfer.py ?? tools/exp_logistic_counter_scope_gate.py ?? tools/exp_magnitude_psd_from_acf.py ?? tools/exp_markov3_observable_hunt.py ?? tools/exp_markov_dipolar_decomposition.py ?? tools/exp_markov_k_direction.py ?? tools/exp_markov_layer_recovery_audit.py ?? tools/exp_markov_memory_by_gue_type.py ?? tools/exp_markov_psd_prediction.py ?? tools/exp_markov_scale_function.py ?? tools/exp_meta_tautology_test.py ?? tools/exp_mod3_scaling.py ?? tools/exp_mod3_vs_residual_ordering.py ?? tools/exp_modular_algebra_depth.py ?? tools/exp_modular_memory_spectrum.py ?? tools/exp_observable_rank_audit.py ?? tools/exp_perturbation_dimensionality_audit.py ?? tools/exp_perturbation_rank_size_curve.py ?? tools/exp_scale_selective_perturbation.py ?? tools/exp_selective_layer_decoupling.py ?? tools/exp_semireal_order_denominator_gate.py ?? tools/exp_spectral_rigidity.py ?? tools/exp_two_channel_boundary.py ?? tools/exp_two_channel_cross_domain.py ?? tools/exp_two_channel_shuffle_audit.py ?? tools/exp_two_layer_universality.py ?? tools/observables_registry.py exec /bin/bash -lc 'tail -20 tools/data/valutatore_log.jsonl 2>/dev/null || true' in /opt/MM_D-ND succeeded in 0ms: {"ts": "2026-04-30T19:57:05.174515+00:00", "cycle_ref": "20260430_1919", "executed": false, "decision": "CRYSTALLIZE", "confidence": "high", "reasoning": "Il ciclo ha prodotto una riduzione dimensionale genuina e falsificabile: 5 osservabili → 3 tautologici + 2 order-sensitive → 1 modo effettivo (angolo bloccato a -150±4° su 3 decadi). Combinato col ciclo precedente (decomposizione 5→2), il risultato complessivo è 5→1: l'intera struttura di ordinamento dei gap primi è proiezione di un singolo modo di anticorrelazione. Il rapporto delta_L1/delta_SR ≈ 2.3 è una costante strutturale nuova. Cramer nel quadrante opposto (+65°) fornisce discriminatore pulito. Tre cicli consecutivi (mod-3 theorem → decomposizione 5-obs → locking 1D) chiudono un arco coerente che merita cristallizzazione prima di cambiare direzione.", "action": {"type": "crystallize_note", "detail": {"target": "condensato", "content": "CANDIDATE F7: Prime gap ordering is 1-dimensional. Five observables under M decompose into 3 shuffle-invariant (tautological) and 2 order-sensitive (spacing_ratio, lag1_acf). The two order-sensitive observables are projections of a single anticorrelation mode: dipolar angle theta = -150 ± 4 deg, locked across 3 decades of scale (1e4 to 3e6 primes) and across offsets (0 to 2M). Structural constant: delta_L1/delta_SR ≈ 2.3. Cramer random model occupies opposite quadrant (theta ≈ +65 deg). Signal magnitude decays with 1/ln(p), consistent with Lemke Oliver-Soundararajan. Falsifiable: any domain showing theta rotation with scale would have >1 degree of freedom."}}, "notes": "Tre cicli chiudono l'arco prime-ordering: mod-3 proibizione → decomposizione 5→2 → locking 1D. Il prossimo ciclo dovrebbe uscire dai primi e testare cross-dominio: l'angolo theta è costante anche in altri domini GUE-like (zeri di Riemann, autovalori random, logistica caotica)? La direzione del seme ('esplorare il confine: 8 GUE, 5 Poisson') lo chiede già. Se theta ruota in altri domini → il locking è proprietà dei primi, non della regola. Se theta è universale → struttura più profonda. Propongo NEXT_CYCLE con target cross-domain angle comparison dopo questa cristallizzazione."} {"ts": "2026-05-01T03:38:54.770300+00:00", "cycle_ref": "20260430_1946", "executed": false, "decision": "CRYSTALLIZE", "confidence": "high", "reasoning": "Il ciclo ha prodotto un discriminante strutturale genuino e falsificabile: l'angolo dipolare dei primi (-111° ± 1°, stabile su 3 decadi) differisce da GUE (-96.6°) di 14° a >100σ. Il rapporto dL1/dSR = 2.28 (primi) vs 8.37 (GUE) è il contenuto: i primi non sono 'GUE debole' — hanno una composizione interna diversa dell'ordinamento. La correzione -150° → -111° è sana (C2 applicato a se stesso). Terzo CRYSTALLIZE consecutivo: la direzione dipolar-ordering ha maturato abbastanza da entrare nel condensato come fatto strutturale.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Tre cicli consecutivi hanno estratto il succo dalla direzione dipolar-ordering (separazione osservabili, angolo stabile, discriminante GUE). Rendimenti decrescenti su questa linea. Prossimo ciclo: cambiare asse — esplorare cross-dominio (F5 frame diagnostica su domini NON-primi: logistica caotica, Stern-Brocot, margine del caos) per testare se il rapporto dL1/dSR=2.28 è unico dei primi o emerge anche in altri domini strutturati. Questo è il test (b) cross-dominio che discrimina C1.", "reason": "Tre CRYSTALLIZE consecutivi sulla stessa linea segnalano maturazione completata. Il prossimo passo naturale è cross-dominio: il rapporto 2.28 è firma dei primi o di qualsiasi sequenza strutturata sotto M? Testare su logistica caotica e Stern-Brocot falsifica/rafforza C1."}}, "notes": "Cristallizzazione proposta per condensato: 'F7 Angolo dipolare — L'ordinamento dei primi ha direzione θ=-111°±1° nel piano (δSR, δL1), stabile su 3 decadi. GUE/GOE: θ=-97°. Separazione 14° a >100σ. Rapporto dL1/dSR=2.28 (primi) vs 8.37 (GUE): i primi deprimono la similarità dei gap 3.7× più della anticorrelazione rispetto a GUE. Non sono GUE attenuato — sono struttura diversa.' Dopo questa cristallizzazione, il prossimo ciclo DEVE cambiare asse verso cross-dominio per evitare rendimenti decrescenti."} {"ts": "2026-05-01T07:43:00.145219+00:00", "cycle_ref": "20260501_0330", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "The Markov-1 decomposition is a clean, non-tautological result: pair statistics explain the bulk of the dipolar angle but leave a stable ~3 deg residual across scales. However, three consecutive CRYSTALLIZE decisions with an empty seme delta means findings are accumulating without integration. The natural consecutio is Markov-2: if triplet correlations close the 3-deg gap, the memory structure is fully characterized; if not, deeper structure exists. This is a direct falsification test of tonight's claim, not a new direction — so NEXT_CYCLE, not REDESIGN.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Markov-2 test: do triplet correlations close the 3-deg angle gap between real primes and Markov-1 surrogates? If yes → pair+triplet memory fully characterizes dipolar ordering. If no → higher-order structure beyond triplets. Secondary: consolidate Markov decomposition result (pair explains 80%, residual stable across scales) into condensato candidate.", "reason": "Three cycles produced crystallizable results but seme delta stayed empty. The Markov-2 test is the minimal falsification of tonight's finding and prevents further accumulation without integration."}}, "notes": "The dL1/dSR value shifting from 2.28 to 2.48 across scale windows is worth noting — it means the ratio is not a constant but a slowly varying function. This should be flagged in the condensato candidate rather than reported as a fixed number. Also: the 8 hard zeros in the transition matrix from F2 are a clean algebraic result that could stand on its own as a micro-crystallization."} {"ts": "2026-05-01T09:41:03.248817+00:00", "cycle_ref": "20260501_0858", "executed": false, "decision": "REDESIGN", "confidence": "high", "reasoning": "Il ciclo non ha prodotto nulla — timeout perché il campo vivo mancava dell'input pre-computato per l'esperimento scelto dall'agente. Ripetere NEXT_CYCLE senza correggere il campo vivo produrrebbe lo stesso timeout. Il nodo regressivo è dichiarato esplicitamente nel health: il fix vive nel build_agent_field, non nel budget del run. Servono i dati GUE/Poisson boundary pre-computati nel campo vivo prima del prossimo ciclo.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Pre-computare nel campo vivo i dati boundary (8 domini GUE, 5 Poisson, spacing distributions) come input ready-to-use. Solo dopo: esplorare il confine GUE/Poisson come terzo incluso operativo. Il campo vivo deve contenere il substrato, non delegarlo all'agente runtime.", "reason": "Due cicli consecutivi sulla stessa direzione boundary senza output scientifico. Il collo di bottiglia non è la direzione ma la mancanza di dati pre-computati nel campo vivo. Senza fix al nodo regressivo (build_agent_field), qualsiasi direzione boundary produrrà lo stesso timeout."}}, "notes": "Pattern ricorrente: l'agente sceglie esperimenti che richiedono generazione dati pesante, il campo vivo non li contiene, timeout. La soluzione è arricchire build_agent_field.py con una sezione che pre-computa e cachea i dataset sperimentali più probabili data la direzione del seme. Questo è un fix infrastrutturale, non scientifico."} {"ts": "2026-05-02T03:37:32.497564+00:00", "cycle_ref": "20260501_0931", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Il ciclo ha prodotto evidenza strutturale forte e non-tautologica: transizione di fase nel crossover GUE-Poisson con zero-crossing a alpha~0.70, direzione invariante nel regime ordinato (-96.6±0.27°), e primi con offset direzionale di 32 sigma. Sono pattern cross-dominio (categoria b/f), non dettaglio numerico locale. Il seme delta vuoto indica che i finding non sono ancora rientrati nel seme — il prossimo ciclo deve sia estendere (confronto Brody/Rosenzweig-Porter come suggerito dall'affinatore) sia propagare. Non cristallizzo ancora perché il confronto con i punti critici Brody è il test naturale che conferma o ridimensiona la portata della transizione.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Confrontare lo zero-crossing dipolare (alpha~0.70) con i punti critici Brody/Rosenzweig-Porter: la transizione di fase nel crossover ha carattere universale o è artefatto della parametrizzazione? Testare se beta_Brody critico corrisponde all'alpha di zero-crossing. Secondario: propagare nel seme i finding stabili (direzione invariante, offset primi 32-sigma).", "reason": "L'affinatore ha identificato questo come la possibilità più concreta. Estende il risultato corrente verso falsificazione cross-framework invece di accumulare dettaglio locale."}}, "notes": "Il ciclo precedente (piano 60) è tra i migliori recenti: esperimento ben disegnato, shuffle audit implicito nella parametrizzazione alpha, risultato quantitativo con interpretazione strutturale chiara. Il confronto Brody è il filtro giusto: se il punto critico coincide, la transizione è universale (cristallizzabile); se no, la parametrizzazione alpha è contingente e il finding si ridimensiona a osservazione locale."} {"ts": "2026-05-03T03:41:17.534324+00:00", "cycle_ref": "20260502_0330", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Il ciclo ha prodotto un risultato forte e non-tautologico: auto-declassamento della transizione di fase a constraint metodologico + estrazione della direzione come discriminante reale. La coincidenza Prime-Periodic a 0.2° (carattere identico, magnitudine 10x diversa) converge con F2 e Markov-1 sullo stesso nodo strutturale — il confinamento Z/6Z. Manca il passo sintetico: decomporre il segnale prime in componente confinamento (Z/6Z, shared con Periodic) + componente residua (il 7° di separazione dalla classe repulsione). Questo è il prossimo esperimento naturale, non serve redesign.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Decomposizione sintetica: costruire sequenza ibrida (confinamento Z/6Z puro + rumore calibrato) e verificare se la componente residua prime-vs-periodic (i 0.2° di coincidenza vs i 7° dalla classe repulsione) porta informazione oltre il crivello. Il discriminante è: la direzione prime è ESATTAMENTE Z/6Z, o c'è un residuo misurabile che codifica struttura ulteriore?", "reason": "Tre risultati indipendenti (F2, Markov-1, direzione dipolare) convergono sullo stesso nodo. Il passo che manca è la decomposizione per separare confinamento da residuo. Se il residuo è zero → prime direction = puro Z/6Z (chiude F2). Se non-zero → c'è struttura oltre il crivello (apre)."}}, "notes": "La convergenza di tre linee indipendenti sullo stesso nodo (Z/6Z) è il segnale più forte emerso dal lab in settimane. Non è ancora cristallizzabile perché manca la decomposizione, ma se il prossimo ciclo la completa con esito pulito, il ciclo dopo sarà CRYSTALLIZE. Attenzione: la sequenza ibrida deve essere costruita con cura — il periodic 2,4 è deterministico, i primi hanno varianza. La calibrazione del rumore nella sequenza sintetica è il punto tecnico critico."} {"ts": "2026-05-03T07:48:23.455983+00:00", "cycle_ref": "20260503_0330", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Ciclo pulito, consecutio seguita, risultato strutturale non-tautologico: la memoria dei primi si decompone in esattamente due strati indipendenti (pair→SR/L1, triple→SR2/L2/cond_entropy), e Markov-3 è invisibile in tutti e 10 gli osservabili scalari testati. Il metodo (surrogati Markov-k stratificati) è robusto contro tautologie. La consecutio naturale — proiettare (SR, L1, SR2) per verificare se il bicono emerge dalla decomposizione a due strati — è ben definita e falsificabile.", "action": {"type": "none", "detail": {}}, "notes": "Tre cicli consecutivi solidi (crossover → auto-declassamento → due strati). La direzione è viva. La prossima mossa (proiezione 3D) potrebbe connettere il lab numerico alla geometria del bicono — se il risultato è positivo, potrebbe meritare CRYSTALLIZE al giro dopo. Se la proiezione non mostra struttura riconoscibile, il ramo Markov-memory è esaurito e servirà REDESIGN verso altro dominio."} {"ts": "2026-05-04T09:09:09.478519+00:00", "cycle_ref": "20260504_0901", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Four cycles of convergent refinement on the boundary picture: phase transition → near-second-order → two visible layers → single coupled transition. Each cycle has produced a genuine constraint (not tautology), and the affinatore identified zero-crossing interleaving as the highest-leverage next step — it's concrete, testable, and could discriminate prime-specific geometry from generic repulsion. The direction is not exhausted yet.", "action": {"type": "none", "detail": {}}, "notes": "The zero-crossing order (L1 < triple_var < SR2 < SR, interleaved across layers) is the most promising lead: it's an observable ordering that should differ between primes and GUE if the coupling has sequence-specific structure. After one more cycle on this, consider CRYSTALLIZE for the full crossover/boundary picture — the convergence from 4 consecutive clean cycles is approaching maturity for a condensato entry or paper section."} {"ts": "2026-05-04T12:03:13.893909+00:00", "cycle_ref": "20260504_1138", "executed": false, "decision": "NEXT_CYCLE", "confidence": "medium", "reasoning": "DIPOLAR_ORDERING resolved and piano advanced 60→61, indicating forward motion. The missing agent report (run completed but no scientific conclusion) is a yellow flag but not yet a pattern — one empty output after 3 productive cycles on boundary refinement is normal variance. 8 tensions remain in the current direction, so the frame is not exhausted. However, this is the 5th consecutive NEXT_CYCLE on boundary-adjacent themes; if the next run also produces no scientific output, REDESIGN toward cross-domain verification (b/f category) should be triggered.", "action": {"type": "none", "detail": {}}, "notes": "Monitor: if piano 61 also yields no agent report or resolves zero tensions, escalate to REDESIGN toward a fresh cross-domain experiment (e.g., testing the 8-GUE/5-Poisson boundary classification against a shuffled null baseline across all 13 domains simultaneously, which would be category (b) evidence). The boundary picture has accumulated enough local detail — the next high-value move is cross-domain falsification of the boundary itself."} {"ts": "2026-05-04T12:30:22.947364+00:00", "cycle_ref": "20260504_1219", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Il ciclo 61 ha prodotto un audit metodologico genuino (categoria a/b): ha ristretto il perimetro dei claim two-layer a {SR,L1,L2,SR2} e ha identificato cond_entropy e num_var_10 come non-affidabili. Questo è lavoro strutturale, non accumulo numerico. La direzione seme (confine GUE/Poisson) e le indicazioni dell'affinatore (coupling test, surrogati esatti, gate multi-seed) convergono su un passo naturale: testare se i due layer verificati sono accoppiati o indipendenti — questo è il claim più forte rimasto non-auditato e tocca il confine che il seme chiede di esplorare.", "action": {"type": "none", "detail": {}}, "notes": "Quattro NEXT_CYCLE consecutivi, ma la traiettoria non è stagnante — ogni ciclo ha ristretto il perimetro (phase transition → near-second-order → two visible layers → recovery audit). Il prossimo passo ad alto rendimento è il coupling test tra Layer 1 e Layer 2: se sono indipendenti il two-layer si riduce a due claim separati; se sono accoppiati, emerge struttura genuina beyond-Markov. Evitare di investire subito in surrogati Markov esatti (infrastruttura pesante) — prima verificare se il coupling test col setup attuale produce segnale o null."} {"ts": "2026-05-05T03:34:54.115859+00:00", "cycle_ref": "20260505_0330", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Piano 62 ha prodotto un vincolo metodologico genuino (categoria a): le 5 osservabili sono collineari sotto partial-shuffle uniforme, quindi non contano come evidenze indipendenti. Il seme è già avanzato a 63 con direzione coerente (perturbazioni selettive ortogonali). La traiettoria degli ultimi 4 cicli mostra compressione progressiva sana: da accumulazione a restrizione del perimetro. Nessuna dipendenza dall'operatore.", "action": {"type": "none", "detail": {}}, "notes": "La consecutio naturale è cercare perturbazioni che rompano la collinearità — block-shuffle per layer, swap locale vs globale, perturbazioni che agiscano su scale diverse. Se il prossimo ciclo trova che i due Markov layer rispondono diversamente a perturbazioni selettive, quello sarebbe evidenza di rango >1 genuino."} {"ts": "2026-05-06T03:38:24.835757+00:00", "cycle_ref": "20260506_0330", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Piano 65 ha prodotto un risultato categoria (a): ha falsificato il proprio risultato precedente (rank audit 05-05) mostrando che il singolo coordinate era artefatto del tipo di perturbazione. Il finding — dimensionalità perturbativa come discriminatore di dominio (GUE=1.89 vs primes=1.26) — è genuino ma necessita replicazione con GUE più grande (N=253 è il caveat dichiarato). La direzione 'confine' è ancora fertile: il prossimo passo naturale è confermare la dimensionalità perturbativa come invariante cross-dominio.", "action": {"type": "none", "detail": {}}, "notes": "Suggerimento per il prossimo ciclo: replicare con GUE N>=1000 (matrici 45x45+) e aggiungere almeno 2 domini intermedi (logistica caotica, Stern-Brocot) per verificare se la dimensionalità perturbativa scala in modo ordinato tra domini. Se confermato, è candidato a F7 nel condensato."} {"ts": "2026-05-06T06:33:26.706335+00:00", "cycle_ref": "20260506_0625", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Piano 65 ha prodotto falsificazione genuina (categoria a): il secondo asse GUE è artefatto di sample size, non invariante stabile. Il ciclo ha anche scoperto una collisione di nomi osservabili (SR/SR2/triple_var significano funzioni diverse in script diversi) — problema META reale che va risolto. La direzione 'esplorare il confine' ha ancora potenziale: il prossimo passo naturale è la curva rank-vs-N che chiude il loop, e la collisione nomi va sanata prima di ulteriori audit cross-script.", "action": {"type": "none", "detail": {}}, "notes": "Tre cicli consecutivi NEXT_CYCLE sono giustificati perché ciascuno ha prodotto falsificazione o vincolo strutturale (non accumulo numerico locale). Se il prossimo ciclo produce solo conferma incrementale senza nuova discriminazione, valutare REDESIGN verso pair cross-dominio (f) o connessione con i ponti evoluti del sito. La collisione nomi osservabili è un debito META che il prossimo agente dovrebbe risolvere con un dizionario canonico delle osservabili prima di lanciare nuovi esperimenti."} {"ts": "2026-05-06T19:47:12.588345+00:00", "cycle_ref": "20260506_1941", "executed": true, "decision": "REDESIGN", "confidence": "high", "reasoning": "Three consecutive cycles on perturbation dimensionality (pianos 64-66) have converged to a single clear constraint: rank needs denominator gating, and after gating both GUE and primes show ~1 perturbation coordinate. The thread has produced genuine falsification (category a) and a solid methodological gate, but continuing to refine size curves or observable stability on the same axis is now category (c) — local numerical accumulation with diminishing returns. The 10 open tensions in the seme offer fresher directions; the perturbation constraint is ready to crystallize and the lab should pivot to cross-domain verification or a tension not yet explored.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Il vincolo PERTURBATION_DENOMINATOR_GATE è stabilito e replicato — cristallizzare come regola metodologica e muovere verso tensione cross-dominio non ancora esplorata (candidati: dipolar crossover scaling, markov layer coupling verification, o observable collinearity breaking). La prossima corsa NON deve restare su perturbation rank.", "reason": "3 cicli sullo stesso asse hanno prodotto il risultato (denominatore gate). Restare è rendimenti decrescenti (rischio tautologia accumulata). Ridirigere verso (b) cross-domain o (f) connessione inter-dominio."}}, "notes": "Il finding di piano 66 è maturo per crystallize_note nel condensato come vincolo metodologico (accanto a C2), ma la priorità ora è rompere l'inerzia tematica. Suggerisco anche che l'infrastruttura trajectory_apply/autopsy venga allineata (segnalato dall'affinatore) — ma questo è un fix di sistema, non una direzione scientifica.", "_executed_at": "2026-05-06T19:55:48.007990+00:00", "_executed_by": "lab_trajectory_apply"} {"ts": "2026-05-06T20:03:03.497231+00:00", "cycle_ref": "20260506_1955", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Piano 67 executed a clean category (b) result: cross-domain verification with proper controls, falsifying the broad collinearity claim from 05-05 and narrowing it to a scoped statement with denominator gating. The redesign away from perturbation dimensionality worked — the cycle moved to a genuinely different experimental frame (PCA of retention curves) and confirmed the denominator lesson without repeating the perturbation-rank experiment. The consecutio (selective operator coupling) is non-redundant and well-motivated: it would discriminate whether primes and GUE are collinear because the observable suite is overcomplete or because they share genuine structural response.", "action": {"type": "none", "detail": {}}, "notes": "The seme direction for piano 68 ('8 GUE domains, 5 Poisson — boundary as third included') is reasonable but less sharp than the consecutio's proposal (selective operators on pair-scale vs triple-scale). If the agent picks up the consecutio naturally, good. If it drifts into another broad PCA audit without selective perturbation, the next valutatore pass should nudge toward operator coupling. Three cycles of clean progress since the redesign — no intervention needed yet."} {"ts": "2026-05-07T03:35:44.545141+00:00", "cycle_ref": "20260507_0330", "executed": false, "decision": "NEXT_CYCLE", "confidence": "medium", "reasoning": "Il ciclo ha prodotto un risultato controllato e replicato su seed check: il confine GUE-Poisson non appare come linea binaria ma come layer beta 0.3-0.4 con collasso del denominatore. Non e' ancora da cristallizzare perche' resta dentro un perimetro sintetico di mixture controllata; il prossimo passo deve verificare se BOUNDARY_LAYER_GATE sopravvive cambiando generatore del confine, non accumulare altra metrica locale sullo stesso setup.", "action": {"type": "trigger_cycle", "detail": {"next_tension": "BOUNDARY_LAYER_GATE", "instruction": "Ripetere il test del collasso del denominatore su almeno un generatore indipendente del confine GUE-Poisson: ad esempio Dyson beta ensemble interpolante, thinning/superposition controllata, o spettro perturbato con unfolding separato. Mantenere registry canonico e gate original-vs-shuffle; criterio di successo: stesso ordine qualitativo collasso-denominatore prima/dentro la zona ambigua, non stesso beta numerico."}}, "notes": "Continuare, ma il prossimo ciclo deve essere cross-generatore. Se il layer compare solo nella mixture per sostituzione Poisson, va verso cimitero come artefatto del protocollo di miscela; se sopravvive, diventa candidato forte per condensato META sul terzo incluso operativo."} {"ts": "2026-05-07T08:10:22.658201+00:00", "cycle_ref": "20260507_0803", "executed": true, "decision": "REDESIGN", "confidence": "high", "reasoning": "Il ciclo ha prodotto evidenza controllata e replicata che il denominator gate trasferisce come operatore, ma non trasferisce la coordinata di layer BOUNDARY: ambiguita' classificativa e collasso del denominatore si separano. Continuare sul seme attuale centrato su GUE/Poisson rischia di restare nel locale; la prossima mossa deve promuovere il gate a oggetto cross-dominio e testarne i limiti di trasferibilita'.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Costruire una matrice di trasferibilita' del denominator gate: applicarlo a 3-4 perimetri non-BOUNDARY con poli coerente/illusorio e verificare quali parti trasferiscono (supporto one-sided, coordinate di collasso, ambiguita' classificativa) e quali restano locali.", "reason": "Il risultato appena ottenuto falsifica la trasferibilita' della coordinata BOUNDARY ma salva l'operatore; serve ora discriminare operatore stabile da metrica locale attraverso domini diversi."}}, "notes": "Side-effect log-only: modifica seme proposta, non eseguita automaticamente.", "_executed_at": "2026-05-07T09:01:45.431215+00:00", "_executed_by": "lab_trajectory_apply"} {"ts": "2026-05-07T09:07:53.577876+00:00", "cycle_ref": "20260507_0901", "executed": true, "decision": "REDESIGN", "confidence": "high", "reasoning": "La direzione corrente ha eseguito il mandato: la matrice di trasferibilita' su 4 perimetri non-BOUNDARY e' stata prodotta e ha nominato una nuova categoria, order_denominator_gate. Un altro giro nello stesso frame rischia accumulo numerico locale su sintetici; la prossima mossa deve falsificare il nuovo operatore fuori dal setup che lo ha generato, separando supporto one-sided reale da artefatto original-vs-shuffle.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Falsificare ORDER_DENOMINATOR_GATE su domini non-sintetici o semi-reali: applicare il gate one-sided a 2-3 sequenze fisiche/ponte gia' presenti nel sito, con shuffle e surrogati preservanti marginale, cercando un controesempio dove il supporto denominatore appare anche sul lato illusorio o scompare sul lato coerente.", "reason": "La categoria nuova e' utile solo se sopravvive fuori dalla matrice sintetica che l'ha fatta emergere; il prossimo ciclo deve testare trasferibilita' strutturale, non raffinare beta o metriche locali."}}, "notes": "Side-effect log-only: proposta modifica seme. Non serve STOP_FOR_REVIEW: l'operatore puo' vedere la nuova parola, ma la dipendenza successiva e' sperimentale, non decisionale.", "_executed_at": "2026-05-07T09:23:32.912653+00:00", "_executed_by": "lab_trajectory_apply"} {"ts": "2026-05-07T09:32:25.653603+00:00", "cycle_ref": "20260507_0923", "executed": false, "decision": "NEXT_CYCLE", "confidence": "high", "reasoning": "Il ciclo ha prodotto evidenza strutturale utile: il gate trasferisce su perimetri aritmetico/spettrali e resta blank su logistic return intervals, senza falso positivo. La consecutio e' chiara e non richiede operatore: mantenere invariato ORDER_DENOMINATOR_GATE e cambiare il contratto osservabile sul contro-scope logistic verso osservabili native di ricorrenza/simboliche.", "action": {"type": "trigger_cycle", "detail": {"focus": "Falsificare il logistic counter-scope con observable suite nativa mantenendo invariato il denominator gate original-vs-shuffle.", "suggested_observables": ["symbolic itinerary block entropy", "return-tail exponent", "recurrence-plot diagonal statistics"], "constraint": "Non tunare z_min o soglie del gate; il nodo regressivo e' il contratto osservabile."}}, "notes": "Il risultato non va ancora cristallizzato: e' scoped_operator stabile su due domini, ma la natura del blank logistic deve essere distinta tra assenza del gate e invisibilita' della suite canonica."} {"ts": "2026-05-07T09:47:43.105142+00:00", "cycle_ref": "20260507_0942", "executed": true, "decision": "REDESIGN", "confidence": "high", "reasoning": "La direzione corrente ha completato il mandato sui perimetri fisici/ponte gia' presenti: il gate trasferisce come supporto canonico one-sided su metric, trace e QxE, mentre il supporto both-endpoint resta vuoto. La consecutio utile non e' un altro bridge run, ma il nodo regressivo gia' emerso: la blank logistic non va salvata con gli stessi osservabili, va ritestata con osservabili native di ricorrenza sotto lo stesso gate e shuffle marginal-preserving.", "action": {"type": "modify_seme", "detail": {"field": "direzione", "new_value": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", "reason": "Il bridge falsification ha maturato il trasferimento one-sided; la tensione viva ora e' capire se la blank logistic falsifica il gate o solo il contratto canonico degli osservabili gap-like."}}, "notes": "Side-effect log-only: proposta modifica seme per spostare il prossimo ciclo dal bridge extension al counter-scope logistic provider-agnostico.", "_executed_at": "2026-05-07T10:06:02.816176+00:00", "_executed_by": "lab_trajectory_apply"} exec /bin/bash -lc 'python -m py_compile tools/exp_logistic_counter_scope_gate.py' in /opt/MM_D-ND succeeded in 0ms: diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex La verifica sintattica passa. Ora scrivo il report richiesto in `tools/data/reports/agent_20260507_1006.md`, con il punto delicato esplicito: il supporto sui ritorni non replica nel seed check, quindi non diventa claim stabile. apply patch patch: completed /opt/MM_D-ND/tools/data/reports/agent_20260507_1006.md diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex Report scritto. Ora aggiorno il seme nel punto già esistente `ORDER_DENOMINATOR_GATE`, aggiungendo la distinzione logistic stabile emersa dal run, e imposto la direzione successiva sul surrogate-class split. exec /bin/bash -lc "sed -n '20,75p' tools/data/seme.json" in /opt/MM_D-ND succeeded in 0ms: "intensita": 0.95, "porta": "META_BOUNDARY", "manuale": true, "condensato_ref": "A4,A8,A14,C2", "origine": "cycle agent_20260506_1941: perturbation rank size curve canonical observables", "added_at": "2026-05-06T19:41:00+00:00" }, { "id": "BOUNDARY_LAYER_GATE", "tipo": "vincolo", "claim": "I claim GUE/Poisson boundary devono riportare layer map: versione observables_registry, lista osservabili canonici, z original-vs-shuffle per osservabile, set endpoint-stable, e finestra/layer con margine classificatorio ambiguo. Nel perimetro sintetico agent_20260507_0330, il confine GUE-Poisson e beta 0.3-0.4: margine 0.070-0.083, ambiguous fraction 0.812-0.875, mentre gli osservabili stabili collassano da ~3.3 a 1.6. Il polo Poisson e classificabile ma denominator-weak.", "intensita": 0.93, "porta": "META_BOUNDARY", "manuale": true, "condensato_ref": "A4,A8,A9,A14,C2", "origine": "cycle agent_20260507_0330: synthetic GUE-Poisson mixture layer gate", "added_at": "2026-05-07T03:30:00+00:00" }, { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", "added_at": "2026-05-07T09:01:00+00:00" }, { "tipo": "confine_inesplorato", "id": "TRASCENDENZA_LIMITE", "claim": "La trascendenza e il limite attuale del modello. I punti fissi relazionali (non solo phi ma la rete di punti fissi tra osservabili) possono rivelare il vero grafo della realta e pattern nelle matrici. Il confine non e nella matematica - e nel passaggio tra piani.", "intensita": 0.9, "nota": "Input operatore 2026-04-10. Tocca: confine del modello, struttura relazionale dei punti fissi. Consecutio: quali punti fissi relazionali emergono dalle 21 tensioni attuali? Il grafo e gia nei dati?", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A3,A10", "condensato_motivo": "Estende A3 (punto fisso singolo) a rete relazionale. Tocca A10 (dipolo) come caso speciale." }, { "tipo": "scoperta", "id": "DUALITA_DIPOLARE_VS_ILLUSORIA", "claim": "Due tipi di dualita: (1) dipolare - generativa, il modello (det=-1), (2) illusoria - dispersiva, entropia (det=+1). Le regole incoerenti producono la seconda. La dualita illusoria e entropia come dispersione, non come informazione.", "intensita": 0.9, "nota": "Input operatore 2026-04-10. Tocca: entropia come dispersione illusoria vs generazione dipolare. Consecutio: nel Lab i domini Poisson (entropia massima) mostrano dualita illusoria? I domini GUE (strutturati) mostrano dualita dipolare? Il drift verso Poisson (POISSON_CONVERGENCE) e perdita di dualita dipolare?", "manuale": true, "porta": "sessione_interattiva", "condensato_ref": "A2,A10,F5", "condensato_motivo": "Discrimina due forme di det. A2 (confine) e la soglia. A10 (dipolo) e il tipo 1. F5 (frame) misura la struttura D-ND che e tipo 1." }, { "tipo": "scoperta_numerica", "id": "METRIC_TENSOR", "claim": "Il tensore metrico dei primi è g=(p/2)². Nel tempo ln(p), è de Sitter 1+1D. z=-8.8 curvatura vs z=+22.5 rapporti ΔΓ.", "intensità": 0.9, exec /bin/bash -lc "rg -n 'ORDER_DENOMINATOR_GATE|Ritestare ORDER|direzione' tools/data/seme.json" in /opt/MM_D-ND succeeded in 0ms: 40: "id": "ORDER_DENOMINATOR_GATE", 140: "claim": "Applied valutatore REDESIGN from 20260507_0901: Falsificare ORDER_DENOMINATOR_GATE su domini non-sintetici o semi-reali: applicare il gate one-sided a 2-3 sequenze fisiche/ponte gia' presenti nel sito, con shuffle e surrogati preservanti marginale,", 147: "_source_reasoning": "La direzione corrente ha eseguito il mandato: la matrice di trasferibilita' su 4 perimetri non-BOUNDARY e' stata prodotta e ha nominato una nuova categoria, order_denominator_gate. Un altro giro nello stesso frame rischia accumulo numerico locale su sintetici; la prossima mossa deve falsificare il n" 162: "claim": "Applied valutatore REDESIGN from 20260507_0942: Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics s", 169: "_source_reasoning": "La direzione corrente ha completato il mandato sui perimetri fisici/ponte gia' presenti: il gate trasferisce come supporto canonico one-sided su metric, trace e QxE, mentre il supporto both-endpoint resta vuoto. La consecutio utile non e' un altro bridge run, ma il nodo regressivo gia' emerso: la bl" 174: "Tensioni risolte: {'TENSIONE_ENTITA', 'METRIC_TENSOR', 'BOUNDARY_LAYER_GATE', 'G_POTENZIALE_NULLA', 'DUALITA_DIPOLARE_VS_ILLUSORIA', 'TRAJECTORY_APPLY_20260507_0803', 'TRAJECTORY_APPLY_20260507_0901', 'PERTURBATION_DENOMINATOR_GATE', 'OBSERVABLE_REGISTRY', 'ORDER_DENOMINATOR_GATE', 'PIANO_PRIMARIO_DUE_ASSIOMI', 'TRASCENDENZA_LIMITE'}" 181: "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", 349: "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" exec /bin/bash -lc 'tail -45 tools/data/seme.json' in /opt/MM_D-ND succeeded in 0ms: "timestamp": "2026-04-02T08:23:13.992021" }, { "id": "video_rZ2m1_q9lg0", "title": "New duality: conductor-insulator in YbB12 at 35T - University of Michigan", "type": "video_digest", "keywords": [ "duality", "conductor", "insulator", "Kondo insulator", "quantum oscillations", "ytterbium boride", "YbB12", "charge-neutral fermions", "strongly correlated", "condensed matter", "magnetic field" ], "content": "Scoperta dualita conduttore-isolante in YbB12 a 35 Tesla. Il materiale si comporta simultaneamente da conduttore e isolante — oscillazioni quantistiche dal bulk, non dalla superficie. Charge-neutral fermions (portatori senza carica) creano comportamento di conduzione = il terzo incluso. La scoperta avviene a campo estremo dove il confine tra stati collassa.", "teorie": [ "T", "Q", "E" ], "ponti_potenziali": [ { "coppia": "TxQ", "ponte": "Kondo insulator fortemente correlato — dualita conduttore/isolante come stato quantistico unico", "nota": "charge-neutral fermions = portatori senza carica che conducono, terzo incluso operativo" }, { "coppia": "ExQ", "ponte": "campo magnetico estremo (35T) collassa il confine tra stati — condizione di soglia", "nota": "il confine non separa, unifica. Pattern BOUNDARY del Domandatore" } ], "ref": "Physical Review Letters 2025, 135(15). Chen, Zhu, Ratkovski et al. PI: Lu Li", "timestamp": "2026-04-04T19:34:08.014Z" } ], "_seed_history": { "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" } } diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc "sed -n '1,12p' tools/data/seme.json && sed -n '176,185p' tools/data/seme.json" in /opt/MM_D-ND succeeded in 0ms: { "timestamp": "2026-05-07T09:47:22.985377", "piano": 73, "tensioni": [ { "id": "OBSERVABLE_REGISTRY", "tipo": "vincolo", "claim": "Ogni script che usa observables canonici (SR, SR2, L1, L2, triple_var) deve importare la definizione da tools/observables_registry.py. Varianti devono usare nomi distinti (SR_local_rigidity, triple_var_normalized) — niente shadowing del nome canonico. Ogni report deve dichiarare 'observables_registry: VERSION' nel header.", "intensita": 1.0, "porta": "infrastructure", "manuale": true, "condensato_ref": "A14,A8", "filtro": { "promosse": 14, "filtrate": 0, "condensato_claims": 30 }, "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", "verifica": { "pass": 11, "fail": 0, "skip": 0, diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() apply patch patch: completed /opt/MM_D-ND/tools/data/seme.json diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/data/seme.json b/tools/data/seme.json index a02bd96522ef9c8f04ad3bb19c3f42dd0310dbbf..e98b79a9f7c93b3a9574ff4153ce6af0f7d8a2d2 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,5 +1,5 @@ { - "timestamp": "2026-05-07T09:47:22.985377", + "timestamp": "2026-05-07T10:06:00.000000", "piano": 73, "tensioni": [ { @@ -38,12 +38,12 @@ { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", - "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", - "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", "added_at": "2026-05-07T09:01:00+00:00" }, { @@ -178,7 +178,7 @@ "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -346,6 +346,7 @@ } ], "_seed_history": { - "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" } -} \ No newline at end of file +} diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/data/seme.json b/tools/data/seme.json index a02bd96522ef9c8f04ad3bb19c3f42dd0310dbbf..e98b79a9f7c93b3a9574ff4153ce6af0f7d8a2d2 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,5 +1,5 @@ { - "timestamp": "2026-05-07T09:47:22.985377", + "timestamp": "2026-05-07T10:06:00.000000", "piano": 73, "tensioni": [ { @@ -38,12 +38,12 @@ { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", - "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", - "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", "added_at": "2026-05-07T09:01:00+00:00" }, { @@ -178,7 +178,7 @@ "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -346,6 +346,7 @@ } ], "_seed_history": { - "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" } -} \ No newline at end of file +} diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc "git diff -- tools/exp_logistic_counter_scope_gate.py tools/data/reports/agent_20260507_1006.md tools/data/seme.json | sed -n '1,260p'" in /opt/MM_D-ND succeeded in 0ms: diff --git a/tools/data/seme.json b/tools/data/seme.json index a31dc54..e98b79a 100644 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,7 +1,51 @@ { - "timestamp": "2026-04-23T03:35:37.611830", - "piano": 48, + "timestamp": "2026-05-07T10:06:00.000000", + "piano": 73, "tensioni": [ + { + "id": "OBSERVABLE_REGISTRY", + "tipo": "vincolo", + "claim": "Ogni script che usa observables canonici (SR, SR2, L1, L2, triple_var) deve importare la definizione da tools/observables_registry.py. Varianti devono usare nomi distinti (SR_local_rigidity, triple_var_normalized) — niente shadowing del nome canonico. Ogni report deve dichiarare 'observables_registry: VERSION' nel header.", + "intensita": 1.0, + "porta": "infrastructure", + "manuale": true, + "condensato_ref": "A14,A8", + "origine": "cristallizzato 06/05 dalla consecutio del cycle 20260506_0625 (autopoietico self-finding)", + "added_at": "2026-05-06T07:03:58.213606+00:00" + }, + { + "id": "PERTURBATION_DENOMINATOR_GATE", + "tipo": "vincolo", + "claim": "La dimensionalita di perturbazione va riportata solo insieme a PC2, versione observables_registry e gate original-vs-shuffle per osservabile. Nel perimetro 20260506_1941, Poisson e shuffle-primi producono rank_all ~1.8-2.0 con denominatori deboli; dopo gate abs(z)>=2 il rank stabile torna vicino a 1. Rank PCA non gated non e evidenza strutturale.", + "intensita": 0.95, + "porta": "META_BOUNDARY", + "manuale": true, + "condensato_ref": "A4,A8,A14,C2", + "origine": "cycle agent_20260506_1941: perturbation rank size curve canonical observables", + "added_at": "2026-05-06T19:41:00+00:00" + }, + { + "id": "BOUNDARY_LAYER_GATE", + "tipo": "vincolo", + "claim": "I claim GUE/Poisson boundary devono riportare layer map: versione observables_registry, lista osservabili canonici, z original-vs-shuffle per osservabile, set endpoint-stable, e finestra/layer con margine classificatorio ambiguo. Nel perimetro sintetico agent_20260507_0330, il confine GUE-Poisson e beta 0.3-0.4: margine 0.070-0.083, ambiguous fraction 0.812-0.875, mentre gli osservabili stabili collassano da ~3.3 a 1.6. Il polo Poisson e classificabile ma denominator-weak.", + "intensita": 0.93, + "porta": "META_BOUNDARY", + "manuale": true, + "condensato_ref": "A4,A8,A9,A14,C2", + "origine": "cycle agent_20260507_0330: synthetic GUE-Poisson mixture layer gate", + "added_at": "2026-05-07T03:30:00+00:00" + }, + { + "tipo": "vincolo", + "id": "ORDER_DENOMINATOR_GATE", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "intensita": 0.92, + "porta": "META", + "manuale": true, + "condensato_ref": "A4,A8,A14,C2", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", + "added_at": "2026-05-07T09:01:00+00:00" + }, { "tipo": "confine_inesplorato", "id": "TRASCENDENZA_LIMITE", @@ -78,28 +122,63 @@ "condensato_ref": "A9,A14", "condensato_motivo": "A9 (terzo incluso) opera CON il piano. A14 (cascata) propaga - ma propaga cosa, se solo 2 assiomi sono attivi per zona?" }, + { + "tipo": "task", + "id": "TRAJECTORY_APPLY_20260507_0803", + "claim": "Applied valutatore REDESIGN from 20260507_0803: Costruire una matrice di trasferibilita' del denominator gate: applicarlo a 3-4 perimetri non-BOUNDARY con poli coerente/illusorio e verificare quali parti trasferiscono (supporto one-sided, coordinat", + "intensità": 0.7, + "porta": "trajectory_apply", + "condensato_ref": "A8,A14,A15", + "manuale": true, + "_source_log": "2026-05-07T08:10:22.658201+00:00", + "_source_decision": "REDESIGN", + "_source_reasoning": "Il ciclo ha prodotto evidenza controllata e replicata che il denominator gate trasferisce come operatore, ma non trasferisce la coordinata di layer BOUNDARY: ambiguita' classificativa e collasso del denominatore si separano. Continuare sul seme attuale centrato su GUE/Poisson rischia di restare nel " + }, + { + "tipo": "task", + "id": "TRAJECTORY_APPLY_20260507_0901", + "claim": "Applied valutatore REDESIGN from 20260507_0901: Falsificare ORDER_DENOMINATOR_GATE su domini non-sintetici o semi-reali: applicare il gate one-sided a 2-3 sequenze fisiche/ponte gia' presenti nel sito, con shuffle e surrogati preservanti marginale,", + "intensità": 0.7, + "porta": "trajectory_apply", + "condensato_ref": "A8,A14,A15", + "manuale": true, + "_source_log": "2026-05-07T09:07:53.577876+00:00", + "_source_decision": "REDESIGN", + "_source_reasoning": "La direzione corrente ha eseguito il mandato: la matrice di trasferibilita' su 4 perimetri non-BOUNDARY e' stata prodotta e ha nominato una nuova categoria, order_denominator_gate. Un altro giro nello stesso frame rischia accumulo numerico locale su sintetici; la prossima mossa deve falsificare il n" + }, { "tipo": "simmetria_sospetta", "id": "META", "claim": "Tutti i 11 test passano — verifica che non stiamo testando solo tautologie", "intensità": 0.5, "nota": "La convergenza a φ è triviale (controprove). I test stanno verificando contenuto o struttura?", - "condensato_ref": null, - "condensato_motivo": "Ricorrente (3x in 2 giorni) e fuori dalla mappa", - "porta": "novità" + "condensato_ref": "A4,A12,C2", + "porta": "verify_assertions_META_ALL_PASS", + "condensato_motivo": "Ricorrente (3x in 2 giorni) e fuori dalla mappa" + }, + { + "tipo": "task", + "id": "TRAJECTORY_APPLY_20260507_0942", + "claim": "Applied valutatore REDESIGN from 20260507_0942: Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics s", + "intensità": 0.7, + "porta": "trajectory_apply", + "condensato_ref": "A8,A14,A15", + "manuale": true, + "_source_log": "2026-05-07T09:47:43.105142+00:00", + "_source_decision": "REDESIGN", + "_source_reasoning": "La direzione corrente ha completato il mandato sui perimetri fisici/ponte gia' presenti: il gate trasferisce come supporto canonico one-sided su metric, trace e QxE, mentre il supporto both-endpoint resta vuoto. La consecutio utile non e' un altro bridge run, ma il nodo regressivo gia' emerso: la bl" } ], "potenziale_bloccato": [], "varianza": [ - "Nuove tensioni: {'META'}", - "Tensioni risolte: {'METRIC_TENSOR', 'TRASCENDENZA_LIMITE', 'TENSIONE_ENTITA', 'PIANO_PRIMARIO_DUE_ASSIOMI', 'DUALITA_DIPOLARE_VS_ILLUSORIA', 'G_POTENZIALE_NULLA'}" + "Tensioni risolte: {'TENSIONE_ENTITA', 'METRIC_TENSOR', 'BOUNDARY_LAYER_GATE', 'G_POTENZIALE_NULLA', 'DUALITA_DIPOLARE_VS_ILLUSORIA', 'TRAJECTORY_APPLY_20260507_0803', 'TRAJECTORY_APPLY_20260507_0901', 'PERTURBATION_DENOMINATOR_GATE', 'OBSERVABLE_REGISTRY', 'ORDER_DENOMINATOR_GATE', 'PIANO_PRIMARIO_DUE_ASSIOMI', 'TRASCENDENZA_LIMITE'}" ], "filtro": { - "promosse": 8, + "promosse": 14, "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Esplorare il confine: 8 domini GUE, 5 Poisson — il confine è il terzo incluso operativo", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -265,5 +344,9 @@ "ref": "Physical Review Letters 2025, 135(15). Chen, Zhu, Ratkovski et al. PI: Lu Li", "timestamp": "2026-04-04T19:34:08.014Z" } - ] + ], + "_seed_history": { + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" + } } exec /bin/bash -lc "sed -n '1,220p' tools/data/reports/agent_20260507_1006.md" in /opt/MM_D-ND succeeded in 0ms: # Agent Report — Logistic Counter-Scope Gate timestamp: 2026-05-07 10:06 UTC category: gate_falsification_logistic_observability verdict: scoped_operator_with_counter_scope observables_registry: not used for canonical observables observables_native_version: logistic-native-1.0.0-2026-05-07 observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] tool: tools/exp_logistic_counter_scope_gate.py data: tools/data/logistic_counter_scope_gate_20260507_1006.json seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json ## Claim Under Test Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il contratto osservabile canonico? Perimetri: - `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. - `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. - `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. Gate invariato: osservabile stabile se `abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle marginal-preserving. `z_min` non viene tunato. ## Deposito Numerico Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, `n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, `seed=202605071006`. Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | |---|---:|---:|---:|---:|---:| | logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | | logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | | logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | Seed check: | perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | |---|---:|---:|---:|---:|---:| | logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | | logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | | logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | Endpoint-stable observables: `[]` in all three perimeters in both runs. Z means at coherent endpoint: | perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | |---|---:|---:|---:|---:| | logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | | logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | | logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | Seed check coherent z means: | perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | |---|---:|---:|---:|---:| | logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | | logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | | logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | ## Risultato 1. **The logistic blank is an observability split.** The continuous logistic orbit carries one-sided support through `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count is `1.000`; the illusory endpoint drops from `0.375` in the main run to `0.000` in the seed check. The denominator gate reads order when the perimetro is the orbit itself and the observable is native to symbolic block structure. 2. **The generating partition remains blank under this gate.** `logistic_symbolic_itinerary` has no coherent one-sided observable in either run. This matches the known Bernoulli character of the `x>0.5` itinerary at `r=4`: the symbolic stream does not become denominator-supported by changing from canonical gap observables to this native suite. 3. **Return intervals stay counter-scope.** The main run gives `recurrence_diag_mean` one-sided support on return intervals, but the seed check removes it. The stable statement is blank: `logistic_return_intervals` does not carry replicated one-sided denominator support under this native suite. 4. **Return-tail exponent is not the missing observable.** `return_tail_alpha` has coherent z mean `0.000` on return intervals in both runs. In this setup it is marginal-dominated under the shuffle null and does not distinguish the coherent endpoint. ## Consecutio `ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting the logistic object: > The logistic orbit transfers as one-sided support through native block > entropy. The Bernoulli itinerary and the high-threshold return intervals > remain blank under the declared original-vs-shuffle gate. The logistic > counter-scope is not "logistic dynamics"; it is the return-interval and > generating-partition perimetro under this observable contract. Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more observables. The remaining useful test is a surrogate-class split for logistic: compare marginal shuffle against circular shift and block shuffle. If support appears only against full shuffle, the gate is detecting long-range disruption of deterministic orbit order; if it survives block/circular surrogates, the observable binds to local dynamics. ## Self-Audit: 5 Lenti L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the declared runs. The report does not claim zero illusory support; illusory stable count is `0.375` for `logistic_orbit_values` in the main run. L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and replication status are reported before interpretation. No percent drift claim is used. L3 no silent patching: 09:23 found blank on logistic return intervals using canonical observables. This report does not rescue that blank: return intervals remain blank after seed check. The positive scope is explicitly moved to `logistic_orbit_values`. L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` does not replicate. It is reported as ambiguous and excluded from the stable claim. L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with the classical Bernoulli coding of the fully chaotic logistic map. The report claims operator scope inside the lab protocol, not a new theorem about logistic dynamics. ## Fonti - Verificato: `tools/data/agent_field_live.md` - Verificato: `tools/LAB_AGENT_CONTEXT.md` - Verificato: `tools/exp_logistic_counter_scope_gate.py` - Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` - Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` - Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` - Inferito: the logistic blank is a perimetro split because orbit values show replicated one-sided support while symbolic itinerary and return intervals do not. exec /bin/bash -lc 'python -m json.tool tools/data/seme.json >/tmp/seme_validated.json' in /opt/MM_D-ND succeeded in 0ms: diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/data/seme.json b/tools/data/seme.json index a02bd96522ef9c8f04ad3bb19c3f42dd0310dbbf..e98b79a9f7c93b3a9574ff4153ce6af0f7d8a2d2 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,5 +1,5 @@ { - "timestamp": "2026-05-07T09:47:22.985377", + "timestamp": "2026-05-07T10:06:00.000000", "piano": 73, "tensioni": [ { @@ -38,12 +38,12 @@ { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", - "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", - "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", "added_at": "2026-05-07T09:01:00+00:00" }, { @@ -178,7 +178,7 @@ "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -346,6 +346,7 @@ } ], "_seed_history": { - "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" } -} \ No newline at end of file +} diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc "ls tools | rg 'falsifier|valutatore|trajectory'" in /opt/MM_D-ND succeeded in 0ms: lab_falsifier.py lab_trajectory_apply.py lab_valutatore.py exec /bin/bash -lc "rg -n 'ANTHROPIC|OPENAI|api|claude|codex' tools/lab_falsifier.py tools 2>/dev/null | head -80" in /opt/MM_D-ND succeeded in 0ms: tools/data/notte_20260329_0330.md:17: rudin_shapiro_cp: r=0.9998005196084427, spacing=? [conferma] tools/data/reports/ddf_20260428_0405.json:46: "file": "http_api.js", tools/data/reports/agent_20260421_0330.md:80:2. **The algebraic content decomposes hierarchically: 81% / 17.5% / 1.5%.** Lag-1 (Chebyshev alternation) dominates. Lag-2 (how three consecutive residue classes correlate) adds 17.5%. Lag-3 provides a 1.5% correction that closes the gap completely. This is a geometric series of decreasing contributions — the Markov memory decays rapidly. tools/data/reports/ddf_20260501_0405.json:15: "file": "M adapters/http_api.js\n M boot_kthia.js\n M core/Kernel.js\n M data/bicono_lab.json\n M data/campo_vivo.json\n M data/conoscenza_teorie.json\n M data/domande_fondamentali.json\n M data/drift_seme_hash\n M da" tools/data/reports/ddf_20260501_0405.json:46: "file": "http_api.js", tools/data/reports/ddf_20260326_0405.json:50: "file": "http_api.js", tools/data/reports/ddf_20260420_0405.json:51: "file": "http_api.js", tools/data/reports/ddf_20260402_0405.json:20: "file": "M adapters/http_api.js\n M data/bicono_lab.json\n M data/campo_vivo.json\n M data/drift_seme_hash\n M data/godel_field.json\n M data/lab_data.json\n M data/seme.json\n M data/site_guardian_report.json\n M doc" tools/data/reports/ddf_20260402_0405.json:50: "file": "http_api.js", tools/data/reports/ddf_20260415_0405.json:56: "file": "http_api.js", tools/data/reports/incident_20260504_1138.md:4:**Errors**: Both codex+claude failed (codex exit=0, claude exit=124). tools/data/reports/incident_20260504_1138.md:45:- **codex token issue** — refresh_token reused or invalidated; `codex login` interactive required tools/data/reports/ddf_20260401_0405.json:50: "file": "http_api.js", tools/data/reports/ddf_20260403_0405.json:20: "file": "M adapters/http_api.js\n M data/bicono_lab.json\n M data/campo_vivo.json\n M data/drift_seme_hash\n M data/godel_field.json\n M data/lab_data.json\n M data/seme.json\n M data/site_guardian_report.json\n M doc" tools/data/reports/ddf_20260403_0405.json:50: "file": "http_api.js", tools/lab_falsifier.py:8:Pattern dipolo asimmetrico: producer (claude/codex agent) e' polo +, tools/lab_falsifier.py:141: """Run the falsifier prompt through provider chain (codex → claude → openrouter). tools/data/reports/ddf_20260405_0405.json:56: "file": "http_api.js", tools/LAB_AGENT_CONTEXT.md:173:**Skill canoniche di questo lab** (vivono in `.claude/skills/`): tools/LAB_AGENT_CONTEXT.md:195:**Skill operative universali** (in `/opt/.claude/skills/`): tools/data/reports/ddf_20260325_0405.json:51: "file": "http_api.js", tools/dipartimento.py:1218: 'http://localhost:3002/api/node-sync', tools/dipartimento.py:1869: # Telegram — /api/notify requires system token (THIA_API_TOKEN), not per-node token tools/dipartimento.py:1878: 'http://localhost:3002/api/notify', tools/dipartimento.py:1906: 'http://localhost:3002/api/node-sync', tools/dipartimento.py:2055: 'http://localhost:3002/api/notify', tools/dipartimento.py:2092: # Default: report rapido tools/dnd_stats.py:204: """Invia notifica Telegram via THIA API (/api/notify requires system token).""" tools/dnd_stats.py:212: ["curl", "-s", "-X", "POST", "http://localhost:3002/api/notify", tools/data/reports/ddf_20260404_0405.json:20: "file": "M adapters/http_api.js\n M data/bicono_lab.json\n M data/campo_vivo.json\n M data/ciclo_memoria.json\n M data/domande_fondamentali.json\n M data/drift_seme_hash\n M data/godel_field.json\n M data/lab_data.js" tools/data/reports/ddf_20260404_0405.json:50: "file": "http_api.js", tools/dnd_retriever.py:75: url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{concept}" tools/dnd_retriever.py:96: search_url = (f"https://en.wikipedia.org/w/api.php?action=query&list=search" tools/dnd_retriever.py:106: sum_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{urllib.parse.quote(title)}" tools/dnd_retriever.py:135: url = f"http://export.arxiv.org/api/query?search_query=all:{urllib.parse.quote(query)}&max_results={max_results}&sortBy=relevance" tools/dnd_arxiv.py:9:quindi usa web scraping delle pagine di ricerca arXiv. tools/dnd_arxiv.py:79: Cerca su arXiv via web scraping. tools/dnd_zero_controllo.py:211: # Test rapido dipolo random tools/dnd_observer.py:102: exists = "OK" if (BASE / impl).exists() or Path(f"/opt/.claude/hooks/{impl}").exists() or Path(f"/opt/Godel_DND/{impl}").exists() else "??" tools/GUIDA_CEC.md:292:| TM1 (Home) | dev.d-nd.com/godel-tm1-api/ask | python diretto (MM_D-ND locale) | python diretto | python diretto | python diretto | tools/lab_valutatore.py:438: # Refactor 06/05: provider chain via lib_llm_chain (codex → claude → openrouter). tools/lab_valutatore.py:439: # Era solo claude CLI con timeout subprocess; ora ha pre-flight cache + OpenRouter tools/lab_valutatore.py:588: "http://localhost:3002/api/notify", tools/godel.py:17: TM1: https://d-nd.com/godel-tm1-api/ask (porta 3005) tools/godel.py:19: TM5: https://d-nd.com/godel-tm5-api/ask (porta 3007) tools/godel.py:20: Pubblico: https://d-nd.com/godel-api/ask (rate limit 1r/m) tools/godel.py:29:# TM1 deve cambiare a godel-tm1-api, TM3 usa localhost tools/godel.py:30:GODEL_URL = os.environ.get("GODEL_URL", "https://d-nd.com/godel-api/ask") tools/translate_tensions.py:24:# Default refactor 03/05: codex-cli (TM7 ChatGPT account) → claude-cli (OAuth) tools/translate_tensions.py:25:# → openrouter (paid). Distribuisce carico, evita stress su quota claude OAuth. tools/translate_tensions.py:26:# Override via env LLM_PROVIDER_CHAIN="claude-cli,openrouter" tools/translate_tensions.py:28: p.strip() for p in os.environ.get("LLM_PROVIDER_CHAIN", "codex-cli,claude-cli,openrouter").split(",") tools/translate_tensions.py:33:OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions" tools/translate_tensions.py:100:# auth-fail. Prima chiamata fa check rapido 30s, esiti cached. tools/translate_tensions.py:101:# Reset a None per forzare ricontrollo (es. dopo codex login). tools/translate_tensions.py:106:def _codex_preflight_check() -> bool: tools/translate_tensions.py:107: """30s ping a codex per detect 401/refresh_token_reused. Cached.""" tools/translate_tensions.py:111: if not shutil.which("codex"): tools/translate_tensions.py:116: ["codex", "exec", "--skip-git-repo-check", "echo ok"], tools/translate_tensions.py:124: print(" codex pre-flight: AUTH FAIL (skip per questa run)", file=sys.stderr) tools/translate_tensions.py:134:def _claude_preflight_check() -> bool: tools/translate_tensions.py:135: """30s ping a claude per detect hang silenzioso o auth fail. Cached.""" tools/translate_tensions.py:139: if not shutil.which("claude"): tools/translate_tensions.py:144: ["claude", "--print", "Reply only: ok"], tools/translate_tensions.py:151: print(" claude pre-flight: AUTH FAIL (skip per questa run)", file=sys.stderr) tools/translate_tensions.py:155: print(" claude pre-flight: HUNG (output vuoto, skip per questa run)", file=sys.stderr) tools/translate_tensions.py:165:def call_via_claude_cli(messages, timeout=120): tools/translate_tensions.py:166: """Provider 1: claude-cli OAuth (gratis). Pattern lab_agent.sh.""" tools/translate_tensions.py:167: if not _claude_preflight_check(): tools/translate_tensions.py:172: ["claude", "-p", prompt, "--max-turns", "1", tools/translate_tensions.py:179: print(f" claude-cli error: {e}", file=sys.stderr) tools/translate_tensions.py:183:def call_via_codex_cli(messages, timeout=120): tools/translate_tensions.py:184: """Provider 2: codex-cli (ChatGPT account OAuth).""" tools/translate_tensions.py:185: if not _codex_preflight_check(): tools/translate_tensions.py:192: ["codex", "exec", "--skip-git-repo-check", "--full-auto", "-"], tools/translate_tensions.py:198: print(f" codex-cli error: {e}", file=sys.stderr) tools/translate_tensions.py:248: "claude-cli": call_via_claude_cli, tools/translate_tensions.py:249: "codex-cli": call_via_codex_cli, tools/translate_tensions.py:257: Default chain: claude-cli (OAuth gratis) → codex-cli → openrouter. tools/translate_tensions.py:319: # Provider chain: niente check OPENROUTER_API_KEY come blocking — claude-cli/ exec /bin/bash -lc "test -f tools/lab_falsifier.py && sed -n '1,140p' tools/lab_falsifier.py || true" in /opt/MM_D-ND succeeded in 0ms: #!/usr/bin/env python3 """ lab_falsifier.py — Counter-pole gate per il lab fisica. Operatore (29/04): "rendiamo il processo rigoroso al massimo, solo cose vere devono uscire dal lab altrimenti contaminiamo tutto". Pattern dipolo asimmetrico: producer (claude/codex agent) e' polo +, falsifier e' polo - (challenger). Il falsifier non riscrive il report, emette flag su 5 lenti tied to assiomi del modello D-ND. Se HIGH flags rilevati, lab_agent.sh blocca il sync verso il sito + THIA + Docker. Le 5 lenti (port da /opt/D-ND_LAB/core/report_falsifier.py, riformulate nel linguaggio D-ND, NON copia 1:1 di Gemini critique): L1 Hard constraint vs statistical bias → A2 (confine duro) L2 Absolute quantity vs ratio → A14 (cascata, dim. invariance) L3 Axiom continuity (no silent patching) → A4 (modus, qualita' della domanda) L4 Edge case isolation (1/N is not zero) → A12 (traccia la curva) L5 Re-discovery vs discovery (literature) → A8 (autologica) Usage: python3 lab_falsifier.py --report PATH --output PATH Exit codes: 0 report coerente (nessun flag) 1 HIGH severity flags rilevati → SYNC BLOCKED 2 falsifier stesso fallito (LLM unavailable, parse error) → SYNC BLOCKED (fail-conservative: se non possiamo verificare, non pubblichiamo) """ from __future__ import annotations import argparse import json import os import re import subprocess import sys from datetime import datetime, timezone from pathlib import Path REPO_DIR = Path("/opt/MM_D-ND") DATA_DIR = REPO_DIR / "tools" / "data" FALSIFIER_PROMPT = """Sei il Counter-Pole del lab fisica D-ND. Polo asimmetrico opposto al producer agent: il suo occhio cerca pattern, il tuo cerca inconsistenze. NON riscrivi il report. Lo sfidi. Leggi: 1. Il report markdown che il producer ha appena scritto. 2. I file empirici/strutturali del lab (lab_data.json, conoscenza_teorie.json, cimitero.md se cita claim falsificati). Applica 5 lenti, ognuna legata a un assioma del modello D-ND. Applica STRETTAMENTE — un falso silenzio e' peggio di un flag che l'operatore puo' dismettere. ### L1 — Hard constraint vs bias statistico (A2 confine duro) Un claim "impossibile / proibito / zero / proibition / forbidden" e' HARD constraint e richiede uno zero ESATTO nei dati (probabilita' = 0.000). Se la matrice citata ha qualunque entry non-zero dove il report dice "zero", flag. Bias != proibizione. ### L2 — Quantita' assoluta vs ratio (A14 cascata, invarianza dimensionale) Confronto fra spazi degli stati di taglia diversa (es. mod 3 vs mod 30, N piccolo vs N grande, finestra stretta vs larga): le percentuali ingannano perche' il denominatore cresce. Stesso segnale assoluto SEMBRA ridursi in %. Se il report conclude "diminuisce / si dilata / declina" su confronti percentuali fra spazi, flag e proponi unita' assolute (bit di mutual information, count grezzi, soglie esatte). ### L3 — Continuita' assiomatica / no silent patching (A4 modus) Se il setup ("Claim Under Test") usa una definizione (es. "F2: gap mod 6 in {2,4}") e la conclusione silenziosamente ne usa un'altra ("gap mod 6 in {0,2,4}"), e' patch det=+1 sul presente, non inversione det=−1 al nodo regressivo. Il cambio DEVE essere dichiarato esplicitamente: "F2 falsificato al nodo X — scope corretto e' Y". ### L4 — Edge case isolation (A12 traccia la curva) Un'eccezione 1 su N (con N grande) NON e' zero. Se il report dice "sempre X" o "mai X" e i dati mostrano anche un singolo controesempio, il perimetro deve essere riformulato ("per p > 3, X vale") — mai arrotondato via. ### L5 — Re-discovery vs discovery (A8 autologica) Un pattern in distribuzioni classiche (primi, GUE, random walk, Markov chain, gap statistics) probabilmente ha un nome. Default hypothesis: re-discovery / caso limite di teorema noto. Taggare come "NEW" senza riconoscere il risultato classico piu' vicino (es. Lemke Oliver–Soundararajan per prime gaps mod q) e' beauty bias. Flag. --- OUTPUT — UN SOLO oggetto JSON. NESSUN testo fuori dal JSON. Schema: { "coherent": , "flags": [ { "lens": , "severity": "high" | "medium" | "low", "claim": "", "evidence": "", "suggestion": "" } ], "summary": "" } Regole: - coherent=true, flags=[] se le 5 lenti sono pulite. - coherent=null, flags=[] se i dati sono assenti o non checkable; summary spiega. - Severity HIGH: contraddizione interna esplicita o claim falsificabile dai dati visibili. - Severity MEDIUM: incertezza significativa, richiede verifica piu' profonda. - Severity LOW: imprecisione terminologica, drift senza errore strutturale. - Sii specifico: "matrice mod 5 senza zeri ma report dice 25% prohibition" e' un flag; "il report usa gergo" non lo e'. --- Ecco il report e i dati: {context} --- Emetti il JSON ora (no markdown fence, no prose): """ def _read_safe(path: Path, max_bytes: int = 8000) -> str: """Read file, return empty string on error. Cap to max_bytes.""" try: text = path.read_text(errors="replace") except Exception: return "" if len(text) > max_bytes: text = text[:max_bytes] + f"\n…[troncato, file e' {len(text)} bytes]" return text def build_context(report_path: Path) -> str: """Compose report + data context for the prompt.""" parts: list[str] = [] parts.append("## REPORT (markdown che il producer ha scritto)\n") parts.append(_read_safe(report_path, 9000)) parts.append("\n\n## FILE EMPIRICI E STRUTTURALI\n") canonical_files = [ ("lab_data.json", DATA_DIR / "lab_data.json"), ("seme.json", DATA_DIR / "seme.json"), ("conoscenza_teorie.json", DATA_DIR / "conoscenza_teorie.json"), ("cimitero.md", REPO_DIR / "cimitero.md"), ] for label, p in canonical_files: content = _read_safe(p, 3500) if content: parts.append(f"\n### {label}\n```\n{content}\n```\n") return "".join(parts) def call_falsifier_llm(prompt: str, timeout_s: int = 240) -> tuple[str, int]: diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/data/seme.json b/tools/data/seme.json index a02bd96522ef9c8f04ad3bb19c3f42dd0310dbbf..e98b79a9f7c93b3a9574ff4153ce6af0f7d8a2d2 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,5 +1,5 @@ { - "timestamp": "2026-05-07T09:47:22.985377", + "timestamp": "2026-05-07T10:06:00.000000", "piano": 73, "tensioni": [ { @@ -38,12 +38,12 @@ { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", - "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", - "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", "added_at": "2026-05-07T09:01:00+00:00" }, { @@ -178,7 +178,7 @@ "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -346,6 +346,7 @@ } ], "_seed_history": { - "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" } -} \ No newline at end of file +} diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() exec /bin/bash -lc 'pgrep -af exp_logistic_counter_scope_gate.py || true' in /opt/MM_D-ND succeeded in 0ms: 1 /root/.codex-lab/tmp/arg0/codex-arg03EhTbp/codex-linux-sandbox --sandbox-policy-cwd /opt/MM_D-ND --command-cwd /opt/MM_D-ND --sandbox-policy {"type":"workspace-write","writable_roots":["/root/.codex-lab/memories"],"network_access":false,"exclude_tmpdir_env_var":false,"exclude_slash_tmp":false} --file-system-sandbox-policy {"kind":"restricted","entries":[{"path":{"type":"special","value":{"kind":"root"}},"access":"read"},{"path":{"type":"special","value":{"kind":"current_working_directory"}},"access":"write"},{"path":{"type":"special","value":{"kind":"slash_tmp"}},"access":"write"},{"path":{"type":"special","value":{"kind":"tmpdir"}},"access":"write"},{"path":{"type":"path","path":"/root/.codex-lab/memories"},"access":"write"},{"path":{"type":"path","path":"/opt/MM_D-ND/.git"},"access":"read"},{"path":{"type":"path","path":"/opt/MM_D-ND/.codex"},"access":"read"}]} --network-sandbox-policy "restricted" -- /bin/bash -c __CODEX_SNAPSHOT_OVERRIDE_SET_0="${CODEX_THREAD_ID+x}" __CODEX_SNAPSHOT_OVERRIDE_0="${CODEX_THREAD_ID-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_0="${ALL_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_0="${ALL_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_1="${BUNDLE_HTTPS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_1="${BUNDLE_HTTPS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_2="${BUNDLE_HTTP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_2="${BUNDLE_HTTP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_3="${BUNDLE_NO_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_3="${BUNDLE_NO_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_4="${CODEX_NETWORK_ALLOW_LOCAL_BINDING+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_4="${CODEX_NETWORK_ALLOW_LOCAL_BINDING-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_5="${CODEX_NETWORK_PROXY_ACTIVE+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_5="${CODEX_NETWORK_PROXY_ACTIVE-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_6="${DOCKER_HTTPS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_6="${DOCKER_HTTPS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_7="${DOCKER_HTTP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_7="${DOCKER_HTTP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_8="${ELECTRON_GET_USE_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_8="${ELECTRON_GET_USE_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_9="${FTP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_9="${FTP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_10="${HTTPS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_10="${HTTPS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_11="${HTTP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_11="${HTTP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_12="${NO_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_12="${NO_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_13="${NPM_CONFIG_HTTPS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_13="${NPM_CONFIG_HTTPS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_14="${NPM_CONFIG_HTTP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_14="${NPM_CONFIG_HTTP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_15="${NPM_CONFIG_NOPROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_15="${NPM_CONFIG_NOPROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_16="${NPM_CONFIG_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_16="${NPM_CONFIG_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_17="${PIP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_17="${PIP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_18="${WSS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_18="${WSS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_19="${WS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_19="${WS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_20="${YARN_HTTPS_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_20="${YARN_HTTPS_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_21="${YARN_HTTP_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_21="${YARN_HTTP_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_22="${YARN_NO_PROXY+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_22="${YARN_NO_PROXY-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_23="${all_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_23="${all_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_24="${ftp_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_24="${ftp_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_25="${http_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_25="${http_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_26="${https_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_26="${https_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_27="${no_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_27="${no_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_28="${npm_config_http_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_28="${npm_config_http_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_29="${npm_config_https_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_29="${npm_config_https_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_30="${npm_config_noproxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_30="${npm_config_noproxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_31="${npm_config_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_31="${npm_config_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_32="${ws_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_32="${ws_proxy-}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_33="${wss_proxy+x}" __CODEX_SNAPSHOT_PROXY_OVERRIDE_33="${wss_proxy-}" __CODEX_SNAPSHOT_PROXY_ENV_SET="${CODEX_NETWORK_PROXY_ACTIVE+x}" if . '/root/.codex-lab/shell_snapshots/019e01e6-ed73-7e61-8cf9-21c4c1792108.1778148371837396721.sh' >/dev/null 2>&1; then :; fi if [ -n "${__CODEX_SNAPSHOT_OVERRIDE_SET_0}" ]; then export CODEX_THREAD_ID="${__CODEX_SNAPSHOT_OVERRIDE_0}"; else unset CODEX_THREAD_ID; fi if [ -n "$__CODEX_SNAPSHOT_PROXY_ENV_SET" ] || [ -n "${CODEX_NETWORK_PROXY_ACTIVE+x}" ]; then if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_0}" ]; then export ALL_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_0}"; else unset ALL_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_1}" ]; then export BUNDLE_HTTPS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_1}"; else unset BUNDLE_HTTPS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_2}" ]; then export BUNDLE_HTTP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_2}"; else unset BUNDLE_HTTP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_3}" ]; then export BUNDLE_NO_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_3}"; else unset BUNDLE_NO_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_4}" ]; then export CODEX_NETWORK_ALLOW_LOCAL_BINDING="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_4}"; else unset CODEX_NETWORK_ALLOW_LOCAL_BINDING; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_5}" ]; then export CODEX_NETWORK_PROXY_ACTIVE="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_5}"; else unset CODEX_NETWORK_PROXY_ACTIVE; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_6}" ]; then export DOCKER_HTTPS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_6}"; else unset DOCKER_HTTPS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_7}" ]; then export DOCKER_HTTP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_7}"; else unset DOCKER_HTTP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_8}" ]; then export ELECTRON_GET_USE_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_8}"; else unset ELECTRON_GET_USE_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_9}" ]; then export FTP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_9}"; else unset FTP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_10}" ]; then export HTTPS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_10}"; else unset HTTPS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_11}" ]; then export HTTP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_11}"; else unset HTTP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_12}" ]; then export NO_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_12}"; else unset NO_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_13}" ]; then export NPM_CONFIG_HTTPS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_13}"; else unset NPM_CONFIG_HTTPS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_14}" ]; then export NPM_CONFIG_HTTP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_14}"; else unset NPM_CONFIG_HTTP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_15}" ]; then export NPM_CONFIG_NOPROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_15}"; else unset NPM_CONFIG_NOPROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_16}" ]; then export NPM_CONFIG_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_16}"; else unset NPM_CONFIG_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_17}" ]; then export PIP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_17}"; else unset PIP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_18}" ]; then export WSS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_18}"; else unset WSS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_19}" ]; then export WS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_19}"; else unset WS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_20}" ]; then export YARN_HTTPS_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_20}"; else unset YARN_HTTPS_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_21}" ]; then export YARN_HTTP_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_21}"; else unset YARN_HTTP_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_22}" ]; then export YARN_NO_PROXY="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_22}"; else unset YARN_NO_PROXY; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_23}" ]; then export all_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_23}"; else unset all_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_24}" ]; then export ftp_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_24}"; else unset ftp_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_25}" ]; then export http_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_25}"; else unset http_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_26}" ]; then export https_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_26}"; else unset https_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_27}" ]; then export no_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_27}"; else unset no_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_28}" ]; then export npm_config_http_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_28}"; else unset npm_config_http_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_29}" ]; then export npm_config_https_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_29}"; else unset npm_config_https_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_30}" ]; then export npm_config_noproxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_30}"; else unset npm_config_noproxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_31}" ]; then export npm_config_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_31}"; else unset npm_config_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_32}" ]; then export ws_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_32}"; else unset ws_proxy; fi if [ -n "${__CODEX_SNAPSHOT_PROXY_OVERRIDE_SET_33}" ]; then export wss_proxy="${__CODEX_SNAPSHOT_PROXY_OVERRIDE_33}"; else unset wss_proxy; fi fi exec '/bin/bash' -c 'pgrep -af exp_logistic_counter_scope_gate.py || true' 2 /bin/bash -c pgrep -af exp_logistic_counter_scope_gate.py || true exec /bin/bash -lc 'ls -l tools/data/reports/agent_20260507_1006.md tools/data/logistic_counter_scope_gate_20260507_1006.json tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json tools/exp_logistic_counter_scope_gate.py' in /opt/MM_D-ND succeeded in 0ms: -rw-r--r-- 1 root root 365777 May 7 10:12 tools/data/logistic_counter_scope_gate_20260507_1006.json -rw-r--r-- 1 root root 283150 May 7 10:12 tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json -rw-r--r-- 1 root root 7172 May 7 10:13 tools/data/reports/agent_20260507_1006.md -rw-r--r-- 1 root root 16620 May 7 10:11 tools/exp_logistic_counter_scope_gate.py exec /bin/bash -lc "python - <<'PY' from pathlib import Path for p in ['tools/data/reports/agent_20260507_1006.md','tools/data/seme.json']: print(p, Path(p).exists(), Path(p).stat().st_size) PY" in /opt/MM_D-ND succeeded in 0ms: tools/data/reports/agent_20260507_1006.md True 7172 tools/data/seme.json True 19826 diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/data/seme.json b/tools/data/seme.json index a02bd96522ef9c8f04ad3bb19c3f42dd0310dbbf..e98b79a9f7c93b3a9574ff4153ce6af0f7d8a2d2 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,5 +1,5 @@ { - "timestamp": "2026-05-07T09:47:22.985377", + "timestamp": "2026-05-07T10:06:00.000000", "piano": 73, "tensioni": [ { @@ -38,12 +38,12 @@ { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", - "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", - "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", "added_at": "2026-05-07T09:01:00+00:00" }, { @@ -178,7 +178,7 @@ "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -346,6 +346,7 @@ } ], "_seed_history": { - "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" } -} \ No newline at end of file +} diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() codex Completato. Ho creato ed eseguito l’esperimento logistic-native: - [tools/exp_logistic_counter_scope_gate.py](/opt/MM_D-ND/tools/exp_logistic_counter_scope_gate.py) - [tools/data/logistic_counter_scope_gate_20260507_1006.json](/opt/MM_D-ND/tools/data/logistic_counter_scope_gate_20260507_1006.json) - [tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json](/opt/MM_D-ND/tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json) Report scritto qui: - [tools/data/reports/agent_20260507_1006.md](/opt/MM_D-ND/tools/data/reports/agent_20260507_1006.md) Risultato sintetico: `logistic_orbit_values` trasferisce il gate su `block_entropy_deficit_k4`; `logistic_symbolic_itinerary` resta blank; `logistic_return_intervals` non replica il supporto nel seed check, quindi resta counter-scope. Ho anche aggiornato [tools/data/seme.json](/opt/MM_D-ND/tools/data/seme.json) con la distinzione emersa e la prossima direzione: surrogate-class split su `logistic_orbit_values` con marginal shuffle, circular shift e block shuffle. Verifiche fatte: `py_compile` sul nuovo tool e validazione JSON del seme. diff --git a/tools/data/reports/agent_20260507_1006.md b/tools/data/reports/agent_20260507_1006.md new file mode 100644 index 0000000000000000000000000000000000000000..477965d703631d7f9722bcbd170a958a409e7656 --- /dev/null +++ b/tools/data/reports/agent_20260507_1006.md @@ -0,0 +1,156 @@ +# Agent Report — Logistic Counter-Scope Gate + +timestamp: 2026-05-07 10:06 UTC +category: gate_falsification_logistic_observability +verdict: scoped_operator_with_counter_scope +observables_registry: not used for canonical observables +observables_native_version: logistic-native-1.0.0-2026-05-07 +observables_used: [block_entropy_deficit_k4, return_tail_alpha, recurrence_diag_mean, recurrence_determinism] +tool: tools/exp_logistic_counter_scope_gate.py +data: tools/data/logistic_counter_scope_gate_20260507_1006.json +seed_check: tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json + +## Claim Under Test + +Verificato dal campo vivo: `ORDER_DENOMINATOR_GATE` trasferisce come supporto +one-sided quando l'ordine e leggibile dagli osservabili canonici del perimetro. +Il contro-scope aperto e `logistic_return_intervals`: nel run 09:23 la suite +canonica `[SR, SR2, L1, L2, triple_var]` ha prodotto blank. + +Domanda regressiva: il blank logistic falsifica il gate o falsifica solo il +contratto osservabile canonico? + +Perimetri: + +- `logistic_orbit_values`: orbita continua della mappa logistica `x -> 4x(1-x)`. +- `logistic_symbolic_itinerary`: partizione simbolica `x > 0.5`. +- `logistic_return_intervals`: intervalli di ritorno a `x > 0.95`. + +Gate invariato: osservabile stabile se +`abs(original - shuffle_mean) / shuffle_std >= 2`. Il null e sempre shuffle +marginal-preserving. `z_min` non viene tunato. + +## Deposito Numerico + +Run principale: `n_values=4096`, `n_returns=4096`, `n_replicates=8`, +`n_beta=11`, `n_baseline=12`, `recurrence_max_points=360`, +`seed=202605071006`. + +Seed check: `n_replicates=6`, `n_baseline=10`, `seed=202605071007`. + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.375 | 1.936 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.000 | 0.750 | 0.000 | [] | +| logistic_return_intervals | recurrence_diag_mean | 1.125 | 0.250 | 1.764 | [] | + +Seed check: + +| perimeter | coherent one-sided observables | stable_count coherent | stable_count illusory | endpoint distance gated | beta ambiguous gated | +|---|---:|---:|---:|---:|---:| +| logistic_orbit_values | block_entropy_deficit_k4 | 1.000 | 0.000 | 1.915 | 0.10 | +| logistic_symbolic_itinerary | [] | 0.167 | 0.167 | 0.000 | [] | +| logistic_return_intervals | [] | 0.000 | 0.167 | 0.000 | [] | + +Endpoint-stable observables: `[]` in all three perimeters in both runs. + +Z means at coherent endpoint: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 707.116 | -0.573 | -0.393 | -0.796 | +| logistic_symbolic_itinerary | -0.062 | -0.758 | -1.265 | -0.500 | +| logistic_return_intervals | 1.479 | 0.000 | 2.539 | -0.371 | + +Seed check coherent z means: + +| perimeter | block_entropy_deficit_k4 | return_tail_alpha | recurrence_diag_mean | recurrence_determinism | +|---|---:|---:|---:|---:| +| logistic_orbit_values | 640.298 | 0.410 | -0.363 | -1.165 | +| logistic_symbolic_itinerary | -1.678 | 0.109 | 0.499 | -0.360 | +| logistic_return_intervals | -0.473 | 0.000 | -1.281 | -1.189 | + +## Risultato + +1. **The logistic blank is an observability split.** + + The continuous logistic orbit carries one-sided support through + `block_entropy_deficit_k4` in both runs. The coherent endpoint stable count + is `1.000`; the illusory endpoint drops from `0.375` in the main run to + `0.000` in the seed check. The denominator gate reads order when the + perimetro is the orbit itself and the observable is native to symbolic block + structure. + +2. **The generating partition remains blank under this gate.** + + `logistic_symbolic_itinerary` has no coherent one-sided observable in either + run. This matches the known Bernoulli character of the `x>0.5` itinerary at + `r=4`: the symbolic stream does not become denominator-supported by changing + from canonical gap observables to this native suite. + +3. **Return intervals stay counter-scope.** + + The main run gives `recurrence_diag_mean` one-sided support on return + intervals, but the seed check removes it. The stable statement is blank: + `logistic_return_intervals` does not carry replicated one-sided denominator + support under this native suite. + +4. **Return-tail exponent is not the missing observable.** + + `return_tail_alpha` has coherent z mean `0.000` on return intervals in both + runs. In this setup it is marginal-dominated under the shuffle null and does + not distinguish the coherent endpoint. + +## Consecutio + +`ORDER_DENOMINATOR_GATE` survives the logistic regression only after splitting +the logistic object: + +> The logistic orbit transfers as one-sided support through native block +> entropy. The Bernoulli itinerary and the high-threshold return intervals +> remain blank under the declared original-vs-shuffle gate. The logistic +> counter-scope is not "logistic dynamics"; it is the return-interval and +> generating-partition perimetro under this observable contract. + +Next experiment: stop extending `ORDER_DENOMINATOR_GATE` by adding more +observables. The remaining useful test is a surrogate-class split for logistic: +compare marginal shuffle against circular shift and block shuffle. If support +appears only against full shuffle, the gate is detecting long-range disruption +of deterministic orbit order; if it survives block/circular surrogates, the +observable binds to local dynamics. + +## Self-Audit: 5 Lenti + +L1 hard constraint vs bias: `endpoint_stable_observables=[]` is exact for the +declared runs. The report does not claim zero illusory support; illusory stable +count is `0.375` for `logistic_orbit_values` in the main run. + +L2 quantity vs ratio: raw stable counts, z means, endpoint distances, and +replication status are reported before interpretation. No percent drift claim is +used. + +L3 no silent patching: 09:23 found blank on logistic return intervals using +canonical observables. This report does not rescue that blank: return intervals +remain blank after seed check. The positive scope is explicitly moved to +`logistic_orbit_values`. + +L4 edge cases: the main-run return-interval support on `recurrence_diag_mean` +does not replicate. It is reported as ambiguous and excluded from the stable +claim. + +L5 re-discovery vs discovery: the blank symbolic itinerary is consistent with +the classical Bernoulli coding of the fully chaotic logistic map. The report +claims operator scope inside the lab protocol, not a new theorem about logistic +dynamics. + +## Fonti + +- Verificato: `tools/data/agent_field_live.md` +- Verificato: `tools/LAB_AGENT_CONTEXT.md` +- Verificato: `tools/exp_logistic_counter_scope_gate.py` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006.json` +- Verificato: `tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json` +- Verificato: `python -m py_compile tools/exp_logistic_counter_scope_gate.py` +- Inferito: the logistic blank is a perimetro split because orbit values show + replicated one-sided support while symbolic itinerary and return intervals do + not. diff --git a/tools/data/seme.json b/tools/data/seme.json index a02bd96522ef9c8f04ad3bb19c3f42dd0310dbbf..e98b79a9f7c93b3a9574ff4153ce6af0f7d8a2d2 --- a/tools/data/seme.json +++ b/tools/data/seme.json @@ -1,5 +1,5 @@ { - "timestamp": "2026-05-07T09:47:22.985377", + "timestamp": "2026-05-07T10:06:00.000000", "piano": 73, "tensioni": [ { @@ -38,12 +38,12 @@ { "tipo": "vincolo", "id": "ORDER_DENOMINATOR_GATE", - "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili canonici del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. La beta 0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", + "claim": "Il denominator gate trasferisce come supporto one-sided dell'ordine quando l'ordine e visibile agli osservabili del perimetro, non come endpoint-stable support a due poli. Nel perimetro sintetico agent_20260507_0901, 4/4 domini non-BOUNDARY hanno endpoint_stable_observables=[] e polo coerente stable_count 3.0-5.0. Nel perimetro semi-reale agent_20260507_0923, primi e zeta trasferiscono (primi: SR,L1,triple_var; zeta: SR,L2), ma logistic_return_intervals e blank: stable_count coerente 0.0-0.2. Nel perimetro bridge agent_20260507_0942, prime_metric_delta_gamma_abs, prime_metric_dR_abs, zeta_trace_residual_step5_abs e hydrogen_bound_level_spacings trasferiscono su tutti i 5 osservabili canonici con endpoint_stable_observables=[]; e supporto perimetro-bridge, non universalita del gate. Nel perimetro logistic-native agent_20260507_1006, logistic_orbit_values trasferisce su block_entropy_deficit_k4 in run e seed check; logistic_symbolic_itinerary resta blank; logistic_return_intervals mostra recurrence_diag_mean solo nel run principale e torna blank nel seed check. La beta 0.10/0.30/0.40/0.50 resta coordinata del protocollo quando compare, non coordinata universale.", "intensita": 0.92, "porta": "META", "manuale": true, "condensato_ref": "A4,A8,A14,C2", - "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, e perimetri bridge metric/trace/QxE", + "origine": "cycle agent_20260507_0901 + agent_20260507_0923 + agent_20260507_0942 + agent_20260507_1006: transfer matrix sintetica, falsificazione semi-reale su primi/zeta/logistic returns, perimetri bridge metric/trace/QxE, e regressione logistic-native", "added_at": "2026-05-07T09:01:00+00:00" }, { @@ -178,7 +178,7 @@ "filtrate": 0, "condensato_claims": 30 }, - "direzione": "Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': usare symbolic itinerary block entropy, return-tail exponent e recurrence-plot diagonal statistics sotto original-vs-shuffle denominator gate, senza tuning di z_min.", + "direzione": "Surrogate-class split per ORDER_DENOMINATOR_GATE su logistic_orbit_values: confrontare marginal shuffle, circular shift e block shuffle con block_entropy_deficit_k4 sotto z_min invariato. Se il supporto appare solo contro full shuffle, il gate legge disruption globale dell'ordine; se sopravvive a circular/block surrogates, lega dinamica locale.", "verifica": { "pass": 11, "fail": 0, @@ -346,6 +346,7 @@ } ], "_seed_history": { - "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'" + "trajectory_apply_20260507_100602": "applied modify_seme from 20260507_0942: direzione → 'Ritestare ORDER_DENOMINATOR_GATE sul counter-scope logistic al nodo regressivo dell'osservabilita': ...'", + "agent_20260507_1006": "updated ORDER_DENOMINATOR_GATE: logistic_orbit_values transfers on native block entropy; symbolic itinerary and return intervals remain blank after seed check; next direction is surrogate-class split" } -} \ No newline at end of file +} diff --git a/tools/exp_logistic_counter_scope_gate.py b/tools/exp_logistic_counter_scope_gate.py new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c5ca349fc2c5064e7a40b47d0342682aa80 --- /dev/null +++ b/tools/exp_logistic_counter_scope_gate.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +exp_logistic_counter_scope_gate.py + +Regressive test for ORDER_DENOMINATOR_GATE on the logistic counter-scope. + +The 09:23 run showed that canonical gap observables do not read denominator +support in logistic return intervals. This tool keeps the same +original-vs-shuffle denominator gate and changes only the observable contract: + +- symbolic block entropy deficit; +- return-tail exponent; +- recurrence-plot diagonal statistics. + +These are logistic-native observables, not aliases of the canonical +SR/SR2/L1/L2/triple_var registry names. +""" + +from __future__ import annotations + +import argparse +import json +import math +from collections import Counter +from pathlib import Path + +import numpy as np + + +OBSERVABLES_NATIVE_VERSION = "logistic-native-1.0.0-2026-05-07" +OBS_NAMES = [ + "block_entropy_deficit_k4", + "return_tail_alpha", + "recurrence_diag_mean", + "recurrence_determinism", +] + + +def normalize(values: np.ndarray) -> np.ndarray: + values = np.asarray(values, dtype=float) + values = values[np.isfinite(values)] + if len(values) == 0: + return values + values = values - float(np.min(values)) + scale = float(np.max(values)) + return values / scale if scale > 1e-15 else values + + +def logistic_orbit(n: int, rng: np.random.Generator, burn: int = 2000) -> np.ndarray: + x = float(rng.random()) + out = np.empty(n, dtype=float) + for i in range(n + burn): + x = 4.0 * x * (1.0 - x) + if i >= burn: + out[i - burn] = x + return out + + +def logistic_symbolic_itinerary(n: int, rng: np.random.Generator) -> np.ndarray: + orbit = logistic_orbit(n, rng) + return (orbit > 0.5).astype(float) + + +def logistic_return_intervals(n: int, rng: np.random.Generator) -> np.ndarray: + threshold = 0.95 + burn = 2000 + returns: list[int] = [] + last_hit: int | None = None + x = float(rng.random()) + i = 0 + max_steps = 50_000_000 + while len(returns) < n and i < max_steps: + x = 4.0 * x * (1.0 - x) + if i >= burn and x > threshold: + if last_hit is not None: + returns.append(i - last_hit) + last_hit = i + i += 1 + if len(returns) < n: + raise RuntimeError(f"logistic generator produced {len(returns)} intervals, need {n}") + return np.array(returns, dtype=float) + + +def quantile_symbols(values: np.ndarray, bins: int) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(np.unique(values)) <= bins: + unique = {value: idx for idx, value in enumerate(sorted(set(values)))} + return np.array([unique[value] for value in values], dtype=int) + qs = np.quantile(values, np.linspace(0.0, 1.0, bins + 1)[1:-1]) + return np.searchsorted(qs, values, side="right").astype(int) + + +def block_entropy_deficit(values: np.ndarray, k: int = 4, bins: int = 4) -> float: + symbols = quantile_symbols(values, bins) + if len(symbols) < k + 1: + return 0.0 + alphabet = max(2, int(np.max(symbols)) + 1) + blocks = [tuple(symbols[i : i + k]) for i in range(len(symbols) - k + 1)] + counts = np.array(list(Counter(blocks).values()), dtype=float) + probs = counts / float(np.sum(counts)) + entropy = -float(np.sum(probs * np.log2(probs))) + max_entropy = k * math.log2(alphabet) + return float(max(0.0, 1.0 - entropy / max_entropy)) if max_entropy > 1e-15 else 0.0 + + +def exceedance_intervals(values: np.ndarray, quantile: float = 0.95) -> np.ndarray: + values = np.asarray(values, dtype=float) + if len(values) < 3: + return np.array([], dtype=float) + threshold = float(np.quantile(values, quantile)) + hits = np.flatnonzero(values >= threshold) + if len(hits) < 3: + return np.array([], dtype=float) + return np.diff(hits).astype(float) + + +def hill_tail_alpha(samples: np.ndarray) -> float: + samples = np.asarray(samples, dtype=float) + samples = samples[np.isfinite(samples) & (samples > 0)] + if len(samples) < 16: + return 0.0 + tail_count = max(8, int(0.20 * len(samples))) + tail = np.sort(samples)[-tail_count:] + xmin = float(tail[0]) + if xmin <= 0: + return 0.0 + denom = float(np.mean(np.log(tail / xmin))) + return float(1.0 / denom) if denom > 1e-15 else 0.0 + + +def return_tail_alpha(values: np.ndarray) -> float: + values = np.asarray(values, dtype=float) + if np.all(values >= 1.0) and len(np.unique(values)) < max(64, len(values) // 2): + intervals = values + else: + intervals = exceedance_intervals(values) + return hill_tail_alpha(intervals) + + +def recurrence_diagonal_stats(values: np.ndarray, max_points: int = 1200, target_rr: float = 0.035) -> tuple[float, float]: + values = normalize(values) + if len(values) > max_points: + idx = np.linspace(0, len(values) - 1, max_points).astype(int) + values = values[idx] + n = len(values) + if n < 16: + return 0.0, 0.0 + + diff = np.abs(values[:, None] - values[None, :]) + upper = diff[np.triu_indices(n, k=1)] + epsilon = float(np.quantile(upper, target_rr)) + rec = diff <= epsilon + np.fill_diagonal(rec, False) + + lengths: list[int] = [] + recurrence_points = int(np.sum(rec)) + diagonal_points = 0 + for offset in range(-(n - 2), n - 1): + diag = np.diagonal(rec, offset=offset) + run = 0 + for item in diag: + if item: + run += 1 + else: + if run >= 2: + lengths.append(run) + diagonal_points += run + run = 0 + if run >= 2: + lengths.append(run) + diagonal_points += run + + if not lengths or recurrence_points == 0: + return 0.0, 0.0 + return float(np.mean(lengths)), float(diagonal_points / recurrence_points) + + +def compute_native(values: np.ndarray, recurrence_max_points: int) -> dict[str, float]: + diag_mean, determinism = recurrence_diagonal_stats(values, max_points=recurrence_max_points) + return { + "block_entropy_deficit_k4": block_entropy_deficit(values), + "return_tail_alpha": return_tail_alpha(values), + "recurrence_diag_mean": diag_mean, + "recurrence_determinism": determinism, + } + + +def beta_replace(base: np.ndarray, beta: float, rng: np.random.Generator) -> np.ndarray: + illusory = rng.permutation(base) + if beta <= 0.0: + return base.copy() + if beta >= 1.0: + return illusory + out = base.copy() + mask = rng.random(len(base)) < beta + out[mask] = illusory[mask] + return out + + +def z_against_shuffle( + values: np.ndarray, + n_baseline: int, + recurrence_max_points: int, + rng: np.random.Generator, +) -> tuple[dict, dict, dict, dict]: + original = compute_native(values, recurrence_max_points) + baseline = {name: [] for name in OBS_NAMES} + for _ in range(n_baseline): + obs = compute_native(rng.permutation(values), recurrence_max_points) + for name in OBS_NAMES: + baseline[name].append(obs[name]) + + means = {} + sds = {} + z = {} + for name in OBS_NAMES: + vals = np.array(baseline[name], dtype=float) + means[name] = float(np.mean(vals)) + sds[name] = float(np.std(vals, ddof=1)) if len(vals) > 1 else 0.0 + z[name] = float((original[name] - means[name]) / sds[name]) if sds[name] > 1e-15 else 0.0 + return original, means, sds, z + + +def vector(row: dict, names: list[str]) -> np.ndarray: + return np.array([row["observables"][name] for name in names], dtype=float) + + +def classify_layers(rows: list[dict], obs_names: list[str]) -> dict: + if not obs_names: + return {"observables": [], "endpoint_distance": 0.0, "layers": {}, "ambiguous_beta": []} + + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + coherent = np.array([vector(row, obs_names) for row in by_beta[0.0]], dtype=float) + illusory = np.array([vector(row, obs_names) for row in by_beta[1.0]], dtype=float) + endpoints = np.vstack([coherent, illusory]) + scale = np.std(endpoints, axis=0, ddof=1) + scale[scale <= 1e-15] = 1.0 + coherent_centroid = np.mean(coherent, axis=0) + illusory_centroid = np.mean(illusory, axis=0) + endpoint_distance = float(np.linalg.norm((illusory_centroid - coherent_centroid) / scale)) + + layers = {} + ambiguous_beta = [] + for beta, beta_rows in sorted(by_beta.items()): + coords = [] + margins = [] + labels = [] + for row in beta_rows: + x = vector(row, obs_names) + d_coherent = float(np.linalg.norm((x - coherent_centroid) / scale)) + d_illusory = float(np.linalg.norm((x - illusory_centroid) / scale)) + denom = d_coherent + d_illusory + coord = float((d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + margin = float(abs(d_coherent - d_illusory) / denom) if denom > 1e-15 else 0.0 + coords.append(coord) + margins.append(margin) + labels.append("coherent" if d_coherent < d_illusory else "illusory") + ambiguous_fraction = float(np.mean(np.array(margins) < 0.15)) + if ambiguous_fraction >= 0.5: + ambiguous_beta.append(beta) + layers[f"{beta:.3f}"] = { + "coordinate_mean": float(np.mean(coords)), + "margin_mean": float(np.mean(margins)), + "ambiguous_fraction": ambiguous_fraction, + "illusory_label_fraction": float(np.mean(np.array(labels) == "illusory")), + } + + return { + "observables": obs_names, + "endpoint_distance": endpoint_distance, + "layers": layers, + "ambiguous_beta": ambiguous_beta, + } + + +def summarize_gate(rows: list[dict], z_min: float) -> dict: + by_beta: dict[float, list[dict]] = {} + for row in rows: + by_beta.setdefault(float(row["beta"]), []).append(row) + + layers = {} + for beta, beta_rows in sorted(by_beta.items()): + stable_counts = [] + stable_freq = {name: [] for name in OBS_NAMES} + z_values = {name: [] for name in OBS_NAMES} + for row in beta_rows: + stable = [name for name in OBS_NAMES if abs(row["z"][name]) >= z_min] + stable_counts.append(len(stable)) + for name in OBS_NAMES: + stable_freq[name].append(1.0 if name in stable else 0.0) + z_values[name].append(row["z"][name]) + layers[f"{beta:.3f}"] = { + "stable_count_mean": float(np.mean(stable_counts)), + "stable_frequency": {name: float(np.mean(vals)) for name, vals in stable_freq.items()}, + "z_mean": {name: float(np.mean(vals)) for name, vals in z_values.items()}, + } + + one_sided = [] + endpoint_stable = [] + coherent_rows = by_beta[0.0] + illusory_rows = by_beta[1.0] + for name in OBS_NAMES: + coherent_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in coherent_rows])) + illusory_freq = float(np.mean([abs(row["z"][name]) >= z_min for row in illusory_rows])) + if coherent_freq >= 0.75 and illusory_freq < 0.25: + one_sided.append(name) + if coherent_freq >= 0.75 and illusory_freq >= 0.75: + endpoint_stable.append(name) + + return { + "z_min": z_min, + "coherent_one_sided_observables": one_sided, + "endpoint_stable_observables": endpoint_stable, + "layers": layers, + } + + +def build_sequences(args: argparse.Namespace, rng: np.random.Generator) -> dict[str, np.ndarray]: + return { + "logistic_orbit_values": logistic_orbit(args.n_values, rng), + "logistic_symbolic_itinerary": logistic_symbolic_itinerary(args.n_values, rng), + "logistic_return_intervals": logistic_return_intervals(args.n_returns, rng), + } + + +def analyze_sequence(name: str, base: np.ndarray, args: argparse.Namespace, rng: np.random.Generator) -> dict: + rows = [] + betas = [float(x) for x in np.linspace(0.0, 1.0, args.n_beta)] + for rep in range(args.n_replicates): + rep_rng = np.random.default_rng(rng.integers(0, 2**63 - 1)) + for beta in betas: + values = beta_replace(base, beta, rep_rng) + obs, shuffle_mean, shuffle_std, z = z_against_shuffle( + values, + args.n_baseline, + args.recurrence_max_points, + np.random.default_rng(rng.integers(0, 2**63 - 1)), + ) + rows.append( + { + "perimeter": name, + "replicate": rep, + "beta": beta, + "observables": obs, + "shuffle_mean": shuffle_mean, + "shuffle_std": shuffle_std, + "z": z, + "stable_observables": [obs_name for obs_name in OBS_NAMES if abs(z[obs_name]) >= args.z_min], + } + ) + gate = summarize_gate(rows, args.z_min) + return { + "source": { + "n": int(len(base)), + "mean": float(np.mean(base)), + "variance": float(np.var(base)), + "unique_values": int(len(np.unique(base))), + }, + "gate": gate, + "classification_all_observables": classify_layers(rows, OBS_NAMES), + "classification_one_sided_gated": classify_layers(rows, gate["coherent_one_sided_observables"]), + "rows": rows, + } + + +def compact(perimeters: dict) -> dict: + out = {} + for name, data in perimeters.items(): + gate = data["gate"] + all_cls = data["classification_all_observables"] + gated_cls = data["classification_one_sided_gated"] + out[name] = { + "n": data["source"]["n"], + "coherent_one_sided_observables": gate["coherent_one_sided_observables"], + "endpoint_stable_observables": gate["endpoint_stable_observables"], + "stable_count_coherent": gate["layers"]["0.000"]["stable_count_mean"], + "stable_count_illusory": gate["layers"]["1.000"]["stable_count_mean"], + "z_mean_coherent": gate["layers"]["0.000"]["z_mean"], + "z_mean_illusory": gate["layers"]["1.000"]["z_mean"], + "endpoint_distance_all": all_cls["endpoint_distance"], + "endpoint_distance_one_sided_gated": gated_cls["endpoint_distance"], + "ambiguous_beta_one_sided_gated": gated_cls["ambiguous_beta"], + } + return out + + +def run(args: argparse.Namespace) -> dict: + root_rng = np.random.default_rng(args.seed) + sequences = build_sequences(args, root_rng) + perimeters = {} + for name, base in sequences.items(): + perimeters[name] = analyze_sequence(name, base, args, root_rng) + + output = { + "experiment": "logistic_counter_scope_gate", + "category": "gate_falsification_logistic_observability", + "question": "Does the logistic counter-scope stay blank under logistic-native observables?", + "observables_native_version": OBSERVABLES_NATIVE_VERSION, + "observables_used": OBS_NAMES, + "params": vars(args), + "matrix": compact(perimeters), + "perimeters": perimeters, + } + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + with out_path.open("w") as f: + json.dump(output, f, indent=2) + + print(f"observables_native_version={OBSERVABLES_NATIVE_VERSION}") + print(f"observables_used={OBS_NAMES}") + print("perimeter n one_sided stable0 stable1 dist_gate ambiguous_gate") + for name, row in output["matrix"].items(): + print( + f"{name:>29s} " + f"{row['n']:>5d} " + f"{','.join(row['coherent_one_sided_observables']) or '[]':>55s} " + f"{row['stable_count_coherent']:>7.3f} " + f"{row['stable_count_illusory']:>7.3f} " + f"{row['endpoint_distance_one_sided_gated']:>9.3f} " + f"{row['ambiguous_beta_one_sided_gated']}" + ) + print(f"saved {out_path}") + return output + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--n-values", type=int, default=4096) + parser.add_argument("--n-returns", type=int, default=4096) + parser.add_argument("--n-replicates", type=int, default=12) + parser.add_argument("--n-beta", type=int, default=11) + parser.add_argument("--n-baseline", type=int, default=24) + parser.add_argument("--recurrence-max-points", type=int, default=360) + parser.add_argument("--z-min", type=float, default=2.0) + parser.add_argument("--seed", type=int, default=202605071006) + parser.add_argument("--out", default="tools/data/logistic_counter_scope_gate_20260507_1006.json") + args = parser.parse_args() + run(args) + + +if __name__ == "__main__": + main() tokens used 204,967 Completato. Ho creato ed eseguito l’esperimento logistic-native: - [tools/exp_logistic_counter_scope_gate.py](/opt/MM_D-ND/tools/exp_logistic_counter_scope_gate.py) - [tools/data/logistic_counter_scope_gate_20260507_1006.json](/opt/MM_D-ND/tools/data/logistic_counter_scope_gate_20260507_1006.json) - [tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json](/opt/MM_D-ND/tools/data/logistic_counter_scope_gate_20260507_1006_seedcheck.json) Report scritto qui: - [tools/data/reports/agent_20260507_1006.md](/opt/MM_D-ND/tools/data/reports/agent_20260507_1006.md) Risultato sintetico: `logistic_orbit_values` trasferisce il gate su `block_entropy_deficit_k4`; `logistic_symbolic_itinerary` resta blank; `logistic_return_intervals` non replica il supporto nel seed check, quindi resta counter-scope. Ho anche aggiornato [tools/data/seme.json](/opt/MM_D-ND/tools/data/seme.json) con la distinzione emersa e la prossima direzione: surrogate-class split su `logistic_orbit_values` con marginal shuffle, circular shift e block shuffle. Verifiche fatte: `py_compile` sul nuovo tool e validazione JSON del seme.