dense-armor 1.0.0__py3-none-any.whl

dense_armor/__init__.py

@@ -0,0 +1,6 @@
+"""Dense-Armor - the wearable Sentinel shield: two-stage anomaly damping for any AI.
+Author: Salvatore Pennacchio (Napoli, 2026). Sister project: Dense-Evolution."""
+from .armatura import Armatura
+
+__version__ = "1.0.0"
+__all__ = ["Armatura"]

dense_armor/__main__.py

@@ -0,0 +1,3 @@
+from .armatura import main
+
+main()

dense_armor/armatura.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""
+armatura.py — L'ARMATURA: istanza indossabile dello scudo Sentinel.
+Versione standalone: usa i core/ e utility/ di QUESTA cartella (shield_),
+nessuna dipendenza da BERT o da altri progetti.
+
+Uso rapido (PowerShell, da questa cartella):
+    python armatura.py 1.2 1.3 9999 1.25 nan 1.3
+    python armatura.py file_con_numeri.txt
+
+Uso da codice (qualsiasi IA):
+    from armatura import Armatura
+    a = Armatura(livello_ia=0.0)        # 0=IA neonata (FILTRA) ... 1=matura (solo MARCA)
+    pulito, K, anomalie = a.analizza(serie)
+    pulito, K, anomalie = a.analizza(serie_oggi, riferimento=baseline_di_ieri)  # anti-deriva
+"""
+import os
+import sys
+
+
+import numpy as np
+import jax.numpy as jnp
+
+from .core.engine import AdaptiveSignalStabilizer   # scudo originale, intatto
+from .utility.collatz import ABCollatz               # scudo originale, intatto
+from .utility.metro import Metro                     # scaler anti-underflow, intatto
+
+
+class Armatura:
+    """Scudo indossabile con CLIP DINAMICO universale.
+
+    livello_ia (0..1): quanto e' matura l'IA che lo indossa.
+      0.0 -> clip pieno: lo scudo FILTRA il dato (corazza per IA neonata)
+      1.0 -> clip zero:  lo scudo NON tocca il dato, solo MARCA (lente per IA matura)
+    PAVIMENTO: la marcatura delle anomalie non viene MAI clippata — a nessun
+    livello lo scudo tace (l'anomalia puo' ESSERE la risposta: mai cancellarla
+    in silenzio). Il livello puo' essere misurato, non dichiarato:
+    Armatura.livello_da_entropia(entropia, vocab_size).
+
+    MEMORIA: lo scudo e' una funzione PURA, senza stato (leggero per design).
+    La memoria appartiene all'IA che lo indossa: per vedere la DERIVA LENTA
+    passa la tua baseline storica come `riferimento`.
+    """
+
+    def __init__(self, static_threshold=0.15, initial_damping=0.85, alpha=0.05,
+                 soglia_anomalia=None, livello_ia=1.0):
+        self.stab = AdaptiveSignalStabilizer(static_threshold=static_threshold,
+                                             initial_damping=initial_damping, alpha=alpha)
+        self.shield = ABCollatz(epsilon_target=1.0)
+        self.soglia = soglia_anomalia
+        self.livello_ia = float(min(1.0, max(0.0, livello_ia)))
+
+    def set_livello(self, livello):
+        """Aggiorna il livello dell'IA (0=debole -> filtra; 1=matura -> marca)."""
+        self.livello_ia = float(min(1.0, max(0.0, livello)))
+
+    @staticmethod
+    def livello_da_entropia(entropia, vocab_size):
+        """Livello MISURATO: 1 - entropia/log(V) (stessa formula dello sfogo dinamico)."""
+        import math
+        return max(0.0, min(1.0, 1.0 - entropia / (math.log(max(2, vocab_size)) + 1e-12)))
+
+    def analizza(self, serie, riferimento=None):
+        """serie: 1D (lista/array). Per tensori N-D: passare tensore.ravel()
+        e rifare reshape dopo (lo scudo e' agnostico: la trasposizione basta).
+        Ritorna (pulito, K, indici_anomalie)."""
+        s = np.asarray(serie, dtype=np.float64).reshape(1, -1)
+        s_jnp = jnp.array(s)
+
+        f1 = self.stab.filter_batch_scenarios(s_jnp)          # Stadio 1
+        f1 = jnp.where(jnp.isnan(f1), jnp.nan_to_num(s_jnp), f1)
+        if riferimento is not None:
+            rif = jnp.array(np.asarray(riferimento, dtype=np.float64).reshape(1, -1))
+        else:
+            # riferimento cieco = smoothing pesante (pattern SentinelCV2D):
+            # mediana mobile immune agli spike, bersaglio per lo Stadio 2
+            v = np.array(f1).ravel()
+            n = v.size
+            rif_np = np.empty(n)
+            for _i in range(n):
+                a, b = max(0, _i - 3), min(n, _i + 4)
+                rif_np[_i] = np.median(v[a:b])
+            rif = jnp.array(rif_np.reshape(1, -1))
+        gt = self.shield.compute_damping_gating(f1, rif)      # Stadio 2
+        gt = jnp.where(jnp.isnan(gt), 0.85, gt)
+
+        # PERCEZIONE a K pieno (pavimento: mai clippata)
+        K = np.array(gt).ravel()
+        pulito_pieno = np.array(f1 - gt * (f1 - rif)).ravel()
+        # INTERVENTO clippato dal livello dell'IA
+        clip = 1.0 - self.livello_ia
+        pulito = np.array(f1 - (gt * clip) * (f1 - rif)).ravel()
+
+        grezza = s.ravel()
+        dev = np.abs(np.nan_to_num(grezza) - pulito_pieno)
+        soglia = self.soglia if self.soglia is not None else (dev.mean() + 2.0 * dev.std())
+        anomalie = set(int(i) for i in np.where(dev > max(soglia, 1e-12))[0])
+
+        # rilevatore robusto (mediana/MAD) per gli spike che lo Stadio 1 insegue
+        finiti = grezza[np.isfinite(grezza)]
+        if finiti.size >= 4:
+            med = float(np.median(finiti))
+            mad = float(np.median(np.abs(finiti - med))) or 1e-12
+            z_rob = np.abs((np.nan_to_num(grezza, nan=med) - med) / (1.4826 * mad))
+            anomalie |= set(int(i) for i in np.where(z_rob > 6.0)[0])
+
+        anomalie |= {int(i) for i in np.where(~np.isfinite(grezza))[0]}
+        return pulito, K, sorted(anomalie)
+
+    def deriva(self, serie):
+        """RILEVATORE DI DERIVA LENTA (usa METRO, come suggerito da Salvatore).
+
+        La rana bollita: incrementi infinitesimi (es. +0.004/passo) invisibili
+        allo scudo punto-per-punto. Qui si guarda la TENDENZA degli incrementi:
+        se la loro media e' sistematica rispetto al rumore, c'e' deriva — e
+        METRO (scaler logaritmico) ne risolve la scala anche quando e' sotto
+        la precisione visibile. Funziona SENZA baseline storica (ma la baseline
+        via `riferimento` in analizza() resta il metodo piu' forte).
+
+        Ritorna (tasso_per_passo, significativa: bool, esponente_metro).
+        """
+        v = np.asarray(serie, dtype=np.float64).ravel()
+        v = v[np.isfinite(v)]
+        if v.size < 9:
+            return 0.0, False, 0.0
+        # la firma della deriva e' lo SPOSTAMENTO CUMULATIVO: mediana del primo
+        # terzo vs mediana dell'ultimo terzo (robusto agli spike), confrontato
+        # col rumore della serie. Gli incrementi singoli restano nel rumore —
+        # e' la somma che tradisce la rana.
+        terzo = v.size // 3
+        med_inizio = float(np.median(v[:terzo]))
+        med_fine = float(np.median(v[-terzo:]))
+        spostamento = med_fine - med_inizio
+        tasso = spostamento / max(1, v.size - terzo)
+        mad_serie = float(np.median(np.abs(v - np.median(v)))) or 1e-12
+        rumore_mediane = 1.4826 * mad_serie / np.sqrt(terzo)
+        significativa = abs(spostamento) > 3.0 * rumore_mediane
+        # METRO: risolve la scala dell'infinitesimo (leggibile anche a 1e-12)
+        _v_new, fact = Metro().enc(abs(tasso))
+        esponente = float(np.log10(fact)) - (-4.0) if fact > 0 else 0.0  # = -log10(|tasso|)
+        return tasso, bool(significativa), esponente
+
+    def referto_json(self, serie, nome="serie", riferimento=None):
+        """Referto MACCHINA-LEGGIBILE (dict pronto per json.dumps).
+        Pensato per IA e altri programmi: niente prosa, solo dati.
+        I valori non finiti diventano stringhe ("NaN") per dare JSON valido."""
+        pulito, K, anomalie = self.analizza(serie, riferimento)
+        s = np.asarray(serie, dtype=np.float64).ravel()
+        tasso, sig, esp = self.deriva(serie)
+        def _num(v):
+            return float(v) if np.isfinite(v) else "NaN"
+        return {
+            "nome": nome,
+            "punti": int(s.size),
+            "livello_ia": self.livello_ia,
+            "anomalie": [{"indice": int(i), "grezzo": _num(s[i]),
+                          "pulito": _num(pulito[i]), "K": _num(K[i])} for i in anomalie],
+            "K_medio": _num(np.mean(K)),
+            "deriva": {"tasso_per_passo": _num(tasso), "significativa": bool(sig),
+                       "esponente_metro": _num(esp)},
+        }
+
+    def referto(self, serie, nome="serie", riferimento=None):
+        """Analisi + referto leggibile."""
+        pulito, K, anomalie = self.analizza(serie, riferimento)
+        s = np.asarray(serie, dtype=np.float64).ravel()
+        print(f"[ARMATURA] {nome}: {len(s)} punti | livello IA {self.livello_ia:.2f} | anomalie: {len(anomalie)}")
+        for i in anomalie[:10]:
+            print(f"   -> indice {i}: valore {s[i]!r} (pulito: {pulito[i]:.4f}, K={K[i]:.3f})")
+        if len(anomalie) > 10:
+            print(f"   ... e altre {len(anomalie) - 10}")
+        tasso, sig, esp = self.deriva(serie)
+        if sig:
+            print(f"   ⚠ DERIVA LENTA rilevata (Metro): {tasso:+.2e} per passo (scala 10^-{esp:.1f})")
+        return anomalie
+
+
+def main():
+    import re as _re
+    argv = sys.argv[1:]
+    come_json = "--json" in argv
+    argv = [a for a in argv if a != "--json"]
+    if not argv:
+        print("USO: python armatura.py [--json] <file_con_numeri>  oppure  python armatura.py [--json] n1 n2 n3 ...")
+        sys.exit(0)
+    if len(argv) == 1 and os.path.exists(argv[0]):
+        testo = open(argv[0], encoding="utf-8", errors="ignore").read()
+        numeri = [float(x) if x.lower() != "nan" else float("nan")
+                  for x in _re.findall(r"[-+]?(?:\d+\.?\d*(?:[eE][-+]?\d+)?|nan|NaN)", testo)]
+        nome = os.path.basename(argv[0])
+    else:
+        numeri = [float(x) if x.lower() != "nan" else float("nan") for x in argv]
+        nome = "serie da riga di comando"
+    if come_json:
+        import json as _json
+        print(_json.dumps(Armatura().referto_json(numeri, nome), ensure_ascii=False))
+    else:
+        Armatura().referto(numeri, nome)
+
+
+if __name__ == "__main__":
+    main()

dense_armor/core/chunk.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+"""core/chunk.py.
+
+===============================================================================
+SENTINEL ENTERPRISE CHUNKER: SPAZIALE, QUANTISTICO & BEAST MODE OPTIMIZATION
+===============================================================================
+Modulo per la segmentazione di batch d'immagini e l'esecuzione cached XLA
+delle ricette di compilazione senza overhead o ricompilazioni JIT.
+"""
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+
+class ImageChunker:
+    """Gestore avanzato di chunking per tensori d'immagine e ricette JIT.
+
+    Risolve i colli di bottiglia della memoria XLA/JAX sia dividendo i grandi
+    batch di dati, sia spezzando le liste di istruzioni lunghe in blocchi a
+    dimensione fissa.
+    """
+
+    def __init__(self, chunk_size: int = 128) -> None:
+        self.chunk_size = int(chunk_size)
+
+    # ── SEZIONE SPAZIALE FOTO/BATCH (Per test21.py e main.py) ───────────────
+
+    def split_array(self, array: np.ndarray) -> list:
+        """Spezza un array multidimensionale in una lista di sotto-chunk."""
+        total_samples = array.shape[0]
+        num_chunks = int(np.ceil(total_samples / self.chunk_size))
+        chunks = []
+        for b in range(num_chunks):
+            start_idx = b * self.chunk_size
+            end_idx = min(start_idx + self.chunk_size, total_samples)
+            chunks.append(array[start_idx:end_idx])
+        return chunks
+
+    def merge_chunks(self, chunks_list: list) -> np.ndarray:
+        """Ricombina una lista di sotto-chunk in un unico array compatto."""
+        if not chunks_list:
+            return np.array([], dtype=np.float32)
+        # Se l'input è monodimensionale flat, usa concatenate invece di vstack
+        if chunks_list[0].ndim == 1:
+            return np.concatenate(chunks_list)
+        return np.vstack(chunks_list)
+
+    # ── SEZIONE BEAST MODE COMPILER (Estratta dalla logica quantistica) ─────
+
+    def execute_pipeline_beast_mode(
+        self, codegen_engine, input_vector: np.ndarray, compiled_ops: list
+    ) -> np.ndarray:
+        """Esegue le istruzioni del compilatore a blocchi fissi (chunk_size).
+
+        Trapianto logico di 'run_circuit_with_chunking'. Impedisce a XLA di
+        ricompilare la ricetta IA se cambia il numero di istruzioni.
+        """
+        output = jnp.array(input_vector, dtype=jnp.float64)
+
+        # Spezza ed esegue la lista di comandi/operazioni
+        for i in range(0, len(compiled_ops), self.chunk_size):
+            chunk_ops = compiled_ops[i : i + self.chunk_size]
+            output = codegen_engine.run_pipeline_with_chunking(
+                output, chunk_ops, chunk_size=self.chunk_size
+            )
+
+        return np.array(output, dtype=np.float64)
+
+    @staticmethod
+    def patch_and_scan_parameters(
+        template_ops: jnp.ndarray, dynamic_parameters: jnp.ndarray
+    ) -> jnp.ndarray:
+        """Iniezione dinamica di parametri e pesi in un ciclo nativo JAX JIT.
+
+        Trapianto logico di 'patch_and_apply' tramite jax.lax.scan. Rileva i
+        punti di iniezione contrassegnati dal marcatore -1.0.
+        """
+
+        def patch_single_op(carry, op):
+            idx = carry
+            # Se rileva lo slot parametrico quantistico/lineare attivo (-1.0)
+            is_parametric = op == -1.0
+            final_param = jnp.where(is_parametric, dynamic_parameters[idx], op)
+            next_idx = jnp.where(is_parametric, idx + jnp.int32(1), idx)
+
+            # Restituisce l'operazione patchata a basso livello XLA
+            patched_op = jnp.array(
+                [op, op, op, final_param], dtype=jnp.float64
+            )
+            return next_idx, patched_op
+
+        _, patched_compiled_ops = jax.lax.scan(
+            patch_single_op, jnp.int32(0), template_ops
+        )
+        return patched_compiled_ops

dense_armor/core/compiler.py

@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+"""
+core/compiler.py
+==============================
+DynamicAICodegen — compila ricette testuali in pipeline JAX eseguibili.
+
+Fix applicati
+-------------
+- BILANCIAMENTO AUREO: Integrazione dei poli di accoppiamento basati sulla costante PHI.
+- INTEGRITÀ XLA: Tipi forzati lato CPU per prevenire eccezioni sui file binari (.bin).
+"""
+
+import os
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+# =========================================================================
+# ANCORAGGIO GEOMETRICO E BAKING DELLO SPETTRO (XLA BINARY SAFE)
+# =========================================================================
+_PHI_128   = np.longdouble(1.0 + np.sqrt(5.0)) / 2.0
+_PHI       = float(_PHI_128)
+_ALPHA     = float(0.25)
+_PHI_FOUR  = float(_PHI_128 ** 4)  # Moltiplicatore topologico della barriera (~6.854)
+
+# ── Mappa comandi → branch index (contigui 0-N per lax.switch) ───────────────
+CMD_MAP = {
+    'identity':    0,
+    'relu':        1,
+    'sigmoid':     2,
+    'tanh':        3,
+    'scale':       4,
+    'dropout':     5,
+    'clip':        6,
+    'l2_normalize':7,
+}
+_N_BRANCHES = 8
+
+
+# ── step JIT ─────────────────────────────────────────────────────────────────
+
+@jax.jit
+def _execute_ai_instruction_step(carry, instruction: jnp.ndarray):
+    """
+    Esegue un singolo passo della pipeline AI su JAX.
+    carry      = (data_vector, prng_key)
+    instruction = [cmd_id, p1, p2, _reserved]
+    """
+    data, prng_key = carry
+    cmd_id = instruction[0].astype(jnp.int32)
+    p1, p2 = instruction[1], instruction[2]
+
+    # ── Branch helpers ────────────────────────────────────────────────────────
+    def _identity(args):
+        d, _p1, _p2, _k = args
+        return d, _k
+
+    def _relu(args):
+        d, _p1, _p2, _k = args
+        return jnp.maximum(0.0, d), _k
+
+    def _sigmoid(args):
+        d, _p1, _p2, _k = args
+        return jax.nn.sigmoid(d), _k
+
+    def _tanh(args):
+        d, _p1, _p2, _k = args
+        return jnp.tanh(d), _k
+
+    def _scale(args):
+        d, _p1, _p2, _k = args
+        return d * _p1 + _p2, _k
+
+    def _dropout(args):
+        d, _p1, _p2, _k = args
+        next_k, subkey = jax.random.split(_k)
+        safe_p1 = jnp.where(_p1 > 0.0, _p1, 1.0)
+        mask    = jax.random.bernoulli(subkey, p=safe_p1, shape=d.shape)
+        return jnp.where(mask, d / safe_p1, 0.0), next_k
+
+    def _clip(args):
+        d, _p1, _p2, _k = args
+        return jnp.clip(d, _p1, _p2), _k
+
+    def _l2_normalize(args):
+        d, _p1, _p2, _k = args
+        norm     = jnp.linalg.norm(d)
+        safe_n   = jnp.where(norm > 0.0, norm, 1.0)
+        return d / safe_n, _k
+
+    branches = [_identity, _relu, _sigmoid, _tanh, _scale, _dropout, _clip, _l2_normalize]
+
+    safe_cmd = jnp.clip(cmd_id, 0, _N_BRANCHES - 1)
+    result, next_key = jax.lax.switch(safe_cmd, branches, (data, p1, p2, prng_key))
+
+    return (result, next_key), None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# DynamicAICodegen (Inizio Classe)
+# ─────────────────────────────────────────────────────────────────────────────
+
+class DynamicAICodegen:
+    """
+    Compila ricette testuali in matrici di istruzioni JAX ed esegue pipeline
+    con chunking Anti-OOM e calcolo del gradiente via JAX AD.
+    """
+
+    def __init__(self, seed: int = 42):
+        self.cmd_map  = CMD_MAP
+        self.base_key = jax.random.PRNGKey(seed)
+
+    # ── Compilazione ──────────────────────────────────────────────────────────
+
+    def compile_pipeline(self, text_instructions: list) -> np.ndarray:
+        """
+        Converte una lista di istruzioni testuali/tuple in matrice float64
+        di shape (N, 4): [cmd_id, p1, p2, reserved].
+        """
+        compiled = []
+        for cmd in text_instructions:
+            if isinstance(cmd, tuple):
+                name = str(cmd[0]).lower().strip()
+                p1   = float(cmd[1]) if len(cmd) > 1 else 0.0
+                p2   = float(cmd[2]) if len(cmd) > 2 else 0.0
+            else:
+                name = str(cmd).lower().strip()
+                if name == 'dropout':
+                    p1, p2 = 0.8, 0.0
+                elif name == 'clip':
+                    p1, p2 = -1.0, 1.0
+                elif name == 'scale':
+                    p1, p2 = float(_PHI), float(_ALPHA) # <-- Sintonizzazione d'Asse Geometrica
+                else:
+                    p1, p2 = 0.0, 0.0
+
+            cmd_id = self.cmd_map.get(name, 0)
+            compiled.append([float(cmd_id), p1, p2, 0.0])
+
+        return np.array(compiled, dtype=np.float64)
+
+    # ── Esecuzione dinamica ───────────────────────────────────────────────────
+
+    def run_dynamic_pipeline(
+        self,
+        input_data:   np.ndarray,
+        compiled_ops: np.ndarray,
+    ) -> np.ndarray:
+        """Esegue la pipeline compilata in un singolo lax.scan JIT."""
+
+        @jax.jit
+        def _run(d, ops, k):
+            (f_data, next_k), _ = jax.lax.scan(
+                _execute_ai_instruction_step, (d, k), ops
+            )
+            return f_data, next_k
+
+        res_data, updated_key = _run(
+            jnp.array(input_data, dtype=jnp.float64),
+            jnp.array(compiled_ops, dtype=jnp.float64),
+            self.base_key,
+        )
+        self.base_key = updated_key
+        return np.array(res_data)
+
+
+    # ── Chunked execution (Anti-OOM) Advanced via Grafo Nativo XLA ───────────
+
+    def run_pipeline_with_chunking(
+        self,
+        input_data:   np.ndarray,
+        compiled_ops: np.ndarray,
+        chunk_size:   int = 500,
+    ) -> np.ndarray:
+        """
+        [ADVANCED ENGINE]: Suddivide la pipeline in blocchi ed esegue il chunking 
+        interamente all'interno dell'acceleratore hardware senza colli di bottiglia CPU.
+        """
+        n_ops = len(compiled_ops)
+        # Calcolo dei blocchi necessari preservando la conformazione statica
+        n_chunks = (n_ops + chunk_size - 1) // chunk_size
+        total_slots = n_chunks * chunk_size
+        
+        # Allocazione della matrice di padding condizionata
+        padded_ops = np.zeros((total_slots, 4), dtype=np.float64)
+        padded_ops[:n_ops] = compiled_ops
+        
+        # Riorganizzazione geometrica in tensore 3D (N_Chunks x Chunk_Size x 4)
+        structured_chunks = padded_ops.reshape(n_chunks, chunk_size, 4)
+        
+        j_data = jnp.array(input_data, dtype=jnp.float64)
+        j_chunks = jnp.array(structured_chunks, dtype=jnp.float64)
+
+        @jax.jit
+        def _chunked_scan_compiler(data_state, chunks_tensor):
+            # Scan a due livelli: itera sui macro-chunk mantenendo intatto lo stato d'onda JAX
+            def _chunk_iterator(carry_state, single_chunk):
+                (f_data, next_k), _ = jax.lax.scan(
+                    _execute_ai_instruction_step, (carry_state, self.base_key), single_chunk
+                )
+                return f_data, None
+            
+            final_state, _ = jax.lax.scan(_chunk_iterator, data_state, chunks_tensor)
+            return final_state
+
+        res_data = _chunked_scan_compiler(j_data, j_chunks)
+        return np.array(res_data)
+
+    # ── Gradients con Regolarizzazione Topologica Aurea ───────────────────────
+
+    def compute_gradients(
+        self,
+        input_data:   np.ndarray,
+        compiled_ops: np.ndarray,
+    ) -> np.ndarray:
+        """Calcola i gradienti AD della loss, normalizzata da una costante fissa (_PHI_FOUR)."""
+
+        def _topological_loss_fn(d, ops, k):
+            (f_data, _), _ = jax.lax.scan(
+                _execute_ai_instruction_step, (d, k), ops
+            )
+            # Normalizzazione: l'errore quadratico e' scalato da una costante fissa
+            return jnp.sum(jnp.square(f_data)) / jnp.float64(_PHI_FOUR)
+
+        grad_engine = jax.jit(jax.grad(_topological_loss_fn, argnums=0))
+        j_input     = jnp.array(input_data, dtype=jnp.float64)
+        j_ops       = jnp.array(compiled_ops, dtype=jnp.float64)
+        
+        grads       = grad_engine(j_input, j_ops, self.base_key)
+        self.base_key = jax.random.split(self.base_key)[0]
+        return np.array(grads)
+
+    # ── Persistence ───────────────────────────────────────────────────────────
+
+    def save_compiled_pipeline(
+        self,
+        compiled_ops: np.ndarray,
+        filename: str = "compiled_recipe.npy",
+    ):
+        """Salva la matrice delle operazioni compilate in formato binario compresso .npy."""
+        np.save(filename, compiled_ops)
+        print(f"-> Advanced Pipeline salvata con successo: '{filename}'")
+
+    def load_compiled_pipeline(
+        self,
+        filename: str = "compiled_recipe.npy",
+    ) -> np.ndarray:
+        """Carica una matrice di operazioni precedentemente salvata."""
+        if not os.path.exists(filename):
+            raise FileNotFoundError(f"File pipeline assente: '{filename}'")
+        ops = np.load(filename)
+        print(f"-> Advanced Pipeline caricata con successo: '{filename}'  shape={ops.shape}")
+        return ops

dense_armor/core/damping_operator.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+r"""
+Sentinel Metrology Framework - Adaptive Damping Blend Operator
+=========================================================
+Sottosistema: fonde due segnali (es. output grezzo e riferimento) con un
+guadagno non lineare che dipende dalla loro distanza -- differenza piccola
+tra i due -> si preferisce il segnale grezzo; differenza grande -> si
+preferisce il riferimento, in modo smorzato e sempre limitato.
+Autore del Framework: Salvatore Pennacchio (Napoli, 2026)
+Percorso: sentinel02/core/damping_operator.py
+
+Nota: non e' calcolo quantistico. I nomi delle costanti (PHI, ecc.) sono
+iperparametri numerici fissi, non stati/operatori quantistici -- non c'e'
+aritmetica complessa ne' spazio di Hilbert coinvolti.
+"""
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+# =========================================================================
+# COSTANTI NUMERICHE FISSE (XLA-SAFE, precompilate per stabilita' binaria)
+# =========================================================================
+_PHI_128        = np.longdouble(1.0 + np.sqrt(5.0)) / 2.0  # sezione aurea, usata solo come iperparametro
+_ZETA_TOTAL_128 = np.longdouble(60.16762236065194)          # costante numerica fissa (limite superiore di damping)
+
+# Cast a tipi primitivi per prevenire eccezioni hardware nei file binari (.bin)
+_PHI        = float(_PHI_128)
+_ALPHA      = float(0.25)                           # Base simmetrica (1/4)
+_SIGMA      = float(np.longdouble(1.0) / (_PHI_128 ** 4)) # ~0.1458980337
+_K_MAX_ZETA = float(_ZETA_TOTAL_128 / (_PHI_128 ** 4))  # Limite di damping superiore (~8.778)
+
+
+@jax.jit
+def apply_damping_blend(gradient_state: jnp.ndarray, noise_matrix: jnp.ndarray) -> jnp.ndarray:
+    r"""
+    Fonde `gradient_state` (segnale grezzo) e `noise_matrix` (riferimento)
+    con un coefficiente K variabile:
+    - differenza piccola tra i due segnali -> K basso, si preferisce il grezzo.
+    - differenza grande -> K alto, si preferisce il riferimento (smorzamento).
+    - [PATCH 2026]: isola e cancella i NaN a runtime prima del blend.
+    """
+    eps = 1e-7
+
+    # =========================================================================
+    # SANIFICAZIONE NaN (nessun valore non finito deve propagarsi nel blend)
+    # =========================================================================
+    is_nan_gradient = jnp.isnan(gradient_state)
+    is_nan_noise = jnp.isnan(noise_matrix)
+
+    gradient_state_safe = jnp.where(is_nan_gradient, noise_matrix, gradient_state)
+    noise_matrix_safe = jnp.where(is_nan_noise, gradient_state_safe, noise_matrix)
+    # =========================================================================
+
+    # 1. Distanza assoluta tra i due segnali
+    diff = jnp.abs(gradient_state_safe - noise_matrix_safe)
+
+    # 2. Coerenza relativa: quanto la distanza e' piccola rispetto alla scala del segnale
+    c_gate = jnp.float32(_ALPHA + _SIGMA)
+    coherence = jnp.clip(1.0 - (diff / (2.0 * jnp.maximum(jnp.abs(gradient_state_safe), 1e-3))), 0.0, 1.0)
+
+    # 3. Curva di damping a sigmoide: sale gradualmente con la distanza, satura a _K_MAX_ZETA
+    x_steer = jnp.clip(diff, 0.0, 5.0)
+    steering = 1.0 / (1.0 + jnp.exp(-(x_steer - 2.0)))
+    h_damping = steering * jnp.float32(_K_MAX_ZETA)
+
+    # 4. Guadagno anomalo: decresce iperbolicamente con la distanza, poi limitato
+    c_anom = jnp.float32(1.0 / (_PHI ** 2))
+    K_anomalous_raw = c_anom / (c_anom + diff + eps)
+    K_anomalous = jnp.clip(K_anomalous_raw, jnp.float32(_ALPHA), jnp.float32(_K_MAX_ZETA))
+
+    # 5. Combinazione dei due guadagni pesata dalla coerenza
+    K_operator = (1.0 - coherence) * h_damping + coherence * K_anomalous
+
+    # Se uno degli input originari era NaN, forziamo K al massimo smorzamento
+    K_operator = jnp.where(jnp.logical_or(is_nan_gradient, is_nan_noise), jnp.float32(1.0 - (_ALPHA - _SIGMA)), K_operator)
+
+    # Limitazione dinamica del guadagno per evitare blend degeneri (K=0 o K=1 assoluti)
+    k_min_bound = jnp.float32(_ALPHA - _SIGMA)
+    k_max_bound = jnp.float32(1.0 - (_ALPHA - _SIGMA))
+    K_operator = jnp.clip(K_operator, k_min_bound, k_max_bound)
+
+    # Blend finale: media pesata tra segnale grezzo e riferimento
+    blended = (1.0 - K_operator) * gradient_state_safe + K_operator * noise_matrix_safe
+
+    # Pulizia finale: nessun NaN deve uscire dalla funzione
+    blended = jnp.where(jnp.isnan(blended), noise_matrix_safe, blended)
+
+    return blended