Strilight (v0.2.0)

Moteur de levée de boucles algébriques haute performance et de récurrences rationnelles exactes pour Python et C

---

Aperçu : pourquoi itérer quand on peut résoudre ?

Les compilateurs, environnements d'exécution et moteurs JIT traditionnels (tels que GCC, Clang, PyPy ou Numba) traitent les boucles comme des séquences répétitives de flux de contrôle, exécutant les instructions pas à pas :

$$ \text{Coût d'exécution} = \mathcal{O}(N) $$

Lorsque $N = 10^6$ ou $10^9$, l'exécution séquentielle engendre des milliards de cycles CPU. Strilight réingénierie fondamentalement l'exécution des boucles grâce à la levée algébrique symbolique :

1. Formulation de la transition d'état : il inspecte statiquement le corps de la boucle et formule sa matrice de transition d'état mathématique :

$$ \vec{\mathbf{X}}(N) = \mathbf{A}^N \cdot \vec{\mathbf{X}}0 + \sum{k=0}^{N-1} \mathbf{A}^{N-1-k} \vec{\mathbf{B}} $$

2. Solution sous forme fermée : il résout le système de récurrence sous forme fermée, réduisant le temps d'exécution de $\mathcal{O}(N)$ à $\mathcal{O}(1)$ (pour les séries scalaires/périodiques/télescopiques) ou $\mathcal{O}(\log N)$ (via l'exponentiation binaire rapide de matrices).

---

Philosophie de conception : la qualité de vie du développeur avant tout

Strilight ne prétend pas introduire de magie ésotérique ; c'est fondamentalement un outil de qualité de vie pour le développeur.

En modélisation physique, en calcul scientifique et en simulation numérique, les ingénieurs sont fréquemment confrontés à un dilemme frustrant :

• Code lisible : des équations naturelles et expressives qui reflètent la physique des manuels, mais qui s'exécutent lentement lorsqu'elles sont itérées des millions de fois.
• Code optimisé à la main : des boucles alambiquées et déroulées manuellement, ainsi que des raccourcis arithmétiques obscurs qui s'exécutent rapidement, mais qui sont fragiles, difficiles à déboguer et qui masquent la physique sous-jacente.

Strilight résout ce dilemme. Vous écrivez le concept physique ou mathématique dans la syntaxe simple et naturelle que vous préférez. Strilight inspecte la structure de votre boucle, dérive les formules de récurrence exactes sous forme fermée et accélère l'exécution en coulisses — tout en préservant une lisibilité et une simplicité totales dans votre base de code.

---

Fondations architecturales

1. Arithmétique rationnelle exacte sur $\mathbb{Q}$ (aucune perte de précision)

L'arithmétique en virgule flottante introduit des erreurs de troncature cumulatives ($1/3 \times 3 \approx 0.9999999999999999$). Strilight effectue l'induction affine et l'analyse des pas sur le corps des nombres rationnels $\mathbb{Q}$ :

• Les multiplicateurs et les décalages sont modélisés sous forme de fractions canoniques ($\frac{p}{q}$).
• Il émet des noyaux en double précision en C et des représentations Fraction exactes en Python, garantissant une parité mathématique 100 % exacte au bit près.

2. Systèmes de récurrences couplés à variables multiples ($\mathcal{O}(\log N)$)

Les variables qui dépendent mutuellement les unes des autres (par exemple, des simulations physiques où la position dépend de la vitesse et la vitesse dépend de l'accélération) sont automatiquement extraites dans une matrice de couplage de variables ($\mathbf{A}$). Strilight effectue une exponentiation binaire sur $\mathbf{A}$, exécutant des millions d'itérations en moins de 2 nanosecondes.

3. Décorateur transparent @accelerate (Fonctionnement)

Décorer n'importe quelle fonction Python standard avec @accelerate exécute un pipeline automatisé au moment de la définition de la fonction (aucune surcharge d'analyse à l'exécution par appel) :

1. Extraction de l'AST : Inspecte l'AST de la fonction, identifie les constructions de boucles for et extrait les variables d'induction.
2. Synthèse en forme fermée : Traduit la boucle en modèles de récurrence équivalents en forme fermée ou en noyaux d'exponentiation matricielle binaire.
3. Substitution sur place : Remplace les nœuds AST de la boucle sur place, compile l'objet appelable en mémoire et injecte les globales d'exécution (Fraction, math) sans polluer les espaces de noms du module.
4. Réflexion de contrat : Attache _loop_summary et _invariant_contract à l'objet fonction compilé, permettant aux compilateurs et outils de vérification en aval d'inspecter la matrice de transition sous-jacente $\mathbf{A}$.
5. Repli gracieux : Si un indexage non linéaire ou des appels dynamiques non pris en charge sont rencontrés, Strilight émet un avertissement de diagnostic et revient proprement à l'exécution native sans planter.

from strilight import accelerate

@accelerate
def compute_simulation(steps: int) -> int:
    acc = 0
    for i in range(steps):
        acc += (i * 3) + 7
    return acc

# Executes in O(1) time (~0.001 ms even if steps = 100,000,000)
result = compute_simulation(100_000_000)

4. Directives de source C guidées par contrat (#pragma strilight)

Contrairement à la réflexion dynamique de Python, les transformations de code C dans Strilight suivent strictement un modèle de contrat développeur explicite via des directives pragma de style OpenMP. Le moteur ne modifie jamais implicitement le code source C ; les transformations n'ont lieu que lorsqu'elles sont dirigées par des clauses de contrat développeur explicites (contract, target, include, model) :

• #pragma strilight accelerate : autorise explicitement Strilight à élever la boucle for C annotée en une expression mathématique équivalente de forme fermée.
• #pragma strilight fuse : directive développeur explicite demandant à Strilight de fusionner des boucles adjacentes désignées partageant des domaines d'itération identiques en un noyau de récurrence matricielle binaire unifié en $\mathcal{O}(\log N)$.

// Example of contract-guided multi-loop fusion via developer directive
int simulate_motion(int n) {
    int pos = 0, vel = 10;

    #pragma strilight fuse
    for (int i = 0; i < n; i++) {
        pos += vel;
    }
    for (int i = 0; i < n; i++) {
        vel += 2;
    }
    return pos;
}

5. Résolution inter-fichiers des symboles et des constantes (CrossFileResolver)

Les simulations numériques définissent fréquemment des paramètres dans des fichiers d'en-tête ou des modules de configuration séparés. Le CrossFileResolver de Strilight :

• Trace statiquement les imports de modules locaux et les directives C #include / #define.
• Évalue les expressions de constantes littérales (par exemple SOLAR_MASS = 4 * PI * PI) à travers les fichiers via l'évaluation AST, sans exécuter de code arbitraire à l'exécution ni utiliser de eval non sécurisé.

6. Induction de tranches de tableaux et recherches cycliques dans les tables

• Recherche cyclique dans un tableau : Transforme les recherches cycliques dans les tables (table[i % P]) en formules fermées de sommes préfixes précalculées en $\mathcal{O}(1)$.
• Mutation en place de tranches de tableaux : Classe les remplissages constants et les progressions arithmétiques, en synthétisant des appels matériels optimaux memset ou des affectations vectorielles de tranches (arr[:N] = ...).