Tensor Logic

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

FiveWin implementa Tensor Logic: The Language of AI de Pedro Domingos (arXiv:2510.12269). Su idea clave: una regla lógica y una suma de Einstein son la misma operación. Un programa es un conjunto de ecuaciones tensoriales; cada ecuación hace el join de los tensores de su lado derecho (producto sobre índices compartidos), proyecta los índices que no aparecen en el lado izquierdo (suma) y aplica opcionalmente una no-linealidad. Un mismo motor ejecuta redes neuronales (atención, MLPs) y razonamiento simbólico (Datalog sobre tablas DBF) — y puede diferenciar cualquier programa automáticamente.

Inicio rápido

1. Compila la librería FWH con tu variante (p.ej. mfwh_new.bat hb32) para que tensorlogic.prg y fwtensor.c estén en la lib.
2. Desde samples\ai, compila y ejecuta el compañero del tutorial:

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

   La salida queda en tltutor.log. Léela junto al tutorial paso a paso.
3. Velocidad opcional: pon libopenblas.dll en el PATH o junto al exe (o define FWT_BLAS_DLL). Comprueba con ? FWT_BlasActive().

Ecuaciones tensoriales

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] )" )    // un perceptron, una ecuacion
oTL:Run()                                          // forward chaining hasta punto fijo
? oTL:GetArray( "Y" )                              // {1, 0}

Los índices repetidos a la derecha se joinean; los que faltan a la izquierda se suman. No-linealidades: step, sigmoid, relu, tanh, gelu, softmax (último índice), lnorm (layer norm, último índice, sin parte afín — gamma/beta se expresan como ecuaciones adicionales). Los factores numéricos escalan un término: "S[p,q] = Q[p,k] * K[q,k] * 0.7071".

Sintaxis de ecuaciones

Los términos con cualquier número de factores se evalúan encadenando contracciones por pares: solo sobreviven las letras aún necesarias para la salida, de modo que cada paso puede usar el camino rápido GEMM de OpenBLAS.

Si el parseo falla, Eq() devuelve .F. y rellena oTL:cError.

TTensorLogic

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

Patrones de bucle de entrenamiento

// Muestra ú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 )

// Acumulación por mini-batch (estilo TTransformerTL)
oTL:ZeroGrad()
for i := 1 to nBatch
   oT:AccumStep( aIds[i], aTgt[i], 1 / nBatch )   // grads de params se suman
next
oTL:ClipGrads( 1.0 )
oTL:StepAdam( nLr )

TTLDomain

Mapa entidad ↔ índice compartido por todas las relaciones para que las dimensiones coincidan.

TTransformerTL

Fachada transformer estilo GPT sobre un programa de tensor logic (~15 ecuaciones por capa). Las cabezas son un índice (sin trocear columnas): WQ[d,h,k] absorbe el reparto por cabeza y WO[h,k,d] absorbe concat+Wo. Con los mismos pesos reproduce ForwardSeq() de la clase Transformer clásica de cerca, y entrena y genera con el autodiff genérico — cero 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 atención como ecuaciones (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 tablas DBF

USE tlfam ALIAS FAM NEW              // campos PARENT, CHILD
oDom := TTLDomain():New()
oDom:Harvest( "FAM", { "PARENT", "CHILD" } )       // fijar el dominio primero
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 )                                      // punto fijo
AEval( oTL:Query( "Ancestor", oDom ), {| a | QOut( a[1] + " -> " + a[2] ) } )

Razonamiento en espacio de embeddings (el puente neuro-simbólico del paper): entidades como vectores unitarios, la relación embebida, consulta inversa y sigmoide con temperatura — T→0 deductivo (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 si (x,y) esta en Parent
tSoft := FWT_Sigmoid( tShifted, nTemperature )

Helpers (PRG)

Motor C (fwtensor.c)

Aceleración OpenBLAS

fwtensor.c carga OpenBLAS dinámicamente en el primer uso — nunca es una dependencia dura: libopenblas.dll en el PATH o junto al exe, o la variable de entorno FWT_BLAS_DLL (con off fuerza los bucles C portables; también detecta builds ILP64 como libscipy_openblas64_ de numpy). FWT_MatMul y todo FWT_EinSum de 2 operandos reducible a un GEMM (por lotes) corre sobre cblas_sgemm, usando las transposiciones de BLAS para que los patrones de atención no necesiten reempaquetado.

El OpenBLAS de numpy alcanza 446 GFLOPS en el matmul de 1024 en la misma máquina — el einsum de FWH iguala el rendimiento clase BLAS; la distancia restante a PyTorch son los kernels AVX-512 de MKL y menor overhead por llamada, no el lenguaje.

Ejemplos

• samples/ai/tltutor.prg — compañero ejecutable del tutorial (lecciones 1–9 → tltutor.log).
• samples/ai/tensorlogic.prg — suite del motor: einsum vs matmul, cabeza de atención en 6 ecuaciones, punto fijo Datalog, comprobaciones de gradiente vs diferencias finitas, entrenamiento XOR (9 PASS).
• samples/ai/tltransformer.prg — transformer como ecuaciones, paridad con la clase clásica, entrenamiento + generación (3 PASS).
• samples/ai/tldatalog.prg — Datalog sobre un DBF familiar + razonamiento en embeddings con temperatura (6 PASS).
• samples/ai/tlbench.prg — benchmark de einsum, BLAS vs bucles C.
• samples/ai/tlminillm.prg — mini-LLM estilo DeepSeek/MiMo como ecuaciones puras: atención latente MLA, RoPE, mixture-of-experts, predicción multi-token (3 PASS).
• samples/ai/tlfwcode.prg — modelo de lenguaje char-level sobre fuentes FWH reales: Adam + warmup/cosine, acumulación por lotes, clipping, split train/val, checkpoint del mejor-val con resume, sampling top-k. Configurable con TLFW_*; resume con TLFW_RESUME=1.
• samples/ai/tlc.prg — receta de entrenamiento sintético de código en miniatura: generador + oráculo exacto, aprendizaje de ejecución (36–40% vs 10% azar) y decoding con máscara gramatical (100% válido incluso sin entrenar).

Compilar cualquier ejemplo igual:

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

Ver también

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