Upload 2 files

README.md

@@ -0,0 +1,266 @@
+---
+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