Skip to main content

Strilight (v0.2.0)

High-Performance Algebraic Loop Lifting & Exact Rational Recurrence Engine for Python and C

Release Python Version Complexity Exact Arithmetic Tests License


Overview: Why Iterate When You Can Solve?

Traditional compilers, runtimes, and JIT engines (such as GCC, Clang, PyPy, or Numba) treat loops as repetitive control-flow sequences, executing instructions step-by-step: $$\text{Runtime Cost} = \mathcal{O}(N)$$

When $N = 10^6$ or $10^9$, sequential execution incurs billions of CPU cycles. Strilight fundamentally re-engineers loop execution through Symbolic Algebraic Lifting:

  • It statically inspects the loop body and formulates its mathematical state transition matrix: $$\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}}$$
  • It solves the recurrence system in closed form, reducing execution time from $\mathcal{O}(N)$ to $\mathcal{O}(1)$ (for scalar/periodic/telescoping series) or $\mathcal{O}(\log N)$ (via fast binary matrix exponentiation).

Architectural Foundations

1. Exact Rational Arithmetic over $\mathbb{Q}$ (Zero Precision Loss)

Floating-point arithmetic introduces cumulative truncation errors ($1/3 \times 3 \approx 0.9999999999999999$). Strilight performs affine induction and stride analysis over the field of rational numbers $\mathbb{Q}$:

  • Multipliers and offsets are modeled as canonical fractions ($\frac{p}{q}$).
  • Emits double-precision kernels in C and exact Fraction representations in Python, guaranteeing 100% bit-exact mathematical parity.

2. Multi-Variable Coupled Recurrence Systems ($\mathcal{O}(\log N)$)

Variables that mutually depend on each other (e.g., physical simulations where position depends on velocity and velocity depends on acceleration) are automatically extracted into a Variable Coupling Matrix ($\mathbf{A}$). Strilight performs binary exponentiation on $\mathbf{A}$, executing millions of iterations in under 2 nanoseconds.

3. Transparent @accelerate Decorator (How It Works)

Decorating any standard Python function with @accelerate executes an automated pipeline at function definition time (zero per-call runtime analysis overhead):

  1. AST Extraction: Inspects the function AST, identifies for loop constructs, and extracts induction variables.
  2. Closed-Form Synthesis: Translates the loop into equivalent closed-form recurrence models or binary matrix exponentiation kernels.
  3. In-Place Splicing: Replaces the loop AST nodes in-place, compiles the callable into memory, and injects runtime globals (Fraction, math) without polluting module namespaces.
  4. Contract Reflection: Attaches _loop_summary and _invariant_contract to the compiled function object, enabling downstream compilers and verification tools to inspect the underlying transition matrix $\mathbf{A}$.
  5. Graceful Fallback: If non-linear indexing or unsupported dynamic calls are encountered, Strilight emits a diagnostic warning and cleanly falls back to native execution without crashing.
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. Contract-Guided C Source Directives (#pragma strilight)

Unlike Python's dynamic reflection, C code transformations in Strilight strictly follow an explicit Developer-Contract Model via OpenMP-style pragma directives. The engine never mutates C source code implicitly; transformations occur solely when directed by explicit developer contract clauses (contract, target, include, model):

  • #pragma strilight accelerate: Explicitly authorizes Strilight to lift the annotated C for loop into an equivalent closed-form mathematical expression.
  • #pragma strilight fuse: Explicit developer directive instructing Strilight to fuse designated adjacent loops sharing identical iteration domains into a unified $\mathcal{O}(\log N)$ binary matrix recurrence kernel.
// 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. Cross-File Symbol & Constant Resolution (CrossFileResolver)

Numerical simulations frequently define parameters in separate header files or configuration modules. Strilight's CrossFileResolver:

  • Statically traces local module imports and C #include / #define directives.
  • Evaluates literal constant expressions (e.g. SOLAR_MASS = 4 * PI * PI) across files via AST evaluation without executing arbitrary runtime code or using unsafe eval.

6. Array Slice Induction & Cyclic Table Lookups

  • Cyclic Array Lookup: Lifts cyclic table lookups (table[i % P]) into precomputed prefix-sum closed formulas in $\mathcal{O}(1)$.
  • In-Place Array Slice Mutation: Classifies constant fills and arithmetic progressions, synthesizing optimal hardware memset calls or vector slice assignments (arr[:N] = ...).

Benchmark Results

Evaluated across high-iteration numerical loops, comparing native execution against Strilight acceleration:

Benchmark Scenario Iterations ($N$) Native Baseline Strilight Accelerated Measured Speedup Precision Fidelity
Coupled 4x4 Linear System (Python) $1,000,000$ $75.2\text{ ms}$ $0.0002\text{ ms}$ $376,000\times$ 100% Bit-Exact
Coupled 4x4 Linear System (GCC -O2) $1,000,000$ $1.1\text{ ms}$ $0.00002\text{ ms}$ $55,000\times$ 100% Bit-Exact
Cyclic Array Lookup Summation $1,000,000$ $74.8\text{ ms}$ $0.0044\text{ ms}$ $17,000\times$ 100% Bit-Exact
Planetary N-Body Celestial Mechanics $100,000$ $7.17\text{ ms}$ $0.051\text{ ms}$ $140\times$ Analytical Orbit Parity

Architecture & Execution Pipeline

flowchart TD
    SRC["Source Code (Python / C)"] --> LIFTER["SourceLifter: AST & Pragma Parser"]
    LIFTER --> RESOLV["CrossFileResolver: Static Import Resolution"]
    RESOLV --> VSA["Algebraic Induction Engine: models.py"]
    VSA --> MATRIX["VariableCouplingMatrix: System Transition Matrix A"]
    VSA --> QFIELD["Exact Rational Domain over Q: AffineExpr"]
    REDUCE --> CODEGEN["CodeGenerator: C / Python Synthesis"]
    VSA --> REDUCE["Schur Reduction & Block-Diagonal Decomposition"]
    CODEGEN --> OUT["O(1) / O(log N) Executable Kernel"]

Key Applications & Real-World Use Cases

Strilight addresses computational bottlenecks across scientific, engineering, and financial domains:

1. Scientific & Astrophysical Simulations

  • Domain: N-Body celestial mechanics, orbital state propagation, and multi-particle kinematic cascades.
  • Advantage: Bypasses iterative $\mathcal{O}(N)$ numerical time-stepping. Evaluates the state vector at arbitrary future epoch $T$ directly in $\mathcal{O}(1)$ or $\mathcal{O}(\log N)$, eliminating cumulative numerical drift via exact rational arithmetic over $\mathbb{Q}$.

2. Quantitative Finance & Actuarial Analysis

  • Domain: Compound interest accrual streams, annuities, fixed-income modeling, and multi-period asset depreciation.
  • Advantage: Replaces multi-thousand-step simulation loops with exact closed-form evaluations in microseconds. Guarantees 100% bit-exact rational precision, eliminating floating-point rounding discrepancies prohibited under financial regulations.

3. Real-Time Graphics & Game Engine Physics

  • Domain: Particle emitters, projectile trajectories, and continuous camera animations.
  • Advantage: Offloads heavy sequential loops from the CPU during real-time 60/120 FPS frame cycles, collapsing iterative accumulator passes into single-cycle algebraic evaluations executing in sub-nanoseconds.

4. Embedded Systems & Hard Real-Time Computing (IoT / Edge)

  • Domain: Resource-constrained microcontrollers (ARM Cortex-M, RISC-V, ESP32) operating under strict power and clock limitations.
  • Advantage: Collapsing billion-iteration cycles into an instantaneous $\mathcal{O}(1)$ arithmetic statement delivers substantial energy savings and guarantees bounded, deterministic execution deadlines.

5. Compilers, Static Analysis & Formal Verification

  • Domain: Invariant inference, symbolic execution, and automated theorem proving (SMT/Z3).
  • Advantage: Synthesizes formal mathematical induction contracts (LoopInvariantContract) without memory-intensive loop unrolling.

Installation

From PyPI / Wheel Distribution:

pip install strilight

From Source (Development Mode):

git clone https://github.com/asama7706r-ui/strilight.git
cd strilight
pip install -e .

Verification & Examples

Execute the standalone verification test suite and practical examples:

# Python recurrence acceleration:
python examples/01_python_recurrence_acceleration.py

# Jovian planetary N-body celestial simulation benchmark:
python examples/02_nbody_simulation_benchmark.py

# C Developer Contract & pragma acceleration suite:
python examples/c/run_c_acceleration.py

Licensing & Dual-License Model

Strilight is released under a Dual-Licensing Model:

  • Open Source (GNU GPLv3): Free for academic research, open-source projects, and personal experimentation.
  • Commercial License: For integration into proprietary commercial products or enterprise pipelines without GPL copyleft obligations.

Contact: asama7706r@gmail.com

Metadata

Release files for strilight 0.2.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for strilight 0.2.0
File Size Uploaded Provenance Actions
strilight-0.2.0.tar.gz 83.6 kB With provenance Details for strilight-0.2.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for strilight 0.2.0
File Interpreter ABI Platform Actions
strilight-0.2.0-py3-none-any.whl Python 3 none any Details for strilight-0.2.0-py3-none-any.whl

Total release size: 169.9 kB

Release files / strilight-0.2.0.tar.gz

Download URL strilight-0.2.0.tar.gz
Size 83.6 kB
Tags Source
SHA-256 checksum
How to use checksums
a823ff792af4f7523592eae12a5cf42e62d9de01987bee498cb43e1726563965
BLAKE2b-256 checksum
How to use checksums
7ceab0a6d78a5de7a68b13e8fae351238542d1eb3ad25b3700d01e1eb7a70283
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Sep 6, 2026.

Transparency log

Release files / strilight-0.2.0-py3-none-any.whl

Download URL strilight-0.2.0-py3-none-any.whl
Size 86.3 kB
Tags Python 3
SHA-256 checksum
How to use checksums
8c038061df868c97bb311f70affb6a0d3ab3423b3de2818d2eac0888be90bbff
BLAKE2b-256 checksum
How to use checksums
4bb0929df88d60f7bc3b69d565809b3985aa78d44db30021b1d2edd1273df349
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Sep 6, 2026.

Transparency log

Security for strilight 0.2.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

Both files in this release have been uploaded with provenance metadata.

Select from 2 files

Attestation for strilight-0.2.0.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Sep 6, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.2.0 This release

2 release files Full provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page