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

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 del Warm-Up y nuestras pautas de Software Engineering (SE1/SE2); el reflejo de la gramática de un lenguaje formal que construyen los cursos The Relational Model and SQL y SQL (Structured Query Language) — donde enseñamos SQL como una notación sobre el álgebra relacional, y un plan de consulta se lee como el árbol de operadores que un optimizador reescribe; el ciclo de «medir una sola cosa a la vez» de los Python Machine Learning Labs; y los fundamentos de entrenamiento de modelos de los cursos Artificial Neural Networks y 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 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, lógica de primer orden y la lógica matemática 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) — 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) y lo responde con una herramienta (Parte 2).

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:

∀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 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 (KR), y John Sowa —cuyo trabajo sobre 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 Interchange Format): cercanas a FOL, diseñadas para seguir siendo legibles.
• Álgebra Plus-Minus — TFL / TFL+ (Term Functor 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 (ASP) — CLINGO, el lenguaje de entrada de un solucionador ASP.
• 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.
• MINIFOLx — 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:

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). 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 (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:

1. 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 en la práctica — abierto a la extensión, cerrado a la modificación — lo que en realidad busca SE1/SE2.
2. 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:

1. analiza el enunciado FOL contra la gramática FOL para construir un árbol de sintaxis abstracta (AST) — el mismo intermediario con forma de árbol que un compilador construye a partir del código fuente;
2. construye un árbol equivalente en la notación destino mediante la gramática BNF de esa notación;
3. 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).

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 analizando el CSS (Cascading Style Sheets) en un árbol recursivo y reverificando cada página podada contra la original antes de enviarla; su verificador de schema.org 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 y 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 MINIFOLx 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:

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 y 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. 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 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

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

• Código: el paquete CLGC — github.com/HannaAbiAkl/clgc, instalable con pip install clgc (en el Python Package Index (PyPI), pypi.org/project/clgc), archivado y citable vía HAL / Software Heritage (hal-05608340).
• Conjuntos de datos: FOLIO-KR y P-FOLIO-KR, publicados en Hugging Face (FOLIO-KR, 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) y Parte 2 (Marco CLGC).
• 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).
• El estudio de tarea compartida: SEF-CLGC at SemEval-2026 Task 11 (hal-05606250; texto completo en arXiv).

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.

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. 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 es el mejor lugar para estas últimas.