Brunobkr/llama.cpp_offellia

markdown

ΩFFΣLLIα - GENESIS

llama.cpp_offellia

Structural Tensor Optimization via Helicoidal-Zeta Kernel & Dynamic Coprime Probing

---

🌌 Abstract

llama.cpp_offellia is an advanced, mathematically-driven fork of llama.cpp and the gguf-py quantization pipeline. It introduces the OFFELLIA-GENESIS Framework, which replaces standard heuristic memory access patterns and linear tensor scaling with rigorous number-theory and complex-analysis models.

By leveraging the Helicoidal-Zeta Kernel (evaluating the Riemann Zeta function on the critical line) and Dynamic Coprime Probing (based on the golden ratio $\phi$ and prime topology), OFFELLIA minimizes cache resonance, eliminates primary clustering in massive tensor graphs, and applies non-linear topological embeddings during the quantization and dequantization phases.

Framework: OFFELLIA-GENESIS (Helicoidal-Zeta Kernel) Author: Bruno Becker (ΩFFΣLLIα) | 2025-2026 Archive: Zenodo DOI: 10.5281/zenodo.20026837

---

🧬 Core Architecture & Theory

The OFFELLIA architecture operates on two distinct layers, bridging low-level C memory management with high-level Python tensor transformations.

1. C/C++ Layer: Dynamic Coprime Hash Probing (ggml-impl.h)

Standard GGML uses power-of-2 hash tables with linear probing, which suffers from primary clustering in massive computation graphs. OFFELLIA introduces Dynamic Coprime Probing:

• Theory: Any odd number is coprime with a power of 2.
• Implementation: We use a base step of 13 (derived from the OFFELLIA $\varphi(42)=12$ structure). This guarantees a full, collision-free traversal of all hash slots without clustering, drastically reducing cache misses during graph evaluation. If the table size is not a power of 2, a dynamic GCD fallback ensures safety.

// OFFELLIA: Coprime step derived from φ(42) structure
static inline size_t ggml_hash_coprime_step(size_t table_size) {
    size_t step = 13; // Base prime from OFFELLIA φ(42) structure
    // Fallback de segurança: se table_size não for potência de 2, encontra um coprimo dinâmico
    if ((table_size & (table_size - 1)) != 0) {
        size_t a = table_size, b = step;
        while (b != 0) { size_t t = b; b = a % b; a = t; } // GCD
        while (a != 1 && step < table_size) {
            step += 2;
            a = table_size; b = step;
            while (b != 0) { size_t t = b; b = a % b; a = t; }
        }
        if (step >= table_size) step = 1;
    }
    return step;
}

2. Python Layer: Helicoidal-Zeta Kernel (quants.py)

During the GGUF quantization and dequantization pipeline, tensor blocks are not merely scaled by min/max values. They are passed through the HelicoidalZetaCore, applying a topological signature:

• Golden Ratio Helicoid: $F(n) = \sin^2(2\pi\phi n)$
• Riemann Zeta Signature: Evaluated at $s = 0.5 + in$, mapping the block index $n$ into a complex plane embedding.
• Reversibility: The framework implements a strict inverse_transform during dequantization to perfectly recover the original tensor scale.

# OFFELLIA: Intercepts block quantization/dequantization
zeta_core = HelicoidalZetaCore(zeta_dps=21, use_primes=False)

# Quantization Phase
blocks[i] = zeta_core.transform(blocks[i], n_val=i+1)

# Dequantization Phase (Essential for recovery)
dequant_blocks[i] = zeta_core.inverse_transform(dequant_blocks[i], n_val=i+1)

---

📐 Mathematical Formulation

The scaling factor applied to tensor blocks is derived from the mean of a multi-dimensional mathematical embedding:

$$\text{Emb}(n)=[\vec{C}(n)\cdot \delta (n),R(n),\mathrm{\Theta }(n),\mathrm{\Re }(\zeta (s)),\mathrm{\Im }(\zeta (s))]\backslash text\{Emb\}(n)\; =\; \backslash left[\; \backslash vec\{C\}(n)\; \backslash cdot\; \backslash delta(n),\; \backslash \; R(n),\; \backslash \; \backslash Theta(n),\; \backslash \; \backslash Re(\backslash zeta(s)),\; \backslash \; \backslash Im(\backslash zeta(s))\; \backslash right]$$

Where:

• $\vec{C}(n)$ are the 3D helicoidal coordinates.
• $\delta(n)$ is the coprime modulus delta ($\varphi(42)$).
• $\zeta(s)$ is the Riemann Zeta function evaluated at the critical line $s = 0.5 + in$.
• The final scale is bounded by $\tanh(\text{mean}(\text{Emb}(n)))$.

---

🚀 Installation & Usage

Prerequisites

• mpmath (Required for high-precision Zeta function evaluation)
• numpy
• Standard llama.cpp build tools (CMake, GCC/Clang)

Python Quantization Pipeline (GGUF)

To use the OFFELLIA quantization transforms when converting models to GGUF:

pip install mpmath numpy

from gguf.quants import HelicoidalZetaCore
import numpy as np

# Initialize the OFFELLIA Kernel
core = HelicoidalZetaCore(zeta_dps=21, use_primes=False)

# The transform is automatically applied during custom GGUF quantization
# if the OFFELLIA hooks are enabled in the conversion script.
# Audit logs will print: "[AUDITORIA] OFFELLIA ATIVA - Bloco X..."

C++ Inference Engine

Compile the modified llama.cpp with the OFFELLIA hash optimizations included natively in ggml-impl.h:

cmake -B build
cmake --build build --config Release

---

🎨 Visual Identity & Cyberpunk Aesthetics

The OFFELLIA project embraces a Cyberpunk / Neon visual identity, reflecting the intersection of ancient mathematics and futuristic AI infrastructure. The UI and design system (defined in app.css) utilize a strict oklch neon palette:

• Primary Neon: Cyan (#00FFFF / oklch(0.75 0.28 195)) - Representing the flow of data and logic.
• Secondary Neon: Magenta (#FF00FF / oklch(0.7 0.28 330)) - Representing the complex plane and Zeta zeros.
• Accent: Electric Purple (#9D00FF / oklch(0.65 0.28 290)) - Representing the Golden Ratio $\phi$ and helicoidal geometry.
• Symbol: Ω (Omega) - The ultimate limit, the end of standard heuristics, the beginning of structural truth.

(See app.css for the complete design system, neon glow filters, and logo.svg for the vector identity).

---

📚 Citation

If you use llama.cpp_offellia or the Helicoidal-Zeta Kernel in your research, please cite the Zenodo archive:

@software{becker2026offellia,
  author       = {Bruno Becker},
  title        = {OFFELLIA-GENESIS: Helicoidal-Zeta Kernel and Coprime Probing for Tensor Graphs},
  month        = {jan},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20026837},
  url          = {https://doi.org/10.5281/zenodo.20026837}
}

---

📬 Contact & Community

• Author: Bruno Becker (ΩFFΣLLIα)

• X (Twitter): @Brunoxuser

• Tag: #OFFELLIA

---

⚖️ License & Acknowledgements

• Base Engine: llama.cpp by Georgi Gerganov and contributors (MIT License).
• OFFELLIA Modifications: Copyright © 2025-2026 Bruno Becker.
• The mathematical implementations (Helicoidal-Zeta, Coprime Hash) are provided as-is for research and experimental inference optimization.

_{"The structure of graphs is optimized based on the geometry of prime numbers and the helicoidal function."
ΩFFΣLLIα 2026}