LHA — Documento de Falseabilidade, Revisão de Pares e Protocolo Experimental v1

Resumo Executivo

• Reivindicação central (U_uni): decisão de primalidade 100% determinística usando apenas aritmética posicional (sem √n, crivos ou 6k±1 no algoritmo).
• Prova curta: para n com k dígitos, testar todos os p ≤ 10^⌈k/2⌉ cobre todos os fatores ≤ √n. Implementamos via resto posicional S_p(n).
• Auditor paralelo: ferramenta independente (ex.: crivo ou divisão por primos ≤ √n) usada apenas para comparação em relatórios.
• U_dir+ (opcional): heurística rápida com wheel M=210, DMFP⁺ estendido e escore GSR para acurácia prática elevada.

Sumário de Terminologias

Postulados e Prova de Corretude (U_uni)

Prova por magnitude dos dígitos

Postulado P1 (Cobertura por magnitude):
  Para n com k dígitos, defina B(k) = 10^⌈k/2⌉ e P_k = {{ p primo | p ≤ B(k) }}.
  Se ∀ p∈P_k: S_p(n) ≠ 0 (e n ≠ p), então n é primo.

Esboço da prova:
  Todo composto n=ab tem um fator primo ≤ √n. Como √n ≤ 10^{k/2} ≤ 10^⌈k/2⌉, então
  esse fator primo pertence a P_k. Logo, se nenhum p∈P_k divide n, n não tem fatores
  primos ≤ √n, portanto é primo.
  Observação: √n não é computado no algoritmo; aparece apenas na justificativa teórica.
  

Algoritmo U_uni (pseudocódigo)

isPrime_Uuni(n):
  if n < 2: return False
  if n in {{2,3,5,7}}: return True
  // Wheel forte
  M = 210; if (n % M) ∉ Res(M): return False
  k = número_de_dígitos(n); B = 10^ceil(k/2)
  P_k = {{primos p | p ≤ B}}  // cache por k
  para p em P_k:
      if S_p(n) == 0 and n != p: return False
  return True
  

Argumento de Não Tautologia

• O algoritmo decide usando apenas S_p(n) e P_k, sem crivos internos nem √n.
• A prova usa √n apenas como limite teórico para garantir cobertura; não há circularidade entre prova e algoritmo.
• O método é falseável: qualquer n cujo resultado divergir de um auditor independente refuta a implementação.

Ferramentas Integradas para Falseamento (nesta página)

Implementação (JS) — U_uni e Auditor

Protocolo de Falseabilidade (passo a passo)

1. Escolha um intervalo (ex.: 2..10^6) e gere a verdade de referência (auditor: crivo ou divisão por primos ≤ √n).
2. Rode U_uni nos mesmos n. Registre TP, TN, FP, FN. Um único FP ou FN refuta a implementação.
3. Documente qualquer divergência (n, fator primo, p que divide n).
4. (Opcional) U_dir+: reporte acurácia, precisão, recall e F1; ajuste τ por faixas de k para aplicações específicas.

Snippet Python (referência reproduzível)

from math import gcd, isqrt

def primes_upto(n):
    bs = bytearray(b"\x01")*(n+1)
    bs[0:2] = b"\x00\x00"
    p=2
    while p*p<=n:
        if bs[p]:
            bs[p*p:n+1:p] = b"\x00"*(((n-p*p)//p)+1)
        p+=1
    return [i for i,b in enumerate(bs) if b]

def Spos(n,p):
    s=0
    for ch in str(n): s=(s*10+ord(ch)-48)%p
    return s

def U_uni(n):
    if n<2: return False
    if n in (2,3,5,7): return True
    M=210
    if gcd(n,M)!=1: return False
    k=len(str(n)); B=10**((k+1)//2)
    for p in primes_upto(B):
        if n!=p and Spos(n,p)==0: return False
    return True

def auditor(n):
    if n<2: return False
    if n%2==0: return n==2
    for p in range(3,isqrt(n)+1,2):
        if n%p==0: return n==p
    return True
  

Exemplo que Funciona

• N = 233: U_uni ⇒ PRIMO; Auditor ⇒ PRIMO; Concordância total.
• N = 221: U_uni ⇒ COMPOSTO (13×17); Auditor ⇒ COMPOSTO; Concordância total.

U_dir+ (Opcional, para aplicações rápidas)

Wheel M=210; DMFP⁺ = {{3,5,7,11,13,17,19,23}}; escore GSR em offsets ±2/±4/±6/±8/±10 com limiar τ=4. Reporte métricas por faixas de 100k e amostras de FP/FN.