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

Item	Valor
Arquivo principal	`llama.cpp-diffusion_ZetaHelicoidal.zip`
Base	llama.cpp-diffusion
Variante	ΩFFΣLLIα / Helicoidal-Zeta
Camada modificada	`gguf-py/gguf/quants.py` + `gguf-py/gguf/__init__.py`
Autor da modificação	Bruno Becker — Brunobkr

🔧 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):

Cada linha do tensor é dividida em blocos de tamanho fixo do tipo de quant escolhido.
Antes de quantizar, cada bloco i é multiplicado por um fator escalar derivado do Helicoidal-Zeta Kernel, indexado por n = i + 1.
O bloco já condicionado segue para a quantização nativa do tipo escolhido (Q4_K, Q8_0, etc.).
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) = \sin^2(2\pi\varphi n), \qquad \varphi = \frac{1+\sqrt{5}}{2} \approx 1{,}6180339887\ldots$

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) = \frac{1}{2} - \frac{1}{2}\cos(4\pi\varphi 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)$:

$f_Y(y) = \frac{1}{\pi\sqrt{y(1-y)}}, \quad y \in (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\pi\varphi)\,\cos\!\big(4\pi\varphi(n+1)\big)$

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

Invariante	Valor	Origem
Frequência fundamental	$4\pi\varphi$ rad	forma cosseno
Valor médio de $F$	0,5	termo constante
Lei de distribuição	arcoseno / Beta(½,½)	equidistribuição de Weyl
Constante de complementaridade	$\cos(4\pi\varphi)=0{,}0874$	passo 2, quase-quadratura
Correlação $F(p)\leftrightarrow F(p+2)$	−0,985	antidiagonal achatada
${2\varphi}$	0,236 ≈ ¼	fração contínua de $\varphi$
Braços coprimos $\varphi(42)$	12	aritmética mod 42
Resíduos quadráticos mod 42	16	CRT: 2×2×4
Centro do bloco	$r=21,\ \theta=\pi$	ponto fixo de $r\leftrightarrow 42-r$

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

Downloads last month: -

Total file size:

1.05 GB

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