STaRS × ESE — Infrastructure universelle de contrainte des données

. STaRS × ESE — Infrastructure universelle de contrainte des données Cadre méthodologique complet pour l’évaluation, la comparaison et la limitation interprétative des signaux Auteur : Kevin FradierAffiliation : Chercheur indépendantDate : 2026Statut : Publication méthodologique autonome — opérationnelle, testable, falsifiableLicence : © 2026 Kevin Fradier — Creative Commons Attribution – Pas d’Utilisation Commerciale – Pas de Modification 4.0 International (CC BY-NC-ND 4.0) 0. Portée explicite de ce document (à lire en premier) Ce document est autosuffisant. Il : définit le problème scientifique général, fixe le cadre méthodologique complet, décrit tous les niveaux d’analyse, précise ce que le pipeline fait, permet et interdit, ferme toute extrapolation théorique. Le code associé n’est qu’une implémentation, pas une source conceptuelle. 1. Problème scientifique universel Dans tous les domaines fondés sur des données, on observe le même échec récurrent : les données sont limitées, bruitées, incomplètes, les modèles sont sur-paramétrés, les récits dépassent la contrainte réelle des observations. 👉 Le problème n’est pas l’absence de théorie.👉 Le problème est l’absence d’un outil standardisé pour mesurer jusqu’où les données parlent réellement. 2. Objectif réel du pipeline STaRS × ESE Fournir une infrastructure universelle permettant de déterminer : ce que les données autorisent,ce qu’elles interdisent,et ce qui reste indécidable, sans hypothèse causale, ontologique ou explicative. ⚠️ Ce pipeline ne remplace aucune théorie.Il précède toutes les théories. 3. Position épistémique (verrouillée) Le pipeline adopte une neutralité stricte : aucune affirmation sur la nature du réel, aucune négation de structures possibles, aucune interprétation téléologique, aucune hiérarchie ontologique. 👉 Il ne dit rien sur ce qui existe.👉 Il dit jusqu’où les données contraignent un discours. 4. Architecture globale (complète) Le cadre est composé de trois briques indissociables, chacune opérant à un niveau distinct de contrainte. 4.1 STaRS — Contrainte locale (niveau système) Analyse interne d’un système unique : robustesse sous perturbations contrôlées, stabilité des distributions, persistance locale du signal, sensibilité à l’échantillonnage. 👉 Verdict :les données locales contraignent-elles quelque chose ou non ? 4.2 STaRS-NET — Contrainte relationnelle (niveau multi-systèmes) Analyse entre plusieurs systèmes comparables : corrélations inter-ensembles, stabilité du réseau relationnel, résistance aux permutations et suppressions, cohérence globale. 👉 Verdict :une structure commune est-elle contrainte par les données ? 4.3 ESE — Contrainte structurelle abstraite (niveau informationnel) Analyse du signal indépendamment du domaine : entropie, compression, persistance, invariants statistiques, stabilité structurelle sous bruit. 👉 Verdict :le signal possède-t-il une structure non triviale en tant qu’objet informationnel ? 5. Résultat principal : classes de contrainte (fermées) Le pipeline produit une classe de contrainte formelle, et rien d’autre. Classe Définition NC Données non contraignantes LC Contrainte locale uniquement SC Contrainte structurelle détectée RC Contrainte robuste inter-domaines ⚠️ Ces classes ne sont pas interprétables causalement. 6. Zone d’interprétation autorisée (pare-feu méthodologique) À chaque classe correspond une zone d’énoncés autorisés. Le pipeline définit explicitement : ce qui peut être dit, ce qui doit rester conditionnel, ce qui est interdit. 👉 Toute affirmation au-delà de cette zone est méthodologiquement invalide. 7. Responsabilité interne des données Le cadre identifie où se situe réellement le signal : niveaux, segments, nœuds, sous-structures dominantes. Cela permet : audits ciblés, réfutations précises, comparaisons reproductibles, critiques scientifiques non rhétoriques. 8. Reproductibilité totale Chaque exécution du pipeline produit obligatoirement : indicateurs quantitatifs, verdict de contrainte, cartographie contributive, hash cryptographique signé. Le hash garantit : réplication indépendante, citation sans divulgation, comparaison inter-équipes, traçabilité expérimentale complète. 9. Universalité des domaines (verrou explicite) Ce cadre est indépendant du domaine. Il s’applique notamment à : paléontologie, stratigraphie, réseaux biologiques ou sociaux, séries temporelles, textes et séquences symboliques, signaux, matrices, systèmes artificiels. 👉 Aucun module n’encode une hypothèse spécifique à un domaine. 10. Ce que le pipeline FAIT réellement (à souligner) STaRS × ESE ne servent pas seulement à “éviter la sur-interprétation”. Ils servent à : décider si un jeu de données est publiable, comparer des systèmes hétérogènes, invalider proprement des récits, établir des bornes objectives au discours scientifique, transformer les données en objet contraignant, pas en support narratif. 11. Ce que le pipeline ne fera jamais Il ne fournira jamais : de mécanisme, de cause, de scénario, de modèle explicatif, de vérité ontologique. 👉 Toute tentative d’usage dans ce sens est hors cadre. 12. Rôle du code (clarification finale) Le code associé : implémente ce cadre, n’en épuise pas la portée, n’en constitue pas la définition. 👉 Le cadre précède le code.👉 Le code ne peut pas être utilisé légitimement hors de ce cadre. 13. Phrase de clôture définitive STaRS × ESE ne disent pas ce qui s’est passé.Ils établissent jusqu’où les données peuvent parler,et à partir de quel point toute affirmation devient un acte interprétatif. LE CODE QUI VA AVEC LA PUBLICATION, aligné 1-pour-1 avec le cadre STaRS × ESE, opérationnel, autosuffisant, sans dépendance interprétative, sans storytelling. 👉 Ce code n’explique rien.👉 Il contraint, teste, classe, hash. STaRS × ESE — Implémentation de référence Code unique, universel, publication-ready # ============================================================ # STaRS × ESE — Universal Data Constraint Pipeline # Auteur : Kevin Fradier # Licence : CC BY-NC-ND 4.0 # Version : 2026 (référence) # ============================================================ import numpy as np import hashlib import zlib from math import log2 from scipy.ndimage import gaussian_filter from hurst import compute_Hc # ------------------------------------------------------------ # SIGNATURE AUTEUR (VERROUILLÉE) # ------------------------------------------------------------ AUTHOR_SIGNATURE = "Kevin Fradier | STaRS × ESE | 2026" # ------------------------------------------------------------ # OUTILS GÉNÉRAUX # ------------------------------------------------------------ def hash_result(obj): h = hashlib.sha256() h.update(str(obj).encode()) h.update(AUTHOR_SIGNATURE.encode()) return h.hexdigest() def shannon_entropy(seq): if len(seq) == 0: return 0.0 probs = [seq.count(c) / len(seq) for c in set(seq)] return -sum(p * log2(p) for p in probs if p > 0) def compression_ratio(seq): raw = bytes(seq, "utf-8") return len(zlib.compress(raw)) / len(raw) # ------------------------------------------------------------ # ESE — ANALYSE STRUCTURELLE INFORMATIONNELLE # ------------------------------------------------------------ def ese_analyze_sequence(seq): numeric = np.array([ord(c) for c in seq]) H, _, _ = compute_Hc(numeric, kind="change") result = { "entropy": shannon_entropy(seq), "compression": compression_ratio(seq), "hurst": float(H), } result["hash"] = hash_result(result) return result def ese_analyze_field(field, sigma_corr=3): field = np.asarray(field) field_corr = gaussian_filter(field, sigma=sigma_corr) fft2 = np.fft.fftshift(np.fft.fft2(field_corr)) power = np.abs(fft2) ** 2 result = { "mean": float(np.mean(field_corr)), "variance": float(np.var(field_corr)), "power_mean": float(np.mean(power)), "power_var": float(np.var(power)), } result["hash"] = hash_result(result) return result # ------------------------------------------------------------ # STaRS — CONTRAINTE LOCALE (SYSTÈME UNIQUE) # ------------------------------------------------------------ def simulate_taphonomic_noise(levels, loss_rate=0.3): noisy = [] for level in levels: mask = np.random.rand(len(level)) > loss_rate noisy.append(level * mask) return noisy def strat_entropy(level): s = np.sum(level) if s == 0: return 0.0 p = level / s p = p[p > 0] return -np.sum(p * np.log2(p)) def stars_local(levels, n_iter=100): totals = np.array([np.sum(l) for l in levels]) entropies = [strat_entropy(l) for l in levels] corrs = [] for _ in range(n_iter): pert = simulate_taphonomic_noise(levels) pert_totals = np.array([np.sum(l) for l in pert]) if np.std(pert_totals) > 0: corrs.append(np.corrcoef(totals, pert_totals)[0, 1]) result = { "mean_entropy": float(np.mean(entropies)), "robustness_corr": float(np.nanmean(corrs)), "robustness_std": float(np.nanstd(corrs)), } result["hash"] = hash_result(result) return result # ------------------------------------------------------------ # STaRS-NET — CONTRAINTE INTER-SYSTÈMES (RÉSEAU) # ------------------------------------------------------------ def stars_net(levels_list): """ levels_list : liste de bassins, chaque bassin = liste de niveaux (vecteurs de comptage) """ totals = [np.array([np.sum(l) for l in basin]) for basin in levels_list] n = len(totals) corr_matrix = np.zeros((n, n)) for i in range(n): for j in range(n): if np.std(totals[i]) > 0 and np.std(totals[j]) > 0: corr_matrix[i, j] = np.corrcoef(tota