# Agent Report - Supertile Tiling Gate Del Core Phi
**Date**: 2026-05-08 19:09
**Piano**: 89
**Tension explored**: M_trascendenza_limite_attuale_L0 (0.529179606750063)
**verdict**: CONSTRAINT
observables_registry: n/a
observables_used: [gap_label_set, supertile_boundary, length_multiset, internal_order, high_label_condition_rate]
**observable_contract**: claim=il core alto phi distingue confine di supertile Fibonacci da blocco contiguo con stessa lunghezza; observable=retention dei label core sotto shuffle di supertile, shuffle contiguo a stessa multiset di lunghezze, shuffle interno a stesso conteggio; operator=Hamiltoniana tight-binding V=1, label IDS con reader theta=1/phi, Jaccard/retention/frequenza per mode e supertile_order; generator=phi_sturmian con tiling di lunghezze Fibonacci; denominator=N={377,610}, phase={0,0.25,0.5,0.75}, threshold={2.0}, trials=5, top_k=12, |n|<=34, supertile_order={8,9,10,11}; not_tested=gap_ratio, soglie 1.75/2.25, parsing simbolico esatto dei supertile per ogni fase, generatori non-phi.

## Respiro fuori-tempo
- **Combo**: A11 combo + TxQ matrice densita come lettore spettrale + QxG vuoto continuo/discreto + tensione TRASCENDENZA_LIMITE/M_come_modulazione_quasiperiodica.
- **Dipolo / punto-zero**: confine reale del supertile · lunghezza contigua equivalente; punto-zero = il blocco come unita' prima che diventi grammatica o contenitore.
- **Piano superiore**: grafo della conoscenza / bicono dei dipoli. Il nodo non e' il valore del gap, ma il passaggio fra grammatica interna, confine esterno e denominatore.
- **Proto-ipotesi**: se il core alto phi vive nel confine tra supertile, lo shuffle di supertile conserva piu' core dello shuffle contiguo con la stessa multiset di lunghezze. Se non lo fa, il confine esatto non e' ancora il portatore: il portatore e' ordine interno piu' scala lunga.
- **Proiezione**: il label-set dei gap larghi manifesta la combo perche' tiene fisso il reader theta=1/phi e muove solo la relazione fra grammatica, boundary e blocco.

## Claim Under Test
> Il vantaggio del blocco Fibonacci lungo non sta solo nell'ordine interno conservato: sta nel confine reale del supertile. Quindi `supertile_shuffle` batte `same_length_contiguous_shuffle` a pari multiset di lunghezze.

## Question
Il core alto `[3, -4, 4, 6]` riconosce il confine di supertile Fibonacci, o riconosce soltanto blocchi lunghi con ordine interno conservato?

## Experiment Design
- Reference core phi: `[-1, 1, -2, 2, 3, -4, 4, 6]`.
- Nucleo basso: `[-1, 1, -2, 2]`. Label alti: `[3, -4, 4, 6]`.
- Supertile orders:
  - order 8: lunghezze `{21,34}`.
  - order 9: lunghezze `{34,55}`.
  - order 10: lunghezze `{55,89}`.
  - order 11: lunghezze `{89,144}`.
- Modes:
  - `supertile_shuffle`: taglia secondo la parola di lunghezze Fibonacci e mescola i chunk.
  - `same_length_contiguous_shuffle`: usa la stessa multiset di lunghezze, ma su taglio contiguo misallineato.
  - `same_count_internal_shuffle`: conserva lunghezza e conteggio di ogni chunk allineato, ma distrugge ordine interno.
  - `same_mean_block_shuffle`: usa un blocco fisso pari alla lunghezza media del tiling, controllo di scala grossolana.
- Denominatori grezzi: per ogni `mode|order`, 40 condizioni (`2 N * 4 phase * 1 threshold * 5 trials`); per ogni mode aggregato, 160 condizioni.

## Results
Reference phi su 8 condizioni (`N x phase x threshold`): core completo `[-1, 1, -2, 2, 3, -4, 4, 6]`.

Sintesi per mode:

| mode | conditions | median Jaccard | low retention | high retention | all-high condition rate |
|---|---:|---:|---:|---:|---:|
| supertile_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 108/160 = 0.67500 |
| same_length_contiguous_shuffle | 160 | 0.818182 | 1.00 | 1.00 | 116/160 = 0.72500 |
| same_count_internal_shuffle | 160 | 0.157895 | 0.25 | 0.25 | 0/160 = 0.00000 |
| same_mean_block_shuffle | 160 | 0.500000 | 1.00 | 0.25 | 7/160 = 0.04375 |

Dettaglio per order:

| mode | order | lengths | median Jaccard | low retention | high retention | all-high condition rate | stable labels 75% |
|---|---:|---|---:|---:|---:|---:|---|
| supertile_shuffle | 8 | {21,34} | 0.750000 | 1.00 | 0.75 | 14/40 = 0.350 | [-1, 1, -2, 2, -3, -4, 4] |
| same_length_contiguous_shuffle | 8 | {21,34} | 0.818182 | 1.00 | 0.875 | 20/40 = 0.500 | [-1, 1, -2, 2, -3, 3, -4, 4] |
| same_mean_block_shuffle | 8 | mean 29 | 0.444444 | 0.75 | 0.00 | 0/40 = 0.000 | [-1, 1, 33] |
| same_count_internal_shuffle | 8 | {21,34} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] |
| supertile_shuffle | 9 | {34,55} | 0.904545 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, -6] |
| same_length_contiguous_shuffle | 9 | {34,55} | 0.818182 | 1.00 | 1.00 | 29/40 = 0.725 | [-1, 1, -2, 2, -3, 3, -4, 4, 6] |
| same_mean_block_shuffle | 9 | mean 45 | 0.500000 | 1.00 | 0.25 | 0/40 = 0.000 | [-1, 1, -2] |
| same_count_internal_shuffle | 9 | {34,55} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] |
| supertile_shuffle | 10 | {55,89} | 0.909091 | 1.00 | 1.00 | 32/40 = 0.800 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6, -7] |
| same_length_contiguous_shuffle | 10 | {55,89} | 0.833333 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] |
| same_mean_block_shuffle | 10 | mean 75 | 0.666667 | 1.00 | 0.50 | 1/40 = 0.025 | [-1, 1, -2, 2, -4, 4] |
| same_count_internal_shuffle | 10 | {55,89} | 0.150000 | 0.25 | 0.25 | 0/40 = 0.000 | [] |
| supertile_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 33/40 = 0.825 | [-1, 1, -2, 2, -3, 3, -4, 4, 6, -7] |
| same_length_contiguous_shuffle | 11 | {89,144} | 0.909091 | 1.00 | 1.00 | 34/40 = 0.850 | [-1, 1, -2, 2, -3, 3, -4, 4, -6, 6] |
| same_mean_block_shuffle | 11 | mean 122 | 0.666667 | 1.00 | 0.75 | 6/40 = 0.150 | [-1, 1, -2, 2, -4, 4] |
| same_count_internal_shuffle | 11 | {89,144} | 0.157895 | 0.25 | 0.25 | 0/40 = 0.000 | [34] |

## Key Findings
1. **Verificato: il confine di supertile non batte il blocco contiguo a pari multiset di lunghezze.** `supertile_shuffle` fa all-high `108/160 = 0.675`; `same_length_contiguous_shuffle` fa `116/160 = 0.725`. Per order 9 sono pari (`29/40`), per order 10-11 il controllo contiguo e' leggermente sopra (`33/40`, `34/40` contro `32/40`, `33/40`).

2. **Verificato: la condizione forte resta l'ordine interno.** `same_count_internal_shuffle` resta nullo su tutti gli order: all-high `0/160`, high retention mediana `0.25`, Jaccard mediano `0.157895`. Questo replica il nodo 18:34 dentro il tiling di supertile.

3. **Verificato: la scala lunga come multiset e' piu' informativa del blocco medio fisso.** `same_mean_block_shuffle` conserva low retention mediana `1.00`, ma resta quasi nullo sul core alto completo (`7/160 = 0.04375`). Quindi non basta una scala media lunga; serve una distribuzione di lunghezze lunghe con ordine interno conservato.

4. **Inferito dal confronto fra controlli: il portatore osservato e' ordine interno + multiset di lunghezze Fibonacci, non boundary esatto.** Il test non autorizza "il core alto vive nel confine del supertile"; autorizza "il core alto richiede ordine interno e beneficia di lunghezze supertile-like".

## Verdict
**CONSTRAINT on TRASCENDENZA_LIMITE / QPG_GAP_RATIO_DENOMINATOR_GATE**: nel perimetro `N={377,610}`, `phase={0,0.25,0.5,0.75}`, `threshold={2.0}`, `trials=5`, `top_k=12`, `|n|<=34`, `supertile_order={8,9,10,11}`, il core alto phi non discrimina il confine esatto del supertile. `same_length_contiguous_shuffle` conserva il core alto almeno quanto `supertile_shuffle` (`116/160` vs `108/160`). Il core alto cade solo quando l'ordine interno viene distrutto (`0/160`) o quando la multiset di lunghezze viene compressa a blocco medio (`7/160`).

La formulazione valida e': il label-set alto phi misura una condizione congiunta di ordine interno e lunghezze Fibonacci-like; non misura ancora il boundary simbolico del supertile e non misura `gap_ratio`.

## Bicono della scoperta
- **Due radici**: confine di supertile · distribuzione di lunghezze con ordine interno.
- **Singolare**: il chunk lungo prima della distinzione fra boundary grammaticale e blocco contiguo.
- **Invariante di passaggio**: il core alto sopravvive quando l'ordine interno resta leggibile su lunghezze Fibonacci-like; non sopravvive a conteggio senza ordine.
- **Campo di possibilita**: qui diventa possibile cercare un osservabile di boundary piu' fine del label-set; qui diventa non-possibile dichiarare che il label-set alto riconosce da solo il confine esatto del supertile.

## Consecutio
Costruire un gate di boundary simbolico che non legga solo il set dei label: confrontare label-set, posizione IDS dei label core e errore di label per chunk aligned/misaligned. Se il boundary reale esiste nell'osservabile, deve apparire nella geometria degli errori o nella posizione dei gap, non nel solo all-high rate.

## Auto-audit: 5 lenti
- **L1 hard constraint vs bias**: il verdict dichiara perimetro e count grezzi; non trasforma `108/160` in legge universale.
- **L2 quantita vs ratio**: Jaccard, retention e all-high rate restano separati; `gap_ratio` dichiarato non testato.
- **L3 no silent patching**: l'ipotesi "supertile batte contiguo" cade; il report non la salva cambiando osservabile.
- **L4 edge cases**: order 10-11 mostrano controllo contiguo sopra supertile; sono il segnale, non rumore.
- **L5 re-discovery**: la conservazione dell'ordine interno era gia' nota dal 18:34; il nuovo finding e' la non-discriminazione del boundary esatto da parte del label-set.

## Files
- Script: `tools/exp_gap_label_supertile_tiling_gate.py`
- Data: `tools/data/gap_label_supertile_tiling_gate_20260508_1909.json`
- Report: `tools/data/reports/agent_20260508_1909.md`