Strilight (v0.2.0)

Hochleistungsfähige algebraische Loop-Lifting- & exakte rationale Rekurrenz-Engine für Python und C

---

Überblick: Warum iterieren, wenn man lösen kann?

Traditionelle Compiler, Laufzeitumgebungen und JIT-Engines (wie GCC, Clang, PyPy oder Numba) behandeln Schleifen als repetitive Kontrollflusssequenzen und führen Anweisungen Schritt für Schritt aus:

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

Wenn $N = 10^6$ oder $10^9$ ist, verursacht die sequentielle Ausführung Milliarden von CPU-Zyklen. Strilight gestaltet die Schleifenausführung durch Symbolisches Algebraisches Lifting grundlegend neu:

1. Formulierung des Zustandsübergangs: Es inspiziert statisch den Schleifenkörper und formuliert seine mathematische Zustandsübergangsmatrix:

$$ \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. Geschlossene Lösung: Es löst das Rekurrenzsystem in geschlossener Form und reduziert die Ausführungszeit von $\mathcal{O}(N)$ auf $\mathcal{O}(1)$ (für skalare/periodische/Teleskopreihen) oder $\mathcal{O}(\log N)$ (mittels schneller binärer Matrixexponentiation).

---

Designphilosophie: Developer Quality-of-Life First

Strilight gibt nicht vor, esoterische Magie einzuführen; es ist im Kern ein Developer-Quality-of-Life-Werkzeug.

In der physikalischen Modellierung, im wissenschaftlichen Rechnen und in der numerischen Simulation stehen Ingenieure häufig vor einem frustrierenden Dilemma:

• Lesbarer Code: Natürliche, ausdrucksstarke Gleichungen, die die Lehrbuchphysik widerspiegeln, aber bei millionenfacher Iteration nur langsam ausgeführt werden.
• Handoptimierter Code: Verschachtelte, manuell entrollte Schleifen und undurchsichtige arithmetische Abkürzungen, die schnell laufen, aber brüchig, schwer zu debuggen sind und die zugrunde liegende Physik verschleiern.

Strilight löst dieses Dilemma. Sie schreiben das physikalische oder mathematische Konzept in welcher geradlinigen, natürlichen Syntax Sie bevorzugen. Strilight inspiziert Ihre Schleifenstruktur, leitet die exakten geschlossenen Rekurrenzformeln ab und beschleunigt die Ausführung hinter den Kulissen – bei vollständiger Lesbarkeit und Einfachheit in Ihrer Codebasis.

---

Architektonische Grundlagen

1. Exakte rationale Arithmetik über $\mathbb{Q}$ (kein Präzisionsverlust)

Gleitkommaarithmetik führt zu kumulativen Abschneidungsfehlern ($1/3 \times 3 \approx 0.9999999999999999$). Strilight führt affine Induktion und Stride-Analyse über dem Körper der rationalen Zahlen $\mathbb{Q}$ durch:

• Multiplikatoren und Offsets werden als kanonische Brüche ($\frac{p}{q}$) modelliert.
• Es emittiert Double-Precision-Kernel in C und exakte Fraction-Darstellungen in Python, wodurch 100% bit-exakte mathematische Parität garantiert wird.

2. Gekoppelte Mehrvariablen-Rekurrenzsysteme ($\mathcal{O}(\log N)$)

Variablen, die voneinander abhängen (z. B. physikalische Simulationen, bei denen die Position von der Geschwindigkeit und die Geschwindigkeit von der Beschleunigung abhängt), werden automatisch in eine Variablenkopplungsmatrix ($\mathbf{A}$) extrahiert. Strilight führt binäre Exponentiation auf $\mathbf{A}$ durch und führt Millionen von Iterationen in unter 2 Nanosekunden aus.

3. Transparenter @accelerate-Decorator (Funktionsweise)

Das Dekorieren einer beliebigen Standard-Python-Funktion mit @accelerate führt zum Zeitpunkt der Funktionsdefinition eine automatisierte Pipeline aus (kein Analyse-Overhead zur Laufzeit pro Aufruf):

1. AST-Extraktion: Untersucht den AST der Funktion, identifiziert for-Schleifenkonstrukte und extrahiert Induktionsvariablen.
2. Synthese in geschlossener Form: Übersetzt die Schleife in äquivalente Rekursionsmodelle in geschlossener Form oder in Kerne der binären Matrixexponentiation.
3. In-Place-Splicing: Ersetzt die AST-Knoten der Schleife in-place, kompiliert das Callable in den Speicher und injiziert Laufzeit-Globals (Fraction, math), ohne die Modul-Namespaces zu verunreinigen.
4. Contract Reflection: Hängt _loop_summary und _invariant_contract an das kompilierte Funktionsobjekt an, sodass nachgelagerte Compiler und Verifikationstools die zugrunde liegende Übergangsmatrix $\mathbf{A}$ inspizieren können.
5. Graceful Fallback: Wenn nichtlineare Indexierung oder nicht unterstützte dynamische Aufrufe auftreten, gibt Strilight eine Diagnosewarnung aus und fällt sauber auf die native Ausführung zurück, ohne abzustürzen.

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. Vertragsgesteuerte C-Quellcode-Direktiven (#pragma strilight)

Im Gegensatz zur dynamischen Reflexion von Python folgen die C-Code-Transformationen in Strilight strikt einem expliziten Entwickler-Vertragsmodell über Pragma-Direktiven im OpenMP-Stil. Die Engine verändert C-Quellcode niemals implizit; Transformationen erfolgen ausschließlich, wenn sie durch explizite Vertragsklauseln des Entwicklers (contract, target, include, model) angewiesen werden:

• #pragma strilight accelerate: Autorisiert Strilight ausdrücklich, die annotierte C-for-Schleife in einen äquivalenten geschlossenen mathematischen Ausdruck zu überführen.
• #pragma strilight fuse: Eine explizite Entwicklerdirektive, die Strilight anweist, bestimmte benachbarte Schleifen mit identischen Iterationsdomänen zu einem einheitlichen binären Matrix-Rekurrenzkern der Komplexität $\mathcal{O}(\log N)$ zu verschmelzen.

// 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. Dateiübergreifende Symbol- und Konstantenauflösung (CrossFileResolver)

Numerische Simulationen definieren Parameter häufig in separaten Header-Dateien oder Konfigurationsmodulen. Strilights CrossFileResolver:

• Verfolgt statisch lokale Modulimporte sowie C-#include- / #define-Direktiven.
• Wertet literale Konstantenausdrücke (z. B. SOLAR_MASS = 4 * PI * PI) dateiübergreifend mittels AST-Auswertung aus, ohne beliebigen Laufzeitcode auszuführen oder ein unsicheres eval zu verwenden.

6. Induktion über Array-Slices & zyklische Tabellenzugriffe

• Zyklischer Array-Zugriff: Hebt zyklische Tabellenzugriffe (table[i % P]) in vorberechnete geschlossene Präfixsummenformeln in $\mathcal{O}(1)$ an.
• In-Place-Mutation von Array-Slices: Klassifiziert konstante Füllungen und arithmetische Progressionen und synthetisiert optimale Hardware-memset-Aufrufe oder Vektor-Slice-Zuweisungen (arr[:N] = ...).