Strilight (v0.2.0)

Motor de Elevação Algébrica de Loops de Alto Desempenho e Recorrência Racional Exata para Python e C

---

Visão Geral: Por Que Iterar Quando Você Pode Resolver?

Compiladores, runtimes e motores JIT tradicionais (como GCC, Clang, PyPy ou Numba) tratam loops como sequências repetitivas de fluxo de controle, executando instruções passo a passo:

$$ \text{Custo de Execução} = \mathcal{O}(N) $$

Quando $N = 10^6$ ou $10^9$, a execução sequencial incorre em bilhões de ciclos de CPU. O Strilight reengenheira fundamentalmente a execução de loops por meio da Elevação Algébrica Simbólica:

1. Formulação da Transição de Estado: Ele inspeciona estaticamente o corpo do loop e formula sua matriz de transição de estado matemática:

$$ \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. Solução em Forma Fechada: Ele resolve o sistema de recorrência em forma fechada, reduzindo o tempo de execução de $\mathcal{O}(N)$ para $\mathcal{O}(1)$ (para séries escalares/periódicas/telescópicas) ou $\mathcal{O}(\log N)$ (via exponenciação binária rápida de matrizes).

---

Filosofia de Design: Qualidade de Vida do Desenvolvedor em Primeiro Lugar

O Strilight não pretende introduzir magia esotérica; ele é fundamentalmente uma ferramenta de qualidade de vida para o desenvolvedor.

Em modelagem física, computação científica e simulação numérica, engenheiros frequentemente enfrentam um dilema frustrante:

• Código Legível: Equações naturais e expressivas que espelham a física dos livros didáticos, mas executam lentamente quando iteradas milhões de vezes.
• Código Otimizado Manualmente: Loops convolutos, desenrolados manualmente, e atalhos aritméticos obscuros que executam rápido, mas são frágeis, difíceis de depurar e obscurecem a física subjacente.

O Strilight resolve esse dilema. Você escreve o conceito físico ou matemático em qualquer sintaxe direta e natural que preferir. O Strilight inspeciona a estrutura do seu loop, deriva as fórmulas de recorrência exatas em forma fechada e acelera a execução nos bastidores—preservando completa legibilidade e simplicidade na sua base de código.

---

Fundamentos Arquiteturais

1. Aritmética Racional Exata sobre $\mathbb{Q}$ (Zero Perda de Precisão)

A aritmética de ponto flutuante introduz erros cumulativos de truncamento ($1/3 \times 3 \approx 0.9999999999999999$). O Strilight realiza indução afim e análise de passos sobre o corpo dos números racionais $\mathbb{Q}$:

• Multiplicadores e deslocamentos são modelados como frações canônicas ($\frac{p}{q}$).
• Emite kernels de precisão dupla em C e representações exatas de Fraction em Python, garantindo 100% de paridade matemática bit a bit.

2. Sistemas de Recorrência Acoplados Multi-Variável ($\mathcal{O}(\log N)$)

Variáveis que dependem mutuamente umas das outras (por exemplo, simulações físicas onde a posição depende da velocidade e a velocidade depende da aceleração) são automaticamente extraídas para uma Matriz de Acoplamento de Variáveis ($\mathbf{A}$). O Strilight realiza exponenciação binária sobre $\mathbf{A}$, executando milhões de iterações em menos de 2 nanossegundos.

3. Decorador transparente @accelerate (Como funciona)

Decorar qualquer função Python padrão com @accelerate executa um pipeline automatizado no momento da definição da função (zero sobrecarga de análise em tempo de execução por chamada):

1. Extração de AST: Inspeciona a AST da função, identifica construções de laço for e extrai variáveis de indução.
2. Síntese em Forma Fechada: Traduz o laço em modelos de recorrência equivalentes em forma fechada ou kernels de exponenciação de matriz binária.
3. Enxerto In-Place: Substitui os nós da AST do laço in-place, compila o callable em memória e injeta globais de tempo de execução (Fraction, math) sem poluir os namespaces do módulo.
4. Reflexão de Contrato: Anexa _loop_summary e _invariant_contract ao objeto de função compilado, permitindo que compiladores e ferramentas de verificação downstream inspecionem a matriz de transição subjacente $\mathbf{A}$.
5. Fallback Gracioso: Se indexação não linear ou chamadas dinâmicas não suportadas forem encontradas, o Strilight emite um aviso de diagnóstico e recorre de forma limpa à execução nativa sem falhar.

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. Diretivas de Código-Fonte C Guiadas por Contrato (#pragma strilight)

Ao contrário da reflexão dinâmica do Python, as transformações de código C no Strilight seguem estritamente um Modelo de Contrato do Desenvolvedor explícito por meio de diretivas pragma no estilo OpenMP. O motor nunca modifica implicitamente o código-fonte C; as transformações ocorrem somente quando direcionadas por cláusulas de contrato explícitas do desenvolvedor (contract, target, include, model):

• #pragma strilight accelerate: Autoriza explicitamente o Strilight a elevar o laço for em C anotado para uma expressão matemática de forma fechada equivalente.
• #pragma strilight fuse: Diretiva explícita do desenvolvedor instruindo o Strilight a fundir laços adjacentes designados que compartilham domínios de iteração idênticos em um kernel de recorrência de matriz binária unificado $\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. Resolução de Símbolos e Constantes entre Arquivos (CrossFileResolver)

Simulações numéricas frequentemente definem parâmetros em arquivos de cabeçalho separados ou módulos de configuração. O CrossFileResolver do Strilight:

• Rastreia estaticamente importações de módulos locais e diretivas C #include / #define.
• Avalia expressões constantes literais (por exemplo, SOLAR_MASS = 4 * PI * PI) entre arquivos via avaliação de AST sem executar código de runtime arbitrário ou usar eval inseguro.

6. Indução de Fatias de Arrays e Consultas Cíclicas em Tabelas

• Consulta Cíclica em Array: Eleva consultas cíclicas em tabelas (table[i % P]) a fórmulas fechadas de soma de prefixos pré-computadas em $\mathcal{O}(1)$.
• Mutação de Fatias de Arrays In-Place: Classifica preenchimentos constantes e progressões aritméticas, sintetizando chamadas otimizadas de hardware memset ou atribuições de fatias vetoriais (arr[:N] = ...).