Strilight (v0.2.0)

Motor de recurrencia racional exacta y elevación algebraica de bucles de alto rendimiento para Python y C

---

Descripción general: ¿por qué iterar cuando puedes resolver?

Los compiladores, runtimes y motores JIT tradicionales (como GCC, Clang, PyPy o Numba) tratan los bucles como secuencias repetitivas de flujo de control, ejecutando instrucciones paso a paso:

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

Cuando $N = 10^6$ o $10^9$, la ejecución secuencial incurre en miles de millones de ciclos de CPU. Strilight rediseña fundamentalmente la ejecución de bucles mediante la elevación algebraica simbólica:

1. Formulación de la transición de estado: inspecciona estáticamente el cuerpo del bucle y formula su matriz matemática de transición de estado:

$$ \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. Solución en forma cerrada: resuelve el sistema de recurrencia en forma cerrada, reduciendo el tiempo de ejecución de $\mathcal{O}(N)$ a $\mathcal{O}(1)$ (para series escalares/periódicas/telescópicas) o $\mathcal{O}(\log N)$ (mediante exponenciación binaria rápida de matrices).

---

Filosofía de diseño: la calidad de vida del desarrollador primero

Strilight no pretende introducir magia esotérica; es fundamentalmente una herramienta de calidad de vida para el desarrollador.

En modelado físico, computación científica y simulación numérica, los ingenieros se enfrentan con frecuencia a un dilema frustrante:

• Código legible: ecuaciones naturales y expresivas que reflejan la física de los libros de texto, pero que se ejecutan con lentitud cuando se iteran millones de veces.
• Código optimizado a mano: bucles enrevesados y desenrollados manualmente, junto con atajos aritméticos oscuros que se ejecutan rápido, pero que son frágiles, difíciles de depurar y ocultan la física subyacente.

Strilight resuelve este dilema. Escribes el concepto físico o matemático con la sintaxis directa y natural que prefieras. Strilight inspecciona la estructura de tu bucle, deriva las fórmulas de recurrencia exactas en forma cerrada y acelera la ejecución entre bastidores, preservando la legibilidad y la simplicidad completas en tu base de código.

---

Fundamentos arquitectónicos

1. Aritmética racional exacta sobre $\mathbb{Q}$ (cero pérdida de precisión)

La aritmética de punto flotante introduce errores acumulativos de truncamiento ($1/3 \times 3 \approx 0.9999999999999999$). Strilight realiza inducción afín y análisis de pasos sobre el cuerpo de los números racionales $\mathbb{Q}$:

• Los multiplicadores y desplazamientos se modelan como fracciones canónicas ($\frac{p}{q}$).
• Emite kernels de doble precisión en C y representaciones exactas Fraction en Python, garantizando una paridad matemática 100 % exacta a nivel de bits.

2. Sistemas de recurrencia acoplados multivariable ($\mathcal{O}(\log N)$)

Las variables que dependen mutuamente entre sí (por ejemplo, simulaciones físicas donde la posición depende de la velocidad y la velocidad depende de la aceleración) se extraen automáticamente en una matriz de acoplamiento de variables ($\mathbf{A}$). Strilight realiza exponenciación binaria sobre $\mathbf{A}$, ejecutando millones de iteraciones en menos de 2 nanosegundos.

3. Decorador transparente @accelerate (Cómo funciona)

Decorar cualquier función estándar de Python con @accelerate ejecuta una canalización automatizada en el momento de la definición de la función (sin sobrecarga de análisis en tiempo de ejecución por llamada):

1. Extracción de AST: Inspecciona el AST de la función, identifica las construcciones de bucle for y extrae las variables de inducción.
2. Síntesis en forma cerrada: Traduce el bucle en modelos de recurrencia equivalentes en forma cerrada o en kernels de exponenciación de matrices binarias.
3. Empalme in situ: Reemplaza los nodos del AST del bucle in situ, compila el invocable en memoria e inyecta globales en tiempo de ejecución (Fraction, math) sin contaminar los espacios de nombres del módulo.
4. Reflexión de contrato: Adjunta _loop_summary y _invariant_contract al objeto de función compilado, permitiendo que los compiladores y herramientas de verificación posteriores inspeccionen la matriz de transición subyacente $\mathbf{A}$.
5. Degradación elegante: Si se encuentran indexaciones no lineales o llamadas dinámicas no admitidas, Strilight emite una advertencia de diagnóstico y recurre limpiamente a la ejecución nativa sin fallar.

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. Directivas de código fuente C guiadas por contrato (#pragma strilight)

A diferencia de la reflexión dinámica de Python, las transformaciones de código C en Strilight siguen estrictamente un Modelo de Contrato del Desarrollador explícito mediante directivas pragma al estilo OpenMP. El motor nunca modifica implícitamente el código fuente C; las transformaciones ocurren únicamente cuando lo indican cláusulas de contrato explícitas del desarrollador (contract, target, include, model):

• #pragma strilight accelerate: Autoriza explícitamente a Strilight a elevar el bucle for de C anotado a una expresión matemática de forma cerrada equivalente.
• #pragma strilight fuse: Directiva explícita del desarrollador que instruye a Strilight a fusionar bucles adyacentes designados que comparten dominios de iteración idénticos en un kernel de recurrencia matricial binaria unificado de $\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. Resolución de símbolos y constantes entre archivos (CrossFileResolver)

Las simulaciones numéricas con frecuencia definen parámetros en archivos de encabezado o módulos de configuración separados. El CrossFileResolver de Strilight:

• Rastrea estáticamente las importaciones de módulos locales y las directivas #include / #define de C.
• Evalúa expresiones constantes literales (p. ej., SOLAR_MASS = 4 * PI * PI) entre archivos mediante evaluación AST sin ejecutar código arbitrario en tiempo de ejecución ni usar eval inseguro.

6. Inducción de segmentos de arrays y búsquedas cíclicas en tablas

• Búsqueda cíclica en arrays: Eleva las búsquedas cíclicas en tablas (table[i % P]) a fórmulas cerradas de suma de prefijos precalculadas en $\mathcal{O}(1)$.
• Mutación in situ de segmentos de arrays: Clasifica los rellenos constantes y las progresiones aritméticas, sintetizando llamadas óptimas de hardware memset o asignaciones de segmentos vectoriales (arr[:N] = ...).