---

license: other

license_name: refer-to-base-model

license_link: https://huggingface.co/docs/hub/repositories-licenses

base_model_relation: quantized

pipeline_tag: text-generation

library_name: gguf

quantized_by: Brunobkr

language:

- en

- pt

tags:

- gguf

- llama.cpp

- quantized

- offsellia

- helicoidal-zeta

- conversational

---

<p align="center">

<img src="capa.png" alt="ΩFFΣLLIα" width="100%"/>

</p>

ΩFFΣLLIα — Quantização GGUF Helicoidal-Zeta

Modelo convertido para o formato GGUF com a quantização ΩFFΣLLIα / Helicoidal-Zeta,

desenvolvida por Bruno Becker, aplicada sobre o pipeline de quantização do llama.cpp.

Compatível com llama.cpp, llama-server, Ollama, LM Studio, KoboldCpp, text-generation-webui

e demais ferramentas que suportam GGUF.

> Este é um derivado quantizado. Todos os créditos dos pesos e da arquitetura original

> conforme o modelo-base e a quantização específica deste repositório: https://huggingface.co/prefeitura-rio

Prefeitura do Rio de Janeiro (City of Rio de Janeiro)

---

📌 Visão geral

| Item | Valor |

| --- | --- |

| Nome do arquivo | <NOME_DO_ARQUIVO>.gguf |

| Variante | ΩFFΣLLIα / Helicoidal-Zeta |

| Formato | GGUF |

| Quantização (ΩFFΣLLIα) | Brunobkr |

---

🧬 O que é a quantização Helicoidal-Zeta (ΩFFΣLLIα)

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). O fluxo é:

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 de uma

construção matemática chamada Helicoidal-Zeta Kernel, indexada por n = i + 1.

1. O bloco já condicionado segue para a quantização nativa do tipo escolhido (Q4_K, Q8_0, etc.).
2. 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.

Como a transformação é um escalar por bloco e seu inverso é aplicado na leitura, o processo é

matematicamente reversível (com proteção contra divisão por escalas próximas de zero).

O fator escalar

Para cada bloco de índice n, o kernel calcula um embedding matemático emb(n) e define:

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

O emb(n) concatena três famílias de invariantes (detalhadas abaixo): coordenadas helicoidais

moduladas, um par (r, θ) da rotação áurea, e a assinatura da função zeta de Riemann em

s = 1/2 + i·n.

---

📐 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 com llama.cpp

# CLI
llama-cli -m <NOME_DO_ARQUIVO>.gguf \
  -p "Escreva um haiku sobre GPUs" \
  -c 8192 -ngl 99

# Servidor (API compatível com OpenAI)
llama-server -m <NOME_DO_ARQUIVO>.gguf \
  -c 8192 -ngl 99 --port 8080

Exemplo de chamada à API do llama-server:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Olá!"}],"stream":false}'

Download

huggingface-cli download Brunobkr/<seu-repo> \
  <NOME_DO_ARQUIVO>.gguf \
  --local-dir ./models

Outras ferramentas

• Ollama: ollama create <nome> -f Modelfile apontando FROM ./<NOME_DO_ARQUIVO>.gguf
• LM Studio / KoboldCpp / text-generation-webui: carregue o .gguf diretamente pela interface.

---

🎯 Casos de uso

Geração e edição de texto, chat e IA conversacional, sumarização, assistentes de código e

fluxos agênticos — conforme as capacidades do modelo base escolhido.

---

⚠️ 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.

• Os parâmetros de geração (temperatura, top_p, top_k, template de chat, tokens especiais)

seguem as recomendações do modelo base — consulte o card original.

• As invariantes matemáticas listadas referem-se à função geradora do kernel, não a benchmarks

de perplexidade/qualidade do GGUF resultante. Avalie empiricamente no seu caso de uso.

• A reversão usa proteção numérica para escalas com $|\,\text{fator}\,| < 10^{-8}$.

---

📚 Referências

• Modelo base: https://huggingface.co/<org/modelo-base>
• llama.cpp (GGUF): 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_offsellia_helicoidal_zeta,
  author       = {Bruno Becker},
  title        = {ΩFFΣLLIα: Helicoidal-Zeta quantization layer for GGUF / llama.cpp},
  year         = {2026},
  howpublished = {Hugging Face},
  note         = {Determinístic, reversible per-block pre-conditioning kernel},
  url          = {https://huggingface.co/Brunobkr}
}

---

🙏 Créditos

• Modelo original: <empresa/autor>
• Quantização GGUF (ΩFFΣLLIα / Helicoidal-Zeta): Bruno Becker — Brunobkr