Tensor Logic

Fonte: source/classes/tensorlogic.prg, source/function/fwtensor.c

FiveWin implementa Tensor Logic: The Language of AI de Pedro Domingos (arXiv:2510.12269). A ideia-chave: uma regra lógica e uma soma de Einstein são a mesma operação. Um programa é um conjunto de equações tensoriais; cada equação faz o join dos tensores do lado direito (produto sobre índices compartilhados), projeta os índices que não aparecem no lado esquerdo (soma) e aplica opcionalmente uma não-linearidade. Um mesmo motor executa redes neurais (atenção, MLPs) e raciocínio simbólico (Datalog sobre tabelas DBF) — e pode diferenciar qualquer programa automaticamente.

Início rápido

1. Compile a biblioteca FWH com sua variante (p.ex. mfwh_new.bat hb32) para que tensorlogic.prg e fwtensor.c estejam na lib.
2. A partir de samples\ai, compile e execute o companheiro do tutorial:

   cd /d C:\fwteam\samples\ai
   C:\fwteam\samples\build_new.bat tltutor hb32
   tltutor.exe

   A saída fica em tltutor.log. Leia-a junto com o tutorial passo a passo.
3. Velocidade opcional: coloque libopenblas.dll no PATH ou junto ao exe (ou defina FWT_BLAS_DLL). Verifique com ? FWT_BlasActive().

Equações tensoriais

oTL := TTensorLogic():New()
oTL:Let( "W", { { 1, -1, 0 }, { 0, 1, -1 } } )     // liga tensores (arrays o FW_Tensor)
oTL:Let( "X", { 1, 2, 0.5 } )
oTL:Let( "B", { 2, -2 } )
oTL:Eq( "Y[i] = step( W[i,j] * X[j] + B[i] )" )    // um perceptron, uma equacao
oTL:Run()                                          // forward chaining até ponto fixo
? oTL:GetArray( "Y" )                              // {1, 0}

Índices repetidos à direita são joinados; os ausentes à esquerda são somados. Não-linearidades: step, sigmoid, relu, tanh, gelu, softmax (último índice), lnorm (layer norm, último índice, sem parte afim — gamma/beta são expressas como equações adicionais). Fatores numéricos escalam um termo: "S[p,q] = Q[p,k] * K[q,k] * 0.7071".

Sintaxe de equações

Termos com qualquer número de fatores são avaliados encadeando contrações em pares: só sobrevivem as letras ainda necessárias para a saída, de modo que cada passo pode usar o caminho rápido GEMM do OpenBLAS.

Se o parse falhar, Eq() retorna .F. e preenche oTL:cError.

TTensorLogic

DATA: hTensors, aEqs, cError, hPre, hGrads, aParams, hAdamM, hAdamV, nAdamT.

Padrões de loop de treino

// Amostra única / batch completo
oTL:Forward()
oTL:ZeroGrad()
oTL:Seed( "Y", FWT_Scale( FWT_Sub( oTL:Get( "Y" ), tTarget ), 2 ) )  // d MSE
oTL:Backward()
oTL:ClipGrads( 1.0 )
oTL:StepAdam( 0.05 )

// Acumulação por mini-batch (estilo TTransformerTL)
oTL:ZeroGrad()
for i := 1 to nBatch
   oT:AccumStep( aIds[i], aTgt[i], 1 / nBatch )   // grads de params somam
next
oTL:ClipGrads( 1.0 )
oTL:StepAdam( nLr )

TTLDomain

Mapa entidade ↔ índice compartilhado por todas as relações para que as dimensões coincidam.

TTransformerTL

Fachada transformer estilo GPT sobre um programa de tensor logic (~15 equações por camada). As cabeças são um índice (sem fatiar colunas): WQ[d,h,k] absorve o repart por cabeça e WO[h,k,d] absorve concat+Wo. Com os mesmos pesos reproduz ForwardSeq() da classe Transformer clássica de perto, e treina e gera com o autodiff genérico — zero código de backprop específico.

oTLT := TTransformerTL():New( 2, 8, 2, nVocab )
aProbs := oTLT:ForwardSeq( { 2, 3, 4, 5, 6 } )
nLoss  := oTLT:TrainStep( aIds, aTargets, 0.01 )
aOut   := oTLT:Generate( { 1 }, 8 )
// multi-batch:
oTLT:oTL:ZeroGrad()
for i := 1 to nBatch
   oTLT:AccumStep( aWin[i], aTgt[i], 1 / nBatch )
next
oTLT:oTL:ClipGrads( 1.0 )
oTLT:oTL:StepAdam( nLr )

Esqueleto de atenção como equações (de BuildProgram()):

oTL:Eq( "Q[h,p,k] = H0[p,d] * WQ[d,h,k]" )
oTL:Eq( "S[h,p,q] = Q[h,p,k] * K[h,q,k] * 0.5 + OnesH[h] * Mask[p,q]" )
oTL:Eq( "A[h,p,q.] = softmax( S[h,p,q] )" )
oTL:Eq( "O[h,p,k] = A[h,p,q] * V[h,q,k]" )
oTL:Eq( "Att[p,d] = O[h,p,k] * WO[h,k,d]" )
oTL:Eq( "N1[p,d] = lnorm( Att[p,d] + H0[p,d] )" )   // residual + layer norm
// ... FFN, segunda norma, proyeccion a vocabulario, softmax

Datalog sobre tabelas DBF

USE tlfam ALIAS FAM NEW              // campos PARENT, CHILD
oDom := TTLDomain():New()
oDom:Harvest( "FAM", { "PARENT", "CHILD" } )       // fixar o domínio primeiro
oTL:LetDbf( "Parent", "FAM", { "PARENT", "CHILD" }, oDom )
oTL:LetSet( "Male", { "abe", "homer" }, oDom )
oTL:Let( "NotEq", TL_NotEq( oDom:Len() ) )
oTL:Let( "Ancestor", FWT_New( { oDom:Len(), oDom:Len() } ) )

oTL:Eq( "Father[x,y] = step( Parent[x,y] * Male[x] )" )
oTL:Eq( "Sibling[x,y] = step( Parent[p,x] * Parent[p,y] * NotEq[x,y] )" )
oTL:Eq( "Ancestor[x,y] = step( Parent[x,y] + Ancestor[x,z] * Parent[z,y] )" )  // recursiva
oTL:Run( 20 )                                      // ponto fixo
AEval( oTL:Query( "Ancestor", oDom ), {| a | QOut( a[1] + " -> " + a[2] ) } )

Raciocínio em espaço de embeddings (a ponte neuro-simbólica do paper): entidades como vetores unitários, a relação embutida, consulta inversa e sigmoide com temperatura — T→0 dedutivo (0/1 duro), T alto analógico:

oE:Let( "Emb", TL_UnitEmb( n, 256, 1.234 ) )
oE:Eq( "EmbR[i,j] = Parent[x,y] * Emb[x,i] * Emb[y,j]" )
oE:Eq( "Score[x,y] = EmbR[i,j] * Emb[x,i] * Emb[y,j]" )   // ~1 se (x,y) está em Parent
tSoft := FWT_Sigmoid( tShifted, nTemperature )

Helpers (PRG)

Motor C (fwtensor.c)

Aceleração OpenBLAS

fwtensor.c carrega OpenBLAS dinamicamente no primeiro uso — nunca é uma dependência obrigatória: libopenblas.dll no PATH ou junto ao exe, o la variable de entorno FWT_BLAS_DLL (com off força os loops C portáveis; também detecta builds ILP64 como libscipy_openblas64_ do numpy). FWT_MatMul e todo FWT_EinSum de 2 operandos redutível a um GEMM (em lote) roda sobre cblas_sgemm, usando as transposições do BLAS para que os padrões de atenção não precisem de reempacotamento.

O OpenBLAS do numpy alcança 446 GFLOPS no matmul de 1024 na mesma máquina — o einsum do FWH iguala o desempenho classe BLAS; a distância restante ao PyTorch são os kernels AVX-512 do MKL e menor overhead por chamada, não a linguagem.

Exemplos

• samples/ai/tltutor.prg — companheiro executável do tutorial (lições 1–9 → tltutor.log).
• samples/ai/tensorlogic.prg — suíte do motor: einsum vs matmul, cabeça de atenção em 6 equações, ponto fixo Datalog, verificações de gradiente vs diferenças finitas, treino XOR (9 PASS).
• samples/ai/tltransformer.prg — transformer como equações, paridade com a classe clássica, treino + geração (3 PASS).
• samples/ai/tldatalog.prg — Datalog sobre um DBF familiar + raciocínio em embeddings com temperatura (6 PASS).
• samples/ai/tlbench.prg — benchmark de einsum, BLAS vs loops C.
• samples/ai/tlminillm.prg — mini-LLM estilo DeepSeek/MiMo como equações puras: atenção latente MLA, RoPE, mixture-of-experts, predição multi-token (3 PASS).
• samples/ai/tlfwcode.prg — modelo de linguagem char-level sobre fontes FWH reais: Adam + warmup/cosine, acumulação por lotes, clipping, split train/val, checkpoint do melhor-val com resume, sampling top-k. Configurável com TLFW_*; resume com TLFW_RESUME=1.
• samples/ai/tlc.prg — receita de treino sintético de código em miniatura: gerador + oráculo exato, aprendizado de execução (36–40% vs 10% acaso) e decoding com máscara gramatical (100% válido mesmo sem treinar).

Compilar qualquer exemplo da mesma forma:

cd /d C:\fwteam\samples\ai
C:\fwteam\samples\build_new.bat <nombre> hb32
<nombre>.exe

Veja também

• Tutorial Tensor Logic (de 0 a 100)
• Transformer Neural Network
• PyTorch-lite roadmap
• Classes alfabético