Nada roda até você pedir. Esta página não cria nenhum contexto
WebGL2 ao abrir: o canvas nasce no clique e o código é buscado de
/shaders. A página inteira usa um único contexto
compartilhado, então um shader anima por vez — é o que impede o navegador de
estourar o limite de contextos e travar a aba. Rodar outro no lugar do atual
devolve o primeiro ao estado inicial.
No benchmark.py da branch pure_physics_PsiQRH eu classifico
cada módulo com uma etiqueta, e a maioria não é o que um leitor apressado esperaria.
Reproduzo a tabela aqui porque ela é o contexto honesto desta página:
| Módulo | O que afirma | Status |
|---|---|---|
| M2 | Espaço de Hilbert π-primo (norma, comutatividade, fluxo) | EXACT |
| M3 | Evolução hamiltoniana, autograd-safe | EXACT |
| M4 | Rotação SO(4) por produto de Hamilton | EXACT |
| M5 | Dimensão fractal por box-counting | EMPIRICAL_NS |
| M6 | Sonda de onda de Padilha | EMPIRICAL_NS |
| M7 | Acoplamento D→α (dimensão fixa o filtro) | EXACT |
| M8 | Atenção espectral F(k)=exp(i·α·arctan(ln|k|+1)) | EMPIRICAL_NS |
| M9 | Codificação Leech lattice Λ₂₄ | APPROX |
| M11 | Eficiência de parâmetros α* | EMPIRICAL_NS |
EXACT igualdade matemática ou de ponto flutuante · EMPIRICAL_NS medido, mas sem significância estatística · APPROX abordagem correta, implementação simplificada
O que isso significa na prática: a álgebra do ΨQRH é exata e verificável — conservação de norma, não-comutatividade, fluxo. O ganho empírico sobre um transformer comum ainda não apareceu com p < 0,05 nas medições que fiz. Os shaders abaixo respeitam essa distinção.
Filtro Espectral Causal
Cada frequência do plano recebe uma fase que cresce com arctan(ln|k|). Frequências baixas giram pouco; altas saturam em ±π/2. O filtro é puro de fase: a energia é preservada, só a fase muda.
Os anéis são iso-fases de arctan(ln|k|). O espaçamento cresce devagar porque o log comprime a escala, e o arctan satura a fase em ±π/2. O matiz é a fase; o módulo é 1 em todo lugar.
Este é o M8 do meu benchmark. A atenção espectral não-causal vaza tokens futuros — o teste de deslocamento no código detecta isso e eu deixo o aviso no relatório. E o status é [EMPIRICAL_NS]: medindo contra um transformer comum nos dados que usei, a diferença não chegou a p < 0,05. O que é exato aqui é só a unitariedade: |F(k)| = 1, logo a norma L2 é preservada por Parseval.
Aplicação: uma FFT direta e uma inversa. O filtro em si é O(n); o custo é o da FFT.
shaders/filtro-espectral-causal.glsl.
Espaço de Hilbert π-primo
M2 — ESPAÇO DE HILBERT π-PRIMO |ψ_w⟩ = Σ_i α_i |e_i⟩ , ‖ψ_w‖ = 1 O estado é um vetor complexo de norma unitária. A evolução é unitária: ρ' = U ρ U†, e a norma se conserva por construção. Aqui cada pixel é um estado candidato. Montamos o vetor em coordenadas polares (raio, ângulo) na base de dimensão d, normalizamos, e mostramos: - raio → proximidade da esfera unitária - matiz → fase acumulada - anéis → iso-norma ‖ψ‖ = 1
Cada ponto do plano é um estado |ψ⟩ escrito na base {|eᵢ⟩}. O raio é
O que é exato é a norma: normalizar e depois medir ‖ψ‖ devolve 1
Uma normalização e uma rotação de fase por pixel. O(d) por pixel
shaders/hilbert-pi-primo.glsl.
Rotação Quaterniônica SO(4)
A atenção tratada como rotação 4D. Cada ponto do plano vira um quaternion puro, é rotacionado por um eixo que varia pelo campo e reprojetado. A rotação preserva a norma — só a orientação muda.
Cada ponto vira um quaternion puro e é conjugado por q: v ↦ q⊗v⊗q†. O eixo varia suavemente pelo campo, então a rotação torce diferente em cada região. A norma é preservada — só a orientação muda.
Este é o M4 e é [EXACT]: o módulo SO4Layer passa no teste de conservação de norma (ΔNorm < 1e-4), no teste de não-comutatividade (i*j = k, j*i = −k) e no autograd. No Lampreia eu documentei um bug real na versão anterior: psi0 era torch.randn(4) sem normalizar, então a saída não tinha norma 1 apesar da rotação ser unitária. Aqui a entrada é construída com norma fixa.
Um produto de Hamilton custa 16 multiplicações. O layer SO(4) usa 6 parâmetros — 3 ângulos para cada quaternion — contra 16 de uma camada complexa por prime.
shaders/rotacao-quaternionica-so4.glsl.
Bound de Cauchy-Schwarz — o que a prova cobre
A esfera de raio ‖v⊥‖‖q⊥‖ é o teto PROVADO do erro de aproximação. Verde = o bound sozinho exclui o documento. Laranja = quem exclui é o corte heurístico k1, sem prova por documento. Rode o slider k1 para ver a fatia laranja crescer e a verde sumir.
Verde = o teto provado (score+teto) ficou abaixo do corte: o documento sai com prova. Laranja = só não entrou no top-k1: sai sem prova por documento. Azul = sobrevive e vai para avaliação exata. Mova o slider k1 e a fatia laranja domina quando o corte aperta.
A desigualdade em si é [EXACT]: ⟨v,q⟩ ≤ ⟨Pv,Pq⟩ + ‖v⊥‖‖q⊥‖ vale para qualquer projeção ortogonal. O que não é garantido é que todo descarte carregue prova. Medi no meu motor 1.9.8 com arXiv d=1536 e basis=random: pruned_by_bound = 0,0% e pruned_by_prefilter = 95,0%. Com basis=pca_corpus a proporção inverte para 88,1% / 7,4%. Ou seja: a fração de descarte com prova depende da basis, e em alta dimensão com basis aleatória ela é praticamente zero.
O post-filter avalia k1·N documentos exatos por query: 50.000 de 1M em SIFT-1M, ~33,8 ms — mais lento que HNSW (~0,2 ms) por desenho. O certificado completo (search_audited) faz 2 scans O(N) e custa 186,8 ms em N=500K.
shaders/bound-cauchy-schwarz.glsl.
Evolução hamiltoniana (leapfrog)
M3 — EVOLUÇÃO HAMILTONIANA H(q,p) = U(q) + K(p), K(p) = ½ pᵀ M⁻¹ p, U(q) = −log π(q) dq/dt = M⁻¹ p dp/dt = −∇U(q) Integrador: leapfrog / velocity Verlet (simplético) p_{n+½} = p_n − (ε/2) ∇U(q_n) q_{n+1} = q_n + ε M⁻¹ p_{n+½} p_{n+1} = p_{n+½} − (ε/2) ∇U(q_{n+1}) Simplético ⇒ o volume de fase se conserva e H erra só por termos limitados, em vez de derivar sem limite.
Cada pixel segue a órbita de um integrador simplético na sua energia.
A conservação de energia é exata no contínuo e aproximada no passo
Um passo de leapfrog por unidade de tempo, O(1) por pixel. Nada de
shaders/hamiltoniano-leapfrog.glsl.
Projetor de Manifold
P = XXᵀ com X = top-r autovetores da covariância das embeddings. A idempotência P²=P é verificada numericamente em cada pixel (o erro aparece no indicador). Aumente r: o subespaço cobre mais variância e o resíduo ortogonal encolhe.
A componente no subespaço principal aparece em cor; o resíduo ortogonal, em cinza. As duas retas claras são as direções e1/e2. O erro de idempotência ‖P²v − Pv‖ é calculado em cada pixel e deve ser ~0.
O projetor é [EXACT] por construção: P = XXᵀ satisfaz P² = P e Pᵀ = P, e isso eu verifico numericamente. Mas o ganho de qualidade é medido: recall@10 de 0,96 contra o ceiling no pipeline RAG (arXiv d=1536), 0 violações. Para geração de texto a perplexidade ficou entre 10 e 71 milhões — o modelo roda, não gera texto coerente. As fases C/D/E seguem pendentes.
Covariância O(VD²); power iteration O(D²·r·iters) contra O(D³) da eigendecomposição densa. A D=2048 medi ~73 s em CPU única — o ganho é assintótico, e em D baixo a rota densa ainda vence.
shaders/projetor-de-manifold.glsl.
Acoplamento dimensão → filtro
M7 — ACOPLAMENTO DIMENSÃO → FILTRO α(D) = α₀ (1 + λ (D − D_e) / D_e) , cortado em [0.1, 3.0] D_e = 2 é a dimensão euclidiana de referência. D > 2 (textura mais "cheia") empurra α para cima; D < 2 (mais próximo de uma curva) empurra para baixo. λ governa o quanto. A ligação: M5/M6 medem D; M7 converte D em α; M8 usa α no filtro F(k) = exp(i α arctan(ln|k|+ε)).
A dimensão fractal D do sinal decide a força do filtro de fase α.
A fórmula do acoplamento é exata — ela é uma reta com corte, e eu
Uma avaliação de α(D) e uma do filtro por pixel. Desprezível.
shaders/acoplamento-dimensao-alfa.glsl.
A equação de Padilha como sonda
A equação, termo a termo: f(λ,t) = I₀·sin(ωt + αλ) · exp( i(ωt − kλ + βλ²) ) └── envelope real ─┘ └── fase complexa ──┘ O termo βλ² é o que distingue isto de uma onda plana: a frequência instantânea é a derivada da fase em λ, f_inst(λ) = (2βλ − k) / 2π e cresce linearmente. É o chirp da óptica de laser que eu reaproveitei como sonda do espaço semântico.
O traço é Re{f}. A curva laranja é a frequência instantânea f_inst=(2βλ−k)/2π. Onde ela sobe, as cristas adensam — é o chirp dado pelo termo βλ².
No meu benchmark M6, esta sonda mede a dimensão fractal D pelo declive do espectro de potência e compara com box-counting. O resultado saiu [EMPIRICAL_NS]: as duas estimativas concordam dentro da variabilidade do box-counting, mas não com significância estatística. A sonda não é uma função de ativação — é um instrumento de medição, e como instrumento ela ainda não provou que mede melhor que o método barato.
Uma FFT por medição. O papel dela no pipeline é alimentar o acoplamento D→α (M7), que é a parte exata.
shaders/chirp-de-padilha.glsl.
Leech Λ₂₄ — e o que eu de fato implementei
M9 — LEECH Λ₂₄ E A APROXIMAÇÃO D₂₄ Λ₂₄ = { x ∈ ℝ²⁴ : x·x ∈ 2ℤ , x ≡ c (mod 2) para algum c ∈ G₂₄ } G₂₄ = { c ∈ 𝔽₂²⁴ : H cᵀ = 0 } , H é 12×24 D₂₄ = { x ∈ ℤ²⁴ : todas as coordenadas têm a MESMA paridade } D₂₄ ⊂ Λ₂₄. Implementar só D₂₄ é o que eu fiz — e é o que se vê.
Os pontos claros são o reticulado que eu efetivamente implementei:
Este é o shader mais desonesto da página se lido rápido, então eu
Uma checagem de paridade por amostra. Projetar 24D em 2D é O(24).
shaders/leech-lattice-d24.glsl.
Processador Fractal Óptico
O campo de distância fractal, com a dobra de espaço que gera a auto-similaridade hierárquica. Determinístico, mas sensível à fase: caos controlado. A cor vem da fase óptica.
A dobra p ← (2,8,2.5) − |abs(p)·e − (4,1.3,4)| aplicada 14 vezes gera a auto-similaridade hierárquica. O acúmulo g += mod(|p.xz|, p.y)/s é o caos controlado: determinístico, sensível à fase inicial.
Preciso ser direto: este shader é uma visualização de campo fractal de distância. Ele NÃO é a equação de onda de Padilha — essa é um chirp, e está no outro shader. O paper 'Processador Fractal Óptico' é conceitual e declara as propostas como exploratórias; ele não publica uma equação de campo executável. Chamar isto de 'a matemática do paper' seria impreciso, e eu já cometi esse erro numa versão anterior desta página.
90 iterações externas × 14 internas por pixel — caro para GPU modesta. As cifras <0,05 pJ/op e o espectro de Hofstadter do paper são proposta de arquitetura fotônica, não medição de software.
shaders/processador-fractal-otico.glsl.
O pipeline inteiro, num quadro
M12 — PIPELINE COMPLETO 1. π-embedding : x → representação em base π 2. SO(4) : Ψ' = q_L Ψ q_R† (norma preservada) 3. filtro : F(k) = exp(i α arctan(ln|k|+ε)), |F| = 1 4. acoplamento : Ψ ← Ψ + g·D→α (fraco) 5. Born : p_i = |c_i|² → logits
Cinco faixas verticais, na ordem em que o dado atravessa o pipeline.
Este é o [EMPIRICAL_NS] mais desconfortável da página: o pipeline
Uma FFT por token de entrada, mais O(n log n) por camada. O ganho
shaders/pipeline-m12.glsl.
Superposição — quem mais responde quando uma feature acende
Cada célula (i,j) é o produto interno wᵢ·wⱼ entre duas features, ambos de norma 1. A diagonal é 1 em toda a matriz (a feature responde a si mesma). O que aparece fora dela é a interferência: a feature j respondendo quando a i acende. Reduza d e o bloco cresce.
As linhas seguem a ordem de importância: a linha 0 é a mais importante. Em d ≥ n a matriz é uma diagonal perfeita — uma direção dedicada por feature, leitura trivial. Conforme d cai, os pontos fora da diagonal se multiplicam e se agrupam em blocos. A varredura acende uma linha por vez: tudo o que compartilha a direção dela acende junto. Em d = 1 a matriz inteira fica acesa, porque G ≡ 1: com uma só direção todas as features são o mesmo vetor e nenhuma pode ser distinguida.
Esta matriz NÃO são os pesos de um LLM e não foi aprendida por gradient descent. É uma alocação que eu construí por regra explícita: as primeiras features recebem eₚ dedicado; as demais caem numa direção por hash e se inclinam dentro de um arco, tanto mais aglomeradas quanto menos importantes. Duas ressalvas que a imagem mostra: colisões de hash podem fazer uma feature menos importante cair na direção de uma dedicada, então a "dedicação" das primeiras não é absoluta; e esta construção não é o ótimo de nenhuma perda — é apenas uma geometria plausível. O que é exato é a álgebra: dado W, G = WWᵀ e a leitura linear x̂ = Gx. Que um modelo treinado chegue a essa geometria bloco-semi-ortogonal é o resultado empírico de Elhage et al. (2022) e Scherlis et al. (2022); eu não o reproduzo aqui.
A conta é exata: G_ij = wᵢ·wⱼ é o produto interno literal de dois vetores unitários, sem aproximação. O shader avalia essa expressão por célula a cada frame.
shaders/superposicao-gram.glsl.
O que a curvatura separa, e o que ela não separa
Esquerda: o embedding paramétrico do registro, com acoplamento λ–t. Direita: um embedding separável, o análogo de wte+wpe. A cor é a curvatura gaussiana K com escala logarítmica e sinal. A tela não mostra "um modelo melhor que o outro" — mostra de onde vem a diferença estrutural.
Azul é K negativo (sela), âmbar é K positivo (cúpula), preto é K≈0. Repare que o painel da direita NÃO é preto: o embedding separável também tem curvatura. O que ele não tem é acoplamento — a derivada mista f_λt é identicamente nula à direita, e é isso, não K, que distingue os dois. Mexa em β: é o termo quadrático βλ², a "dispersão" do chirp, que deforma as faixas.
Este shader calcula a curvatura EXATA de duas funções escritas à mão; ele não treina nada e não mede nenhum modelo. A função da direita é um substituto explícito: um lookup table real (wte+wpe) é uma função arbitrária de uma variável, e aqui uso seno porque é suave e fechado em forma. Duas correções ao registro, ambas verificáveis: (1) as fórmulas publicadas de f_λλ e f_λt na seção 5.4 estão erradas — trocam sin por cos e omitem termos cruzados; o K da seção 5.5 (médio 0,845) não sai dessas fórmulas com os parâmetros treinados da seção 5.6; (2) a afirmação da seção 6.3 de que "K=0 é propriedade de embeddings lineares" é falsa, e este painel direito é a contraprova — o que se anula no embedding separável é f_λt = 0, não K.
Tudo aqui é forma fechada: as cinco derivadas parciais são diferenciadas à mão e conferidas contra sympy. Não há aproximação por diferenças finitas em lugar nenhum, que era justamente o erro do benchmark original (torch.diff ao longo da sequência media uma curva 1D, cuja curvatura gaussiana é zero por definição).
shaders/curvatura-acoplamento.glsl.
A única coisa que a curvatura de fato separa
Esquerda: o embedding paramétrico do registro. Direita: uma soma separável, o análogo de wte+wpe. A cor é altura, a luz vem da normal analítica. O que muda entre os dois não é ter ou não curvatura — é a FORMA da curvatura.
Repare na direita: as cristas correm sempre na horizontal e na vertical. É uma chapa ondulada, soma de duas curvas 1D, e a derivada mista f_λt é exatamente zero em todo ponto. Na esquerda as cristas se inclinam e se cruzam em diagonais — isso é acoplamento: mover λ muda a fase em t. O slider α deforma essas diagonais, mas não as apaga: mesmo com α = 0 a derivada mista continua não-nula em 100% dos pontos, porque ωt aparece dentro dos dois fatores. Não há posição do slider em que a esquerda vire a direita.
Duas correções a afirmações do próprio registro, ambas verificáveis por sympy. (1) A seção 6.3 diz que "K=0 é propriedade de embeddings lineares" — é falso: o painel da direita tem K≠0 em 100% dos pontos que amostrei. O que se anula no embedding separável é a derivada mista f_λt, não a curvatura gaussiana. (2) As fórmulas de f_λλ e f_λt publicadas na seção 5.4 estão erradas: trocam seno por cosseno e omitem termos cruzados, e o K médio de 0,845 da seção 5.5 não é reproduzível a partir delas. Este shader usa as derivadas corrigidas, diferenciadas à mão e conferidas contra sympy.
Forma fechada, sem diferenças finitas. O erro do benchmark original foi justamente usar torch.diff ao longo do índice da sequência, o que mede a curvatura de uma curva 1D — e a curvatura gaussiana de uma curva é zero por definição, não por medição.
shaders/superficie-acoplada.glsl.
Reproduzir localmente
Cada arquivo está em /shaders/ com extensão .glsl
e compila em qualquer ambiente WebGL2 — incluindo
twigl.app e
glsl.app, no modo
300 es. Nesses ambientes troque uRes por
resolution e uTime por time.