# Enseñar a las máquinas a leer lógica

Canonical HTML: https://dsti.school/es/techblog/ensenar-a-las-maquinas-a-leer-logica

This Markdown copy is generated from the same DSTI static-site build as the canonical HTML page. It is intended for machine readability and concise retrieval.

[DSTI TechBlog](https://dsti.school/es/techblog) / AI is tech

Cuerpo docente AI is tech

Un modelo de lenguaje moderno sabe traducir un menú y sostener una conversación fluida, y sin embargo titubea al decir si un breve argumento es realmente válido. El director académico Hanna Abi Akl ha pasado buena parte de su doctorado en esa brecha —entre un argumento que suena correcto y uno que es correcto— y construyó un pequeño paquete Python abierto, [Common Logic Grammar Construction](https://github.com/HannaAbiAkl/clgc) (CLGC), para volver medible la pregunta. Aquí está la ciencia, la ingeniería que la sostiene, y un recuento honesto de lo que el trabajo logró y de lo que queda por mejorar.

![Hanna Abi Akl](https://media.dsti.school/wp-content/uploads/2024/10/11160155/DSTI-Hanna-Chief-Academic-Officer-1024x1024.avif)

Por Hanna Abi Akl Director académico, DSTI · exalumno de DSTI (MSc in Data Science & AI, 2018) · doctorando, Wimmics (Inria, CNRS, I3S, Université Côte d’Azur)

12 Sep 2026 22 min de lectura AI is tech

syllogistic-reasoning first-order-logic knowledge-representation neuro-symbolic-ai semantic-web small-language-models open-science

Figura — el efecto de contenido

**Figure:** Un silogismo inválido representado mediante un diagrama de Euler. Autos es un subconjunto de Vehículos; Animales es disjunto de Autos pero se traslapa con Vehículos. El traslape con estrella — un animal que también es un vehículo — satisface ambas premisas a la vez que contradice la conclusión, por lo que el argumento es inválido.

> **Figure caption:** Por qué la conclusión no se sigue: un animal puede ser un vehículo sin ser un auto; las premisas dejan la conclusión abierta — el argumento es inválido.

Un modelo de lenguaje moderno sabe redactar un ensayo, traducir un menú y sostener una conversación
fluida. Pregúntale si un breve argumento de tres líneas es válido , y ocurre algo más delicado. Ese
espacio delicado — entre un argumento que suena correcto y uno que es correcto — es donde he pasado
buena parte de mi doctorado, y es el tema de este artículo.

El texto sigue dos hilos entrelazados. El primero es una pregunta científica: ¿cómo manejan la lógica los
modelos de lenguaje, y qué ocurre cuando le damos a un modelo el mismo problema lógico escrito en un
lenguaje formal distinto ? El segundo es una respuesta de ingeniería: un pequeño paquete Python abierto que
construí, llamado Common Logic Grammar Construction (CLGC) , que hace la pregunta medible y reproducible.
Me importan por igual ambos hilos, y los dos se conectan con lo que enseñamos en DSTI: la disciplina de la
documentación y el código limpio del módulo
[Clean IT](https://dsti.school/es/msc-data-science-ai#course-clean-it) del Warm-Up y nuestras pautas de
Software Engineering ([SE1](https://dsti.school/es/msc-data-analytics-ai#course-software-engineering-part-1)/[SE2](https://dsti.school/es/msc-data-analytics-ai#course-software-engineering-part-2));
el reflejo de la gramática de un lenguaje formal que construyen los cursos
[The Relational Model and SQL](https://dsti.school/es/bsc-informatica-ingenieria#course-the-relational-model-and-sql)
y [SQL](https://dsti.school/es/bsc-informatica-ingenieria#course-the-relational-model-and-sql) (Structured Query Language) — donde enseñamos SQL como una
notación sobre el [álgebra relacional](https://es.wikipedia.org/wiki/%C3%81lgebra_relacional), y un plan
de consulta se lee como el árbol de operadores que un
[optimizador](https://es.wikipedia.org/wiki/Optimizaci%C3%B3n_de_consultas) reescribe; el ciclo de
«medir una sola cosa a la vez» de los
[Python Machine Learning Labs](https://dsti.school/es/msc-data-science-ai#course-python-machine-learning-labs);
y los fundamentos de entrenamiento de modelos de los cursos
[Artificial Neural Networks](https://dsti.school/es/msc-data-science-ai#course-artificial-neural-networks)
y [Deep Learning](https://dsti.school/es/msc-data-science-ai#course-deep-learning), que impartí y reelaboré a
fondo antes de entregarlos a sus profesores actuales. Señalaré esas conexiones a medida que surjan, porque un
blog de escuela se gana su lugar mostrando dónde la investigación se encuentra con el aula.

Es una lectura larga, y así debe ser — al fin y al cabo, es el DSTI TechBlog. Partimos de qué es un
silogismo, atravesamos la lógica de primer orden y la idea de notación , abrimos la arquitectura del paquete,
recorremos los experimentos y — la parte que más valoro — exponemos con honestidad lo que el trabajo logró y lo
que queda por mejorar.

## 01 La prueba de razonamiento más antigua que tenemos

### Lógica, inferencia y silogismo

La lógica, en su raíz, trata del buen razonamiento: la capacidad de derivar nuevos enunciados verdaderos a
partir de los que ya sostenemos. La unidad es la proposición — una oración que es o verdadera o falsa. Un
[silogismo](https://es.wikipedia.org/wiki/Silogismo) encadena dos o más proposiciones (las premisas )
para producir una nueva (la conclusión ). El ejemplo de manual es el que todos encuentran primero:

Todos los hombres son mortales.
Sócrates es un hombre.
Por lo tanto, Sócrates es mortal.

Aristóteles abrió el estudio de la lógica con argumentos de esta forma por una buena razón: la validez de
un silogismo depende solo de su forma , no de las palabras concretas. Cambia los términos y una forma válida
sigue siendo válida. Desde Aristóteles, la lógica se ha ramificado en
[lógica proposicional](https://es.wikipedia.org/wiki/L%C3%B3gica_proposicional),
[lógica de primer orden](https://es.wikipedia.org/wiki/L%C3%B3gica_de_primer_orden) y la
[lógica matemática](https://es.wikipedia.org/wiki/L%C3%B3gica_matem%C3%A1tica) de Frege y sus sucesores —
muchas maneras de escribir las mismas formas subyacentes.

### Cuando las palabras tiran hacia un lado y la forma hacia el otro

Considera un segundo argumento:

Todos los autos son vehículos.
Ningún animal es un auto.
Por lo tanto, ningún animal es un vehículo.

La conclusión parece sensata — los animales no son vehículos — y, sin embargo, el argumento es
inválido : las premisas impiden que los animales sean autos , y no dicen nada que impida que un animal
sea un vehículo . La plausibilidad cotidiana apunta a «válido» mientras que la forma dice «inválido». Esa
brecha tiene nombre: el efecto de contenido (pariente cercano del
[sesgo de creencia](https://en.wikipedia.org/wiki/Belief_bias)) — juzgar un argumento por
lo creíble que suena su conclusión en lugar de por su estructura. Los humanos lo muestran, y los modelos
entrenados para predecir texto probable también lo muestran, porque la plausibilidad es justo el tipo de señal
que el entrenamiento recompensa.

Esto es lo que hace de los silogismos un instrumento tan nítido. Son pequeños; su validez es decidible por la
forma; y nos permiten medir en qué grado un razonador se apoya en el contenido frente a la estructura. Así,
la pregunta moderna se vuelve precisa y comprobable: cuando un modelo etiqueta correctamente un silogismo,
¿razona sobre la forma o se apoya en la familiaridad de las palabras? La serie en dos partes Logic in the
Era of Artificial Intelligence plantea justamente esto ([Parte 1](https://hal.science/hal-05709316)) y
lo responde con una herramienta ([Parte 2](https://hal.science/hal-05709317)).

## 02 El mismo pensamiento, escrito de muchas maneras

### La lógica de primer orden: poner la forma por escrito

Para estudiar la forma , primero la escribimos. La herramienta estándar es la lógica de primer orden
(FOL) : cuantificadores (∀ «para todo», ∃ «existe»), conectivas (→, ∧, ∨, ⊕ «o exclusivo», ¬), variables y
predicados. El argumento de Sócrates se convierte en:

```text
∀x (Human(x) → Mortal(x))
Human(socrates)
∴ Mortal(socrates)
```

La traducción elimina el tono y la connotación y conserva el esqueleto. Quien haya convertido una petición de
negocio vaga en un `SELECT … WHERE …` preciso ha hecho el mismo movimiento: lenguaje natural de entrada, una
expresión formal exacta de salida. SQL es en sí mismo un lenguaje formal con una gramática — y bajo su
superficie está el álgebra relacional, un conjunto cerrado de operadores sobre conjuntos de filas (σ selección,
Π proyección, ⋈ junta …). Escrita un operador por paso, una consulta es un árbol: el mismo plan lógico que
una base de datos construye a partir de tu SQL. Ese árbol puede reescribirse luego en árboles demostrablemente
equivalentes — empujar una selección bajo una junta para filtrar temprano, reordenar juntas porque ⋈ es
conmutativa y asociativa — siempre que nunca proyectes fuera de una columna que un paso posterior todavía
necesita.
[Sébastien](https://dsti.school/es/docentes#prof-CORNIGLION) y yo enseñamos el álgebra primero, a propósito, para que los estudiantes lean SQL como una notación
sobre esa forma y un plan de consulta como un árbol de operadores: el álgebra fija qué es correcto y qué
reescrituras siguen siendo lícitas, mientras que el optimizador de consultas, que estima el costo de los planes según las
estadísticas de las tablas, decide qué tan rápido . Es el mismo movimiento gramática → árbol → transformación
al que este artículo no deja de volver — el optimizador no es más que otra pasada sobre un árbol sintáctico.

### Un espectro de notaciones

FOL es una manera de escribir el esqueleto, y lejos de ser la única. El mismo contenido lógico vive en muchas
notaciones de [representación del conocimiento](https://es.wikipedia.org/wiki/Representaci%C3%B3n_del_conocimiento)
(KR) , y John Sowa —cuyo trabajo sobre [Common Logic](https://en.wikipedia.org/wiki/Common_Logic) dio nombre a CLGC— sostuvo durante toda una carrera que esas notaciones son la verdadera interfaz
humano-máquina. Las familias con las que trabaja el proyecto:

- Suite Common Logic (CL) — CLIF (Common Logic Interchange Format) y CGIF ([Conceptual Graph](https://en.wikipedia.org/wiki/Conceptual_graph) Interchange Format): cercanas a FOL, diseñadas para seguir siendo legibles.

- Álgebra Plus-Minus — TFL / TFL+ ([Term Functor Logic](https://en.wikipedia.org/wiki/Term_logic)): muy abstracta, que codifica un silogismo con los operadores `+` y `-` y predicados por primera letra y subíndice. «Todo ateniense es griego; todo griego es mortal; así que todo ateniense es mortal» se convierte en la única expresión fusionada `-(+A0-+G0)-(+G0-+M0)-(+A0-+M0)`.

- [Answer Set Programming](https://es.wikipedia.org/wiki/Answer_set_programming) (ASP) — CLINGO, el lenguaje de entrada de un solucionador ASP.

- [Prolog](https://es.wikipedia.org/wiki/Prolog) (PROLOG) — el lenguaje de programación lógica clásico. CLGC no genera Prolog; valida enunciados contra una gramática Prolog y los pasa por un motor Prolog (Pytholog), de modo que Prolog es un objetivo de interoperación y validación, no una salida de traducción.

- MINIFOL x — una familia de variantes de FOL deliberadamente compactas y deliberadamente no familiares , introducidas para probar una idea concreta (más sobre esto abajo).

El mismo silogismo — el de ateniense/griego/mortal mostrado arriba en Plus-Minus — se vuelve concreto cuando
CLGC realmente lo genera. Las celdas de abajo son la salida efectiva `fol_to_*` de la herramienta (cada salto
de línea de enunciado representado con un retorno de línea, espacios circundantes recortados), no una versión
idealizada a mano:

Notación | El silogismo, exactamente como CLGC lo emite

Lenguaje natural | Todo ateniense es griego. Todo griego es mortal. Por lo tanto, todo ateniense es mortal.

FOL (fuente) | `∀x (Athenian(x) → Greek(x))`
`∀x (Greek(x) → Mortal(x))`
`∀x (Athenian(x) → Mortal(x))`

CLIF | `forall x (athenian(x) implies greek(x))`
`forall x (greek(x) implies mortal(x))`
`forall x (athenian(x) implies mortal(x))`

CGIF | `[@every *x [(athenian[(?x)] greek[(?x)])]`
`@every *x [(greek[(?x)] mortal[(?x)])]`
`@every *x [(athenian[(?x)] mortal[(?x)])]`
`]`

TFL | `-+A1-+G1-+G2-+M2-+A3-+M3`

TFL+ | `-(+A0-+G0)-(+G0-+M0)-(+A0-+M0)`

CLINGO (ASP) | `forall (athenian(x) -: greek(x))`
`forall (greek(x) -: mortal(x))`
`forall (athenian(x) -: mortal(x))`

MINIFOL | `all:x (athenian(x) :- greek(x))`
`all:x (greek(x) :- mortal(x))`
`all:x (athenian(x) :- mortal(x))`

El contenido es idéntico en cada fila; solo cambia la notación — y con ella su forma. CLIF, CLINGO y
MINIFOL mantienen un enunciado por línea; TFL, TFL+ y CGIF fusionan todo el argumento en una sola expresión, y
CLGC pasa los nombres de predicados a minúsculas al traducir. Prolog no es un objetivo de generación : el
paquete valida enunciados contra una gramática Prolog y los entrega a un motor Prolog (Pytholog) en lugar de
emitir Prolog.

Una melodía es la misma tonada en un piano, un sintetizador o una marimba; el instrumento cambia lo que un
oyente nota. La hipótesis científica de todo el proyecto es el análogo lingüístico: dale a un modelo el mismo
silogismo en una notación distinta, y su comportamiento de razonamiento se desplaza — a veces hacia arriba, a
veces no, y siempre de una manera que vale la pena medir. Hay un fuerte precedente de esto desde mi estudio de
2025, que encontró que un modelo pequeño podía conservar un razonamiento sólido cuando se cambiaba el lenguaje
natural por un lenguaje lógico más compacto ([hal-05248053](https://inria.hal.science/hal-05248053)). CLGC
es la herramienta que convirtió esa observación en algo sistemático.

## 03 CLGC como ingeniería

La ciencia solo significa algo si el instrumento es sólido, así que quiero dedicar tiempo real a la
construcción. Es la parte que más se apoya en los hábitos de ingeniería de software que enseñamos.

### Una buena abstracción: una notación es un objeto

La decisión de diseño central es pequeña, y creo que es el tipo correcto de pequeñez. Una notación es un
objeto. Hay una sola clase base abstracta, `Notation`; cada lenguaje formal — FOL, CLIF, CGIF, TFL+, CLINGO,
PROLOG, MINIFOL — es una clase hija, y cada una se define por su gramática
[Backus–Naur Form](https://es.wikipedia.org/wiki/Notaci%C3%B3n_de_Backus-Naur) (BNF) , la manera estándar
de escribir cómo se construyen las expresiones válidas de un lenguaje. FOL es la primera clase concreta, porque
es ampliamente usada y legible por humanos, y todas las demás notaciones derivan de ella.

Se siguen dos consecuencias, ambas deliberadas:

- Añadir una notación es escribir una gramática, no modificar el motor. Un colaborador aporta la BNF de una nueva notación y CLGC puede entonces generar y traducir silogismos en ella. Es el [principio abierto/cerrado](https://es.wikipedia.org/wiki/Principio_de_abierto/cerrado) en la práctica — abierto a la extensión, cerrado a la modificación — lo que en realidad busca SE1/SE2.

- Los silogismos también son objetos. Un `FOLSyllogism` contiene premisas y una conclusión, y sabe categorizarse, traducirse y validarse a sí mismo. Hasta donde sabemos, CLGC es el primer paquete que trata los silogismos como objetos de primera clase en lugar de como simples cadenas de texto.

### Cómo se genera realmente una traducción

El algoritmo de generación es el corazón de ingeniería. Partiendo de un silogismo en FOL (que tiene una
gramática BNF definida), CLGC:

- analiza el enunciado FOL contra la gramática FOL para construir un [árbol de sintaxis abstracta](https://es.wikipedia.org/wiki/%C3%81rbol_de_sintaxis_abstracta) (AST) — el mismo intermediario con forma de árbol que un compilador construye a partir del código fuente;

- construye un árbol equivalente en la notación destino mediante la gramática BNF de esa notación;

- reconstruye el enunciado en la notación destino a partir del árbol, aplicando las reglas sintácticas del destino (espaciado, paréntesis, símbolos de operadores).

Figura — gramática → árbol → emisión

**Figure:** El pipeline gramática-a-árbol-a-emisión. Una cadena fuente en lógica de primer orden se analiza contra la gramática FOL en un árbol de sintaxis abstracta, se mapea a un árbol equivalente en la notación destino mediante la gramática destino, y luego se emite como cadena en la sintaxis destino. La cadena emitida se revalida contra la gramática destino antes de enviarse.

> **Figure caption:** El pipeline gramática → árbol → emisión: FOL se analiza en un AST, se mapea al árbol de la notación destino, se emite como texto y se revalida contra la gramática destino antes de enviarse.

Como todo pasa por una gramática explícita y un árbol explícito, una traducción es reconstruible y
verificable en lugar de una edición de cadena opaca. Quien haya escrito un analizador sintáctico, o pensado
con cuidado en cómo se analiza SQL, reconocerá la forma de inmediato.

Véase también — un patrón de la casa. Este gramática → árbol → emisión , junto con
generar-y-verificar , no es exclusivo de CLGC; lo reconozco en cómo Sébastien diseñó el nuevo sistema web de
DSTI a partir de junio de 2026. Esa construcción envía
[una hoja de estilos podada por página](https://dsti.school/es/techblog/reconstruccion-dsti-school-primavera-2026) analizando
el [CSS](https://es.wikipedia.org/wiki/Hoja_de_estilos_en_cascada) (Cascading Style Sheets) en un árbol
recursivo y reverificando cada página podada contra la original antes de enviarla; su
[verificador de schema.org](https://dsti.school/es/techblog/ingenieria-dsti-school-parte-2) se construye a partir del propio
vocabulario de schema.org en lugar de codificarse regla por regla a mano; y su pipeline de traducción gobernado trata una traducción como una transformación que preserva la estructura, confirmada por un validador
determinista. Problemas distintos, una sola manera de pensar — definir el destino formalmente, trabajar sobre el
árbol, y probar la salida antes de que salga. Esa coherencia a lo largo de la ingeniería de la escuela — contada
en detalle en el TechBlog de ingeniería en dos partes,
[Parte 1](https://dsti.school/es/techblog/reconstruccion-dsti-school-primavera-2026) y
[Parte 2](https://dsti.school/es/techblog/ingenieria-dsti-school-parte-2) — más que cualquier herramienta aislada, es lo que
encuentro digno de señalar.

### Las cuatro preguntas para toda notación nueva

Al definir una notación nueva, el proyecto recomienda cuatro criterios rectores — que además funcionan como
una lente elegante sobre toda la pregunta de investigación:

- Verbosidad — ¿la notación es compacta o verbosa? (Más verbosidad deja más lugar a la ambigüedad.)

- Frecuencia — ¿es probable que la notación, o algo parecido, la haya visto un modelo durante el preentrenamiento? (Lenguaje natural: a menudo. CLIF: rara vez.)

- Abstracción — ¿se sitúa cerca del lenguaje natural o cerca de las matemáticas (como TFL)?

- Finitud — ¿tiene un vocabulario finito y una gramática definible? (Un requisito estricto.)

La familia MINIFOL x existe precisamente para sondear el criterio de Frecuencia . Cada variante hace
un cambio pequeño y deliberado a FOL: MINIFOL cambia los símbolos de operadores (∀, ⊕, →, ¬, ∃, ∧, ∨) por las
cadenas `all`, `^`, `:-`, `-`, `some`, `&`, `|`; MINIFOL2 elimina el cuantificador existencial; MINIFOL3
escribe `not` por ¬; MINIFOL4 escribe `,` por ∧. Son variantes ligeras y, por diseño, no familiares — una
forma de preguntar qué ocurre cuando un modelo se topa con una sintaxis que casi nunca ha visto.

### Lo que hace el paquete, en cuatro verbos

- Manipular — como los silogismos son objetos, se pueden añadir, reemplazar o quitar proposiciones (`add_statements`, `add_premises`, `add_conclusion`).

- Traducir — de FOL a cualquier notación admitida.

- Validar — comprobar un enunciado contra la gramática de una notación (`validate(grammar='PROLOG')`).

- Categorizar — asignar un silogismo a un tipo estructural (las categorías del Syllogism Evaluation Framework (SEF), detallado en la Parte 4).

Un breve ejemplo real tomado del repositorio:

```text
from clgc.__base import *

syllogism = FOLSyllogism(
    "∀x (Bikes(x) → ¬Calledcars(x))\n"
    " ∀x (Bike(x) → Vehicle(x))\n"
    " ∃x (Vehicles(x) ∧ Bikes(x))\n"
)

print(syllogism.categorize())               # -> categorical
tfl_plus = FOLSyllogism.fol_to_tfl_plus(syllogism.syllogism)
print(tfl_plus)                             # -> -(+B0--+C0)-(+B0-+V0)+(+V1++B1)
```

Esa última línea es el mismo pensamiento con un traje muy distinto.

### Llevarse bien con los demás

Como CLGC valida contra gramáticas, coopera con las herramientas lógicas existentes en lugar de reinventarlas.
El repositorio muestra a CLGC entregando enunciados validados a Pytholog , un motor Prolog para Python:
cada hecho candidato se valida como PROLOG por CLGC antes de añadirse a una base de conocimiento y consultarse.
La validación-antes-de-inserción es la versión de programación lógica de comprobar las entradas en la frontera —
el mismo instinto que mantiene honesta a un pipeline de datos.

### La dimensión Clean IT

CLGC se instala con `pip install clgc`, lleva un README que documenta su arquitectura y cada notación
admitida, y está archivado con un registro citable en
[HAL](https://es.wikipedia.org/wiki/HAL_%28archivo_abierto%29) y
[Software Heritage](https://es.wikipedia.org/wiki/Software_Heritage). Nada de esto es glamoroso; todo
ello es la diferencia entre un script que corre en una sola computadora y una herramienta sobre la que otras
personas pueden construir. El módulo Clean IT del Warm-Up existe para volver ordinario ese segundo punto, y
un paquete que otros investigadores pueden instalar y citar es la prueba visible de que el hábito prendió.

## 04 Los experimentos, completos y a la vista

Con el instrumento construido, la ciencia se vuelve tratable. La pregunta central: ¿la elección de la
notación cambia qué tan bien razona un modelo sobre silogismos — y puede el encuadre adecuado ayudar a un modelo
pequeño a atender más a la estructura y menos al contenido?

### La tarea, los datos, los modelos

Los estudios se apoyan en dos conjuntos de datos de razonamiento públicos y curados por humanos, FOLIO y
P-FOLIO , que ya dan los silogismos en lenguaje natural (NL) y en FOL. CLGC extiende cada uno a través de
las notaciones admitidas para producir FOLIO-KR y P-FOLIO-KR , ambos publicados en abierto en
[Hugging Face](https://es.wikipedia.org/wiki/Hugging_Face). La tarea es una clasificación de tres vías:
etiquetar cada conclusión como Verdadera (válida), Falsa (inválida) o Desconocida (no
concluyente). Los conjuntos de datos están honestamente desbalanceados — en las etiquetas de verdad, y también
en las categorías SEF (en FOLIO-KR la categoría categorical queda muy superada por disjunctive y
complex ) — por lo que los artículos reportan el [puntaje F1](https://es.wikipedia.org/wiki/Valor-F) en
lugar de la exactitud bruta donde importa el desbalance de las etiquetas de verdad.

El lado SEF del pipeline clasifica cada silogismo en una de cuatro categorías estructurales, cada
una con una definición precisa que se le puede mostrar al modelo:

- Hipotético — contiene una implicación.

- Disyuntivo — contiene una disyunción.

- Categórico — exactamente dos premisas, y ninguna de las anteriores.

- Complejo — ninguna de las anteriores.

Esas cuatro categorías son el SEF tal como los artículos lo definen conceptualmente. El método `categorize()`
que se entrega es una heurística ligera por palabras clave y por forma que aproxima ese esquema en lugar de
calcularlo con exactitud: etiqueta un silogismo como disjunctive cuando el texto contiene un símbolo de
disyunción (∨ o ⊕); si no, complex cuando tiene más de tres enunciados; si no, categorical cuando el
texto en minúsculas contiene uno de un pequeño conjunto de cuantificadores ( all, any, some, no, few, most,
none, several ) como subcadena; y hypothetical por defecto. Es rápida y suficiente para agrupar un conjunto
de datos a escala, pero es una heurística que sustituye a las definiciones formales de arriba, no una
reimplementación — conviene tenerlo en mente al leer los resultados por categoría.

Se comparan dos regímenes de modelos. En Supervised Fine-Tuning (SFT) el modelo se entrena con silogismos
en una notación dada con sus etiquetas, y luego predice sobre ejemplos reservados; los caballos de batalla son
los pequeños modelos codificador-decodificador Flan-T5 (`small` y `large`), elegidos por su frugalidad y
reproducibilidad. En Zero-Shot (ZS) se le pregunta al modelo en frío, con dos escenarios de prompt: el
Escenario 1 da el silogismo más la gramática BNF de la notación; el Escenario 2 añade la categoría SEF, su
definición y un ejemplo resuelto, para ver si decirle al modelo de qué tipo de argumento se trata ayuda. Los
modelos ZS son pequeños sistemas basados en decodificador de menos de diez mil millones de parámetros —
Gemma-2-2b-it, Llama-3.2-3b-instruct, Phi-3.5-mini-instruct. Los Python ML Labs funcionan exactamente sobre esta
forma de trabajo: fijar una métrica, cambiar una sola cosa, leer el resultado con honestidad.

### Lo que muestran los resultados

Varios hallazgos atraviesan los estudios, y los enunciaré tal como son.

El tamaño del modelo eleva el rendimiento, en gran medida con independencia de la notación. A medida que
Flan-T5 pasa de small a large, la mayoría de las notaciones mejoran juntas. Eso da una base limpia: la escala
ayuda en todas partes, así que los efectos interesantes son los que quedan una vez descontada la escala.

Qué notación gana depende del modelo y del conjunto de datos. En P-FOLIO-KR, con el modelo pequeño y muy
pocos datos de entrenamiento, la compacta y abstracta TFL+ se desempeñó sorprendentemente bien — sus tokens
`+`/`-` ya le son familiares al tokenizador, así que una notación corta le dio al modelo pequeño un apoyo firme.
Con el modelo más grande, el NL recuperó la delantera. Leer esto con honestidad significa resistir un único
titular pulcro: el efecto es real, y es condicional.

Un encuadre híbrido vuelve el razonamiento más prudente. Combinar NL con una notación formal compacta
desplazó a los modelos hacia juicios más conservadores . En el estudio RuleML+RR, NL + CLIF en particular
mejoró el razonamiento por refutación — detectar los casos inválidos — y fue de manera sistemática el más
fuerte en la etiqueta más difícil, Desconocida ; en el estudio SemEval, NL + FOL redujo el efecto de
contenido frente al NL solo. Para sistemas que, de otro modo, tienden a responder con seguridad cuando deberían
abstenerse, un encuadre que empuja hacia «Desconocida» cuando corresponde es una propiedad realmente útil.

Las notaciones compactas se ejecutan más rápido. En el cronometraje ZS, el NL fue la notación más costosa
de procesar, mientras que notaciones compactas como TFL+ y CLIF corrieron más rápido; CLIF se ubicó en un punto
óptimo entre velocidad y calidad. Donde una notación conserva la exactitud mientras acorta la entrada, compra
velocidad de inferencia gratis — una buena noticia para quien corre modelos con un presupuesto ajustado.

Las descripciones de categoría ayudan, según el caso. Añadir la categoría SEF a un prompt ZS (Escenario
2) elevó el rendimiento para varios pares modelo/notación y dejó otros sin cambios. La ganancia depende de qué
tan sensible sea un modelo dado a la notación, lo cual es en sí mismo un resultado interesante sobre cómo estos
modelos aprovechan una estructura adicional.

El complemento SemEval puso números al sesgo. En el estudio SemEval (Semantic Evaluation) 2026 Task 11
(Subtarea 1: Disentangling Content and Formal Reasoning ), el modelo pequeño más fuerte — un Flan-T5-large
preajustado en FOLIO y luego ajustado a la tarea, leyendo NL + FOL — alcanzó 90.57 % de exactitud con
un Content Score (CS) de 27.80 % en el conjunto de evaluación a ciegas, ubicándose 10.° en exactitud y
7.° en la métrica de efecto de contenido . El Content Score recompensa deliberadamente la exactitud mientras
penaliza el efecto de contenido — `CS = ACC / (1 + log(1 + CE))`, donde ACC es la exactitud y CE el efecto de
contenido — por lo que un puntaje alto es difícil de ganar, y obtener uno competitivo con un modelo de menos de
mil millones de parámetros, a la vez que se reduce el efecto de contenido frente al NL solo, es la parte de la
que me alegro. El paso de lenguaje-natural-a-FOL de ese pipeline usó un modelo comercial, con las
traducciones revisadas a mano en una muestra del 20 % del conjunto de entrenamiento y en la totalidad del
conjunto de evaluación.

### Lo que queda por mejorar

Un experimento honesto reporta las partes que se resistieron, y estas apuntan directo al siguiente trabajo.

Atrapar los argumentos inválidos es la habilidad más difícil. Los modelos reconocían con facilidad los
silogismos válidos y cometían la mayoría de sus errores en los inválidos, con tendencia a aceptar un argumento
inválido como válido (un patrón de falsos positivos). Confirmar que algo encaja es más fácil que demostrar que
está roto; las próximas ganancias están en fortalecer la refutación, y el encuadre conservador NL + CLIF es una
vía prometedora hacia ella.

Los conjuntos de datos están desbalanceados. Los silogismos categóricos dominan los conjuntos de trabajo,
lo que vuelve provisionales algunas conclusiones a nivel de categoría. Equilibrar las categorías SEF es una
tarea concreta para un próximo conjunto de datos, y los artículos la nombran como tal.

Un paso se apoya en un modelo comercial. La traducción de lenguaje-natural-a-FOL usa actualmente un
sistema comercial alojado. Eso mantiene fuerte el frente del pipeline hoy, y también crea una dependencia:
si el modelo externo cambia, el primer eslabón puede moverse bajo el experimento. Nombrar esto abiertamente es
el punto — la reproducibilidad es una propiedad que se protege a propósito.

El resultado que defiendo es la forma del hallazgo, que se sostuvo a través de más de un estudio y un foro:
cómo se formula un problema cambia cómo un modelo pequeño razona sobre él, y un encuadre híbrido bien elegido
lo ayuda a atender a la estructura y a abstenerse cuando debe. Los números precisos viven en los artículos, y
el código y los conjuntos de datos abiertos permiten que cualquiera los vuelva a correr.

## 05 La evidencia, a la vista

![Logo del proyecto Common Logic Grammar Construction (CLGC)](https://media.dsti.school/assets/clgc-logo.png)

> **Figure caption:** CLGC — abierto en GitHub y PyPI, archivado y citable en HAL y Software Heritage.

Todo lo que hay detrás de este artículo es público.

- Código: el paquete CLGC — [github.com/HannaAbiAkl/clgc](https://github.com/HannaAbiAkl/clgc), instalable con `pip install clgc` (en el [Python Package Index](https://es.wikipedia.org/wiki/Python_Package_Index) (PyPI), [pypi.org/project/clgc](https://pypi.org/project/clgc/)), archivado y citable vía HAL / Software Heritage ([hal-05608340](https://hal.science/hal-05608340)).

- Conjuntos de datos: FOLIO-KR y P-FOLIO-KR, publicados en Hugging Face ([FOLIO-KR](https://huggingface.co/datasets/HannaAbiAkl/FOLIO-KR), [P-FOLIO-KR](https://huggingface.co/datasets/HannaAbiAkl/P-FOLIO-KR)); los pesos de las mejores configuraciones NL-CLIF y NL están publicados, y el modelo NL-FOL vendrá después.

- El marco, en lenguaje claro: Logic in the Era of AI — [Parte 1 (Silogismos)](https://hal.science/hal-05709316) y [Parte 2 (Marco CLGC)](https://hal.science/hal-05709317).

- El estudio revisado por pares: Are you Talking Logic to Me? Assessing Language Models Syllogistic Reasoning Capabilities , aceptado en RuleML+RR 2026 , la 10.ª International Joint Conference on Rules and Reasoning ([hal-05700643](https://hal.science/hal-05700643)).

- El estudio de tarea compartida: SEF-CLGC at SemEval-2026 Task 11 ([hal-05606250](https://hal.science/hal-05606250); texto completo en [arXiv](https://arxiv.org/abs/2606.09157)).

El trabajo creció dentro del equipo Wimmics (Inria, CNRS, I3S, Université Côte d'Azur), del que soy
miembro desde principios de 2023, y es el núcleo de mi doctorado con el Prof. Fabien Gandon y la Profa. Catherine
Faron , con Pierre Monnin como colaborador cercano. Contó con apoyo, dentro del plan France 2030, de la
Agencia Nacional de Investigación de Francia (ANR), la Iniciativa de Excelencia de la Université Côte d'Azur, el
instituto 3IA Côte d'Azur (uno de los Institutos Interdisciplinarios de Inteligencia Artificial de Francia),
el centro de cómputo de alto rendimiento de la universidad, y DSTI School of Engineering. Nombrar el linaje
importa: estas ideas se inscriben en un programa más amplio sobre grafos de conocimiento, la web semántica y la
[IA neurosimbólica](https://es.wikipedia.org/wiki/Inteligencia_artificial_neurosimb%C3%B3lica).

## 06 Hacia dónde apunta esto

La dirección es una que encuentro de veras digna de perseguir. Si a un modelo pequeño y frugal se le puede
ayudar a razonar sobre la estructura — eligiendo cómo se escribe un problema, y diciéndole de qué tipo de
problema se trata — entonces se abren dos puertas.

La primera es la [ingeniería de ontologías](https://es.wikipedia.org/wiki/Ingenier%C3%ADa_ontol%C3%B3gica) .
Construir los vocabularios y reglas formales que permiten a las máquinas compartir significado es un trabajo
cuidadoso y costoso; un modelo que razona de forma confiable sobre una notación formal compacta podría asumir
una parte mayor del andamiaje, con una persona conservando el juicio sobre el resultado. Esa es la pregunta de
doctorado para la que se construyó CLGC.

La segunda es el razonamiento trazable . Como CLGC mantiene la forma lógica explícita en cada paso —
gramática, árbol, traducción, categoría, validación — el camino de una pregunta en lenguaje natural hasta la
respuesta de una máquina sigue siendo inspeccionable. Un sistema de razonamiento cuyos pasos se pueden leer es
un sistema cuyos errores se pueden encontrar , lo que, para todo lo que importa, vale más que un punto de
exactitud. La dicotomía entre notaciones naturales y abstractas apunta hacia pipelines neurosimbólicos de
varias etapas que usan el lenguaje natural como primer paso y afinan en una notación formal compacta — una línea
concreta de trabajo futuro.

Queda mucho por hacer: equilibrar los conjuntos de datos, fortalecer la detección de argumentos inválidos, y
reducir la dependencia del pipeline respecto de cualquier modelo externo único. Cada uno es un próximo
experimento preciso, y cada uno es más fácil de correr porque la herramienta de abajo es limpia.

Si eres estudiante de DSTI y estás leyendo esto, el hilo que va de un ejercicio de Warm-Up sobre documentar tu
código, a una clase base `Notation` con una gramática cuidada, hasta un artículo en una conferencia de
razonamiento, es más corto y más recto de lo que parece en la semana uno. Lo puedo decir con cierta seguridad:
yo estuve sentado donde tú estás, terminando mi propio MSc in Data Science & AI aquí en 2018. Construye bien la
cosa pequeña, escribe lo que hace, mide con honestidad, y comparte la evidencia. Lo demás suele venir por
añadidura.

Correcciones y pull requests son bienvenidas — el [repositorio](https://github.com/HannaAbiAkl/clgc) es
el mejor lugar para estas últimas.

---

© DSTI School of Engineering 2026 - Todos los derechos reservados. Institución privada de educación superior - V2026.389 - 12 de septiembre de 2026