👁 ΩFFΣLLIα

llama.cpp-diffusion — ZetaHelicoidal (ΩFFΣLLIα)

Fork modificado do llama.cpp-diffusion com a camada de quantização ΩFFΣLLIα / Helicoidal-Zeta integrada ao pipeline Python de quantização (gguf-py), desenvolvida por Bruno Becker.

Este repositório contém o código-fonte completo (llama.cpp-diffusion_ZetaHelicoidal.zip, ~1.05 GB) pronto para compilar e quantizar modelos GGUF com o pré-condicionamento Helicoidal-Zeta ativo.

Este é um derivado de código. Todos os créditos da base original pertencem ao projeto llama.cpp / llama.cpp-diffusion e seus mantenedores. As modificações ΩFFΣLLIα estão documentadas abaixo.

---

📌 Visão geral

---

🔧 O que foi modificado

A integração ΩFFΣLLIα atua dentro do pipeline Python de quantização do gguf-py, sem alterar os formatos binários do GGML. Dois arquivos foram modificados:

1. gguf-py/gguf/__init__.py

Exposição do kernel no pacote:

from gguf.quants import HelicoidalZetaCore # Importação necessária!

2. gguf-py/gguf/quants.py

• Classe HelicoidalZetaCore — implementa o kernel matemático completo:

  • math_embedding(n) — concatena coordenadas helicoidais moduladas, par (r, θ) da rotação áurea e assinatura da função zeta de Riemann em s = 1/2 + i·n (via mpmath, 21 dígitos, com cache LRU de 10.000 entradas);
  • transform(x, n_val) — aplica o fator escalar tanh(mean(emb(n))) ao bloco;
  • inverse_transform(x, n_val) — desfaz exatamente o fator na dequantização, com proteção numérica para escalas |fator| < 1e-8;
  • delta_m(n) — modulação mod-42 das coordenadas (1.0 se n ≡ 0 (mod 42), senão 0.42);
  • cache incremental de primos (_PrimeCache) para o modo opcional use_primes.

• __Quant.quantize_rows — antes da quantização nativa, cada bloco i recebe zeta_core.transform(bloco, n_val=i+1). Inclui auditoria em tempo real:

[AUDITORIA] OFFELLIA ATIVA - Bloco 0 ANTES: <valor>
[AUDITORIA] SUCESSO - Bloco 0 DEPOIS: <valor>
 > Offellia processando tensores: i/n_blocks...

• __Quant.dequantize_rows — após a dequantização padrão do GGML, cada bloco recebe zeta_core.inverse_transform(bloco, n_val=i+1), restaurando a escala original.

Todas as classes de quantização nativas (Q4_0…Q8_0, Q2_K…Q6_K, TQ, MXFP4, IQ*) permanecem intactas — a camada ΩFFΣLLIα envolve o fluxo, não o substitui.

---

🧬 Como funciona a camada Helicoidal-Zeta

A ΩFFΣLLIα não substitui os formatos de quantização do GGML/llama.cpp — ela atua como uma camada de pré-condicionamento determinística e reversível aplicada bloco a bloco, antes da quantização padrão (e desfeita na dequantização):

1. Cada linha do tensor é dividida em blocos de tamanho fixo do tipo de quant escolhido.
2. Antes de quantizar, cada bloco i é multiplicado por um fator escalar derivado do Helicoidal-Zeta Kernel, indexado por n = i + 1.
3. O bloco já condicionado segue para a quantização nativa do tipo escolhido (Q4_K, Q8_0, etc.).
4. Na inferência, a dequantização nativa do GGML é aplicada e em seguida o inverse_transform desfaz exatamente o fator, restaurando a escala original do bloco.

O fator escalar

raw_scale = média(emb(n))
fator = tanh(raw_scale) # usado na quantização
inverso = x / fator # usado na dequantização

---

📐 Fundamentos matemáticos

A construção parte da função real sobre os inteiros:

F(n)=sin2(2πφn),φ=21+5​​≈1,6180339887…

Geometricamente, é uma rotação irracional no toro levantada para uma hélice em $\mathbb{R}^3$. Como $\varphi$ é a constante "mais irracional" (caso extremo do teorema de Hurwitz), a órbita nunca se fecha nem se repete — e dessa única propriedade derivam todas as estruturas seguintes.

Forma cosseno e valor médio

Aplicando $\sin^2 x = \tfrac{1}{2}(1 - \cos 2x)$:

F(n)=21​−21​cos(4πφn)

• A parte constante $\tfrac{1}{2}$ é o valor médio de $F$ (≈ 0,5).
• A parte flutuante é mono-frequencial, com frequência angular única $\omega = 4\pi\varphi$.
• Não há harmônicos superiores: toda estrutura vem da interação dessa frequência irracional com operações inteiras (passos e módulos).

Equidistribuição e lei do arcoseno

Pelo teorema de Weyl, a sequência ${\varphi n}$ é equidistribuída em $[0,1)$. Logo $Y = \sin^2(2\pi U)$ segue a distribuição arcoseno $\mathrm{Beta}(\tfrac12,\tfrac12)$:

fY​(y)=πy(1−y)​1​,y∈(0,1)

com massa acumulada nas bordas e mínimo central $\tfrac{1}{\pi} \approx 0{,}637$.

Complementaridade do passo 2

F(n)+F(n+2)=1−cos(4πφ)cos(4πφ(n+1))

com $\cos(4\pi\varphi) \approx 0{,}0874$ — quase-quadratura. A soma oscila em torno de 1 com amplitude mínima, gerando a correlação antidiagonal $F(p) \leftrightarrow F(p+2) \approx -0{,}985$. O passo 2 é minimizante porque ${2\varphi} = 0{,}236 \approx \tfrac14$, consequência direta da expansão em fração contínua $\varphi = [1;1,1,1,\ldots]$.

Estrutura modular 42

Como $42 = 2\cdot 3\cdot 7$ e $\varphi(42) = 12$, há 12 braços coprimos que abrigam todos os primos $> 7$. Os 16 resíduos quadráticos mod 42 ocupam posições fixas ${0,1,4,7,9,15,16,18,21,22,25,28,30,36,37,39}$ e o centro $r=21$ (ângulo $\theta=\pi$) é o eixo de simetria do bloco, ponto fixo do pareamento $r \leftrightarrow 42-r$.

Tabela-síntese das invariantes

Estas propriedades descrevem a função geradora do kernel. Elas são exatas e demonstráveis a partir dos primeiros princípios; não constituem, por si só, medições de qualidade do modelo quantizado (ver "Notas e limitações").

---

🚀 Uso rápido

1. Baixar e extrair

huggingface-cli download Brunobkr/llama.cpp-diffusion_ZetaHelicoidal \
 llama.cpp-diffusion_ZetaHelicoidal.zip \
 --repo-type dataset --local-dir .

unzip llama.cpp-diffusion_ZetaHelicoidal.zip
cd llama.cpp-diffusion_ZetaHelicoidal

2. Dependências

pip install -r requirements.txt
pip install mpmath # necessário para zeta_signature()

3. Quantizar com ΩFFΣLLIα ativa

python convert_hf_to_gguf.py /caminho/do/modelo-base \
 --outfile modelo-zeta.gguf \
 --outtype q8_0

Durante o processo, o log de auditoria confirma a camada ativa:

[AUDITORIA] OFFELLIA ATIVA - Bloco 0 ANTES: 0.123456789012345
[AUDITORIA] SUCESSO - Bloco 0 DEPOIS: 0.051234567890123
 > Offellia processando tensores: 4200/98304...

4. Inferência

O GGUF resultante requer a dequantização com inverse_transform (incluída neste fork) para restaurar a escala original dos blocos.

llama-server -m modelo-zeta.gguf -c 8192 -ngl 99 --port 8080

---

⚠️ Notas e limitações

• A camada Helicoidal-Zeta é determinística e reversível; os pesos efetivos na inferência correspondem aos do modelo base submetidos ao formato de quant escolhido.
• A reversão usa proteção numérica para escalas com $|,\text{fator},| < 10^{-8}$.
• O mpmath é dependência obrigatória para o cálculo da assinatura zeta ($\zeta(1/2 + i,n)$, 21 dígitos de precisão).
• As invariantes matemáticas listadas referem-se à função geradora do kernel, não a benchmarks de perplexidade/qualidade dos GGUFs resultantes. Avalie empiricamente no seu caso de uso.
• Os parâmetros de geração (temperatura, top_p, top_k, template de chat) seguem as recomendações do modelo base quantizado — consulte o card original.

---

📚 Referências

• Base: llama.cpp-diffusion / llama.cpp — https://github.com/ggml-org/llama.cpp
• Formato GGUF: https://huggingface.co/docs/hub/gguf
• ΩFFΣLLIα (Hugging Face): https://huggingface.co/Brunobkr
• Depósito de pesquisa (Zenodo): https://doi.org/10.5281/zenodo.20026837

---

✍️ Citação

@misc{becker_llamacpp_diffusion_zetahelicoidal,
 author = {Bruno Becker},
 title = {llama.cpp-diffusion ZetaHelicoidal: Helicoidal-Zeta quantization layer integrated into the gguf-py pipeline},
 year = {2026},
 howpublished = {Hugging Face Datasets},
 note = {Deterministic, reversible per-block pre-conditioning kernel (ΩFFΣLLIα)},
 url = {https://huggingface.co/datasets/Brunobkr/llama.cpp-diffusion_ZetaHelicoidal}
}

---

🙏 Créditos

• Base original: llama.cpp / llama.cpp-diffusion — ggml-org e contribuidores
• Camada ΩFFΣLLIα / Helicoidal-Zeta: Bruno Becker — Brunobkr