Strilight (v0.2.0)

Motore ad alte prestazioni per il sollevamento algebrico dei cicli e per ricorrenze razionali esatte per Python e C

---

Panoramica: perché iterare quando puoi risolvere?

I compilatori, i runtime e i motori JIT tradizionali (come GCC, Clang, PyPy o Numba) trattano i cicli come sequenze ripetitive di flusso di controllo, eseguendo le istruzioni passo dopo passo:

$$ \text{Runtime Cost} = \mathcal{O}(N) $$

Quando $N = 10^6$ o $10^9$, l'esecuzione sequenziale comporta miliardi di cicli di CPU. Strilight riprogetta radicalmente l'esecuzione dei cicli attraverso il sollevamento algebrico simbolico:

1. Formulazione della transizione di stato: ispeziona staticamente il corpo del ciclo e ne formula la matrice matematica di transizione di stato:

$$ \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. Soluzione in forma chiusa: risolve il sistema di ricorrenza in forma chiusa, riducendo il tempo di esecuzione da $\mathcal{O}(N)$ a $\mathcal{O}(1)$ (per serie scalari/periodiche/telescopiche) o $\mathcal{O}(\log N)$ (tramite esponenziazione binaria veloce di matrici).

---

Filosofia di progettazione: prima la qualità della vita dello sviluppatore

Strilight non pretende di introdurre magie esoteriche; è fondamentalmente uno strumento per migliorare la qualità della vita dello sviluppatore.

Nella modellazione fisica, nel calcolo scientifico e nella simulazione numerica, gli ingegneri affrontano spesso un dilemma frustrante:

• Codice leggibile: equazioni naturali ed espressive che rispecchiano la fisica dei libri di testo, ma che risultano lente quando iterate milioni di volte.
• Codice ottimizzato a mano: cicli contorti, srotolati manualmente, e scorciatoie aritmetiche oscure che girano veloci, ma sono fragili, difficili da sottoporre a debug e oscurano la fisica sottostante.

Strilight risolve questo dilemma. Scrivi il concetto fisico o matematico con la sintassi diretta e naturale che preferisci. Strilight ispeziona la struttura del tuo ciclo, deriva le formule di ricorrenza esatte in forma chiusa e accelera l'esecuzione dietro le quinte, preservando la completa leggibilità e semplicità del tuo codice.

---

Fondamenti architetturali

1. Aritmetica razionale esatta su $\mathbb{Q}$ (zero perdita di precisione)

L'aritmetica in virgola mobile introduce errori cumulativi di troncamento ($1/3 \times 3 \approx 0.9999999999999999$). Strilight esegue l'induzione affine e l'analisi degli incrementi sul campo dei numeri razionali $\mathbb{Q}$:

• I moltiplicatori e gli offset sono modellati come frazioni canoniche ($\frac{p}{q}$).
• Genera kernel in doppia precisione in C e rappresentazioni Fraction esatte in Python, garantendo una parità matematica bit per bit al 100%.

2. Sistemi di ricorrenza accoppiati a più variabili ($\mathcal{O}(\log N)$)

Le variabili che dipendono reciprocamente l'una dall'altra (ad esempio, simulazioni fisiche in cui la posizione dipende dalla velocità e la velocità dipende dall'accelerazione) vengono estratte automaticamente in una matrice di accoppiamento delle variabili ($\mathbf{A}$). Strilight esegue l'esponenziazione binaria su $\mathbf{A}$, eseguendo milioni di iterazioni in meno di 2 nanosecondi.

3. Decoratore trasparente @accelerate (Come funziona)

Decorare qualsiasi funzione Python standard con @accelerate esegue una pipeline automatizzata al momento della definizione della funzione (zero overhead di analisi runtime per chiamata):

1. Estrazione AST: Ispeziona l'AST della funzione, identifica i costrutti del ciclo for ed estrae le variabili di induzione.
2. Sintesi in forma chiusa: Traduce il ciclo in modelli di ricorrenza equivalenti in forma chiusa o in kernel di esponenziazione matriciale binaria.
3. Splicing in-place: Sostituisce i nodi AST del ciclo in-place, compila il callable in memoria e inietta i global runtime (Fraction, math) senza inquinare i namespace del modulo.
4. Riflessione del contratto: Associa _loop_summary e _invariant_contract all'oggetto funzione compilato, consentendo ai compilatori e agli strumenti di verifica a valle di ispezionare la matrice di transizione sottostante $\mathbf{A}$.
5. Fallback controllato: Se si incontrano indicizzazioni non lineari o chiamate dinamiche non supportate, Strilight emette un avviso diagnostico e ripiega in modo pulito sull'esecuzione nativa senza andare in crash.

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. Direttive per il codice sorgente C guidate da contratto (#pragma strilight)

A differenza della riflessione dinamica di Python, le trasformazioni del codice C in Strilight seguono rigorosamente un Modello a Contratto dello Sviluppatore esplicito tramite direttive pragma in stile OpenMP. Il motore non modifica mai implicitamente il codice sorgente C; le trasformazioni avvengono esclusivamente quando sono dirette da clausole contrattuali esplicite dello sviluppatore (contract, target, include, model):

• #pragma strilight accelerate: autorizza esplicitamente Strilight a sollevare il ciclo for C annotato in un'espressione matematica equivalente in forma chiusa.
• #pragma strilight fuse: direttiva esplicita dello sviluppatore che istruisce Strilight a fondere cicli adiacenti designati che condividono domini di iterazione identici in un kernel ricorrente a matrice binaria unificato $\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. Risoluzione di simboli e costanti tra file (CrossFileResolver)

Le simulazioni numeriche definiscono spesso parametri in file di intestazione separati o moduli di configurazione. Il CrossFileResolver di Strilight:

• Traccia staticamente gli import dei moduli locali e le direttive C #include / #define.
• Valuta espressioni costanti letterali (ad es. SOLAR_MASS = 4 * PI * PI) tra file tramite valutazione AST senza eseguire codice runtime arbitrario né utilizzare eval non sicuro.

6. Induzione di slice di array e lookup ciclici in tabelle

• Lookup ciclico in array: Trasforma i lookup ciclici in tabelle (table[i % P]) in formule chiuse con somma prefissa precalcolata in $\mathcal{O}(1)$.
• Mutazione in-place di slice di array: Classifica riempimenti costanti e progressioni aritmetiche, sintetizzando chiamate hardware ottimali memset o assegnazioni di slice vettoriali (arr[:N] = ...).