README.md

---
license: mit
pretty_name: llama.cpp-diffusion ZetaHelicoidal (ΩFFΣLLIα)
language:
  - en
  - pt
tags:
  - llama.cpp
  - gguf
  - quantization
  - diffusion
  - offsellia
  - helicoidal-zeta
  - source-code
---

<p align="center">
  <img src="https://huggingface.co/datasets/Brunobkr/llama.cpp-diffusion_ZetaHelicoidal/resolve/main/capa.png" alt="ΩFFΣLLIα" width="100%"/>
</p>

# 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

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

```python
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) = \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

```bash
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

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

### 3. Quantizar com ΩFFΣLLIα ativa

```bash
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.

```bash
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

```bibtex
@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