Ensinar as máquinas a ler lógica

Um modelo de linguagem moderno sabe redigir um ensaio, traduzir um cardápio e sustentar uma conversa fluida. Pergunte a ele se um breve argumento de três linhas é válido, e acontece algo mais delicado. Esse espaço delicado — entre um argumento que soa correto e um que é correto — é onde passei boa parte do meu doutorado, e é o tema deste artigo.

O texto segue dois fios entrelaçados. O primeiro é uma pergunta científica: como os modelos de linguagem lidam com a lógica, e o que acontece quando damos a um modelo o mesmo problema lógico escrito em uma linguagem formal diferente? O segundo é uma resposta de engenharia: um pequeno pacote Python aberto que construí, chamado Common Logic Grammar Construction (CLGC), que torna a pergunta mensurável e reproduzível. Eu me importo igualmente com os dois fios, e ambos se conectam ao que ensinamos na DSTI: a disciplina da documentação e do código limpo do módulo Clean IT do Warm-Up e nossas diretrizes de Software Engineering (SE1/SE2); o reflexo da gramática de uma linguagem formal que os cursos The Relational Model and SQL e SQL (Structured Query Language) constroem — onde ensinamos SQL como uma notação sobre a álgebra relacional, e um plano de consulta se lê como a árvore de operadores que um otimizador reescreve; o ciclo de “medir uma só coisa por vez” dos Python Machine Learning Labs; e os fundamentos de treinamento de modelos dos cursos Artificial Neural Networks e Deep Learning, que ministrei e reelaborei a fundo antes de entregá-los a seus professores atuais. Vou apontar essas conexões conforme surgirem, porque um blog de escola conquista seu lugar mostrando onde a pesquisa encontra a sala de aula.

É uma leitura longa, e assim deve ser — afinal, é o DSTI TechBlog. Partimos do que é um silogismo, atravessamos a lógica de primeira ordem e a ideia de notação, abrimos a arquitetura do pacote, percorremos os experimentos e — a parte que mais valorizo — expomos com honestidade o que o trabalho alcançou e o que resta melhorar.

01 O teste de raciocínio mais antigo que temos

Lógica, inferência e silogismo

A lógica, em sua raiz, trata do bom raciocínio: a capacidade de derivar novos enunciados verdadeiros a partir dos que já sustentamos. A unidade é a proposição — uma frase que é verdadeira ou falsa. Um silogismo encadeia duas ou mais proposições (as premissas) para produzir uma nova (a conclusão). O exemplo de manual é aquele que todos encontram primeiro:

Todos os homens são mortais. Sócrates é um homem. Portanto, Sócrates é mortal.

Aristóteles abriu o estudo da lógica com argumentos dessa forma por uma boa razão: a validade de um silogismo depende apenas de sua forma, não das palavras concretas. Troque os termos e uma forma válida continua válida. Desde Aristóteles, a lógica se ramificou em lógica proposicional, lógica de primeira ordem e a lógica matemática de Frege e seus sucessores — muitas maneiras de escrever as mesmas formas subjacentes.

Quando as palavras puxam para um lado e a forma para o outro

Considere um segundo argumento:

Todos os carros são veículos. Nenhum animal é um carro. Portanto, nenhum animal é um veículo.

A conclusão parece sensata — animais não são veículos — e, no entanto, o argumento é inválido: as premissas impedem que animais sejam carros, e não dizem nada que impeça um animal de ser um veículo. A plausibilidade do dia a dia pende para “válido” enquanto a forma diz “inválido”. Essa lacuna tem nome: o efeito de conteúdo (parente próximo do viés de crença) — julgar um argumento pela credibilidade aparente da sua conclusão em vez de pela sua estrutura. Os humanos o manifestam, e os modelos treinados para prever texto provável também o manifestam, porque a plausibilidade é justamente o tipo de sinal que o treinamento recompensa.

É isso que faz dos silogismos um instrumento tão nítido. São pequenos; sua validade é decidível pela forma; e nos permitem medir em que grau um raciocinador se apoia no conteúdo em vez da estrutura. Assim, a pergunta moderna torna-se precisa e testável: quando um modelo rotula corretamente um silogismo, ele raciocina sobre a forma ou se apoia na familiaridade das palavras? A série em duas partes Logic in the Era of Artificial Intelligence coloca exatamente isso (Parte 1) e responde com uma ferramenta (Parte 2).

02 O mesmo pensamento, escrito de muitas maneiras

A lógica de primeira ordem: pôr a forma no papel

Para estudar a forma, primeiro a escrevemos. A ferramenta padrão é a lógica de primeira ordem (FOL): quantificadores (∀ “para todo”, ∃ “existe”), conectivos (→, ∧, ∨, ⊕ “ou exclusivo”, ¬), variáveis e predicados. O argumento de Sócrates torna-se:

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

A tradução remove o tom e a conotação e conserva o esqueleto. Quem já converteu um pedido de negócio vago em um SELECT … WHERE … preciso fez o mesmo movimento: linguagem natural na entrada, uma expressão formal exata na saída. SQL é em si uma linguagem formal com uma gramática — e sob sua superfície está a álgebra relacional, um conjunto fechado de operadores sobre conjuntos de linhas (σ seleção, Π projeção, ⋈ junção …). Escrita um operador por passo, uma consulta é uma árvore: o mesmo plano lógico que um banco de dados constrói a partir do seu SQL. Essa árvore pode então ser reescrita em árvores comprovadamente equivalentes — empurrar uma seleção para baixo de uma junção para filtrar cedo, reordenar junções porque ⋈ é comutativa e associativa — desde que você nunca projete para fora uma coluna de que um passo posterior ainda precisa. Sébastien e eu ensinamos a álgebra primeiro, de propósito, para que os alunos leiam SQL como uma notação sobre essa forma e um plano de consulta como uma árvore de operadores: a álgebra fixa o que é correto e quais reescritas continuam lícitas, enquanto o otimizador de consultas, que precifica os planos segundo as estatísticas das tabelas, decide quão rápido. É o mesmo movimento gramática → árvore → transformação ao qual este artigo não para de voltar — o otimizador nada mais é que outra passagem sobre uma árvore sintática.

Um espectro de notações

FOL é uma maneira de escrever o esqueleto, e longe de ser a única. O mesmo conteúdo lógico vive em muitas notações de representação do conhecimento (KR), e John Sowa —cujo trabalho sobre Common Logic deu nome ao CLGC— sustentou por toda uma carreira que essas notações são a verdadeira interface humano-máquina. As famílias com que o projeto trabalha:

• Suite Common Logic (CL) — CLIF (Common Logic Interchange Format) e CGIF (Conceptual Graph Interchange Format): próximas de FOL, projetadas para permanecer legíveis.
• Álgebra Plus-Minus — TFL / TFL+ (Term Functor Logic): muito abstrata, que codifica um silogismo com os operadores + e - e predicados por primeira letra e índice. “Todo ateniense é grego; todo grego é mortal; logo todo ateniense é mortal” torna-se a única expressão fundida -(+A0-+G0)-(+G0-+M0)-(+A0-+M0).
• Answer Set Programming (ASP) — CLINGO, a linguagem de entrada de um solucionador ASP.
• Prolog (PROLOG) — a linguagem de programação lógica clássica. O CLGC não gera Prolog; valida enunciados contra uma gramática Prolog e os passa por um motor Prolog (Pytholog), de modo que Prolog é um alvo de interoperação e validação, não uma saída de tradução.
• MINIFOLx — uma família de variantes de FOL deliberadamente compactas e deliberadamente não familiares, introduzidas para testar uma ideia concreta (mais sobre isso abaixo).

O mesmo silogismo — o de ateniense/grego/mortal mostrado acima em Plus-Minus — torna-se concreto quando o CLGC de fato o gera. As células abaixo são a saída efetiva fol_to_* da ferramenta (cada quebra de linha de enunciado representada por um retorno de linha, espaços ao redor removidos), não uma versão idealizada à mão:

O conteúdo é idêntico em cada linha; só muda a notação — e com ela sua forma. CLIF, CLINGO e MINIFOL mantêm um enunciado por linha; TFL, TFL+ e CGIF fundem todo o argumento em uma única expressão, e o CLGC passa os nomes de predicados a minúsculas ao traduzir. Prolog não é um alvo de geração: o pacote valida enunciados contra uma gramática Prolog e os entrega a um motor Prolog (Pytholog) em vez de emitir Prolog.

Uma melodia é a mesma toada num piano, num sintetizador ou numa marimba; o instrumento muda o que um ouvinte percebe. A hipótese científica de todo o projeto é o análogo linguístico: dê a um modelo o mesmo silogismo em uma notação diferente, e seu comportamento de raciocínio se desloca — às vezes para cima, às vezes não, e sempre de uma maneira que vale a pena medir. Há um forte precedente disso desde o meu estudo de 2025, que constatou que um modelo pequeno podia conservar um raciocínio sólido quando se trocava a linguagem natural por uma linguagem lógica mais compacta (hal-05248053). O CLGC é a ferramenta que transformou essa observação em algo sistemático.

03 CLGC como engenharia

A ciência só significa algo se o instrumento for sólido, então quero dedicar tempo real à construção. É a parte que mais se apoia nos hábitos de engenharia de software que ensinamos.

Uma boa abstração: uma notação é um objeto

A decisão de projeto central é pequena, e acredito que é o tipo certo de pequenez. Uma notação é um objeto. Há uma única classe base abstrata, Notation; cada linguagem formal — FOL, CLIF, CGIF, TFL+, CLINGO, PROLOG, MINIFOL — é uma classe filha, e cada uma se define por sua gramática Backus–Naur Form (BNF), a maneira padrão de escrever como se constroem as expressões válidas de uma linguagem. FOL é a primeira classe concreta, porque é amplamente usada e legível por humanos, e todas as demais notações derivam dela.

Seguem-se duas consequências, ambas deliberadas:

1. Adicionar uma notação é escrever uma gramática, não modificar o motor. Um colaborador fornece a BNF de uma nova notação e o CLGC pode então gerar e traduzir silogismos nela. É o princípio aberto/fechado na prática — aberto à extensão, fechado à modificação — o que SE1/SE2 realmente buscam.
2. Os silogismos também são objetos. Um FOLSyllogism contém premissas e uma conclusão, e sabe categorizar-se, traduzir-se e validar-se a si mesmo. Até onde sabemos, o CLGC é o primeiro pacote a tratar os silogismos como objetos de primeira classe em vez de simples cadeias de texto.

Como uma tradução é realmente gerada

O algoritmo de geração é o coração de engenharia. Partindo de um silogismo em FOL (que tem uma gramática BNF definida), o CLGC:

1. analisa o enunciado FOL contra a gramática FOL para construir uma árvore de sintaxe abstrata (AST) — o mesmo intermediário em forma de árvore que um compilador constrói a partir do código-fonte;
2. constrói uma árvore equivalente na notação destino por meio da gramática BNF dessa notação;
3. reconstrói o enunciado na notação destino a partir da árvore, aplicando as regras sintáticas do destino (espaçamento, parênteses, símbolos de operadores).

Como tudo passa por uma gramática explícita e uma árvore explícita, uma tradução é reconstruível e verificável em vez de uma edição de cadeia opaca. Quem já escreveu um analisador sintático, ou pensou com cuidado em como o SQL é analisado, reconhecerá a forma de imediato.

Veja também — um padrão da casa. Este gramática → árvore → emissão, junto com gerar-e-verificar, não é exclusivo do CLGC; eu o reconheço na maneira como Sébastien projetou o novo sistema web da DSTI a partir de junho de 2026. Essa construção envia uma folha de estilos podada por página analisando o CSS (Cascading Style Sheets) em uma árvore recursiva e reverificando cada página podada contra a original antes de enviá-la; seu verificador de schema.org é construído a partir do próprio vocabulário de schema.org em vez de codificado regra por regra à mão; e seu pipeline de tradução governado trata uma tradução como uma transformação que preserva a estrutura, confirmada por um validador determinístico. Problemas diferentes, uma só maneira de pensar — definir o destino formalmente, trabalhar sobre a árvore, e provar a saída antes que ela saia. Essa coerência ao longo da engenharia da escola — contada em detalhe no TechBlog de engenharia em duas partes, Parte 1 e Parte 2 — mais que qualquer ferramenta isolada, é o que considero digno de mostrar.

As quatro perguntas para toda notação nova

Ao definir uma notação nova, o projeto recomenda quatro critérios norteadores — que também funcionam como uma lente elegante sobre toda a pergunta de pesquisa:

• Verbosidade — a notação é compacta ou verbosa? (Mais verbosidade deixa mais espaço para a ambiguidade.)
• Frequência — é provável que a notação, ou algo parecido, tenha sido vista por um modelo durante o pré-treinamento? (Linguagem natural: com frequência. CLIF: raramente.)
• Abstração — situa-se perto da linguagem natural ou perto da matemática (como TFL)?
• Finitude — tem um vocabulário finito e uma gramática definível? (Um requisito estrito.)

A família MINIFOLx existe precisamente para sondar o critério de Frequência. Cada variante faz uma mudança pequena e deliberada em FOL: MINIFOL troca os símbolos de operadores (∀, ⊕, →, ¬, ∃, ∧, ∨) pelas cadeias all, ^, :-, -, some, &, |; MINIFOL2 elimina o quantificador existencial; MINIFOL3 escreve not para ¬; MINIFOL4 escreve , para ∧. São variantes leves e, por design, não familiares — uma forma de perguntar o que acontece quando um modelo se depara com uma sintaxe que quase nunca viu.

O que o pacote faz, em quatro verbos

• Manipular — como os silogismos são objetos, pode-se adicionar, substituir ou remover proposições (add_statements, add_premises, add_conclusion).
• Traduzir — de FOL para qualquer notação suportada.
• Validar — checar um enunciado contra a gramática de uma notação (validate(grammar='PROLOG')).
• Categorizar — atribuir um silogismo a um tipo estrutural (as categorias do Syllogism Evaluation Framework (SEF), detalhado na Parte 4).

Um breve exemplo real tirado do repositório:

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)

Essa última linha é o mesmo pensamento vestindo uma roupa bem diferente.

Dar-se bem com os demais

Como o CLGC valida contra gramáticas, ele coopera com as ferramentas lógicas existentes em vez de reinventá-las. O repositório mostra o CLGC entregando enunciados validados ao Pytholog, um motor Prolog para Python: cada fato candidato é validado como PROLOG pelo CLGC antes de ser adicionado a uma base de conhecimento e consultado. A validação-antes-da-inserção é a versão de programação lógica de checar as entradas na fronteira — o mesmo instinto que mantém honesta um pipeline de dados.

A dimensão Clean IT

O CLGC instala-se com pip install clgc, traz um README que documenta sua arquitetura e cada notação suportada, e está arquivado com um registro citável no HAL e no Software Heritage. Nada disso é glamouroso; tudo isso é a diferença entre um script que roda em um único computador e uma ferramenta sobre a qual outras pessoas podem construir. O módulo Clean IT do Warm-Up existe para tornar ordinário esse segundo ponto, e um pacote que outros pesquisadores podem instalar e citar é a prova visível de que o hábito pegou.

04 Os experimentos, completos e à vista

Com o instrumento construído, a ciência torna-se tratável. A pergunta central: a escolha da notação muda o quão bem um modelo raciocina sobre silogismos — e o enquadramento adequado pode ajudar um modelo pequeno a atender mais à estrutura e menos ao conteúdo?

A tarefa, os dados, os modelos

Os estudos apoiam-se em dois conjuntos de dados de raciocínio públicos e curados por humanos, FOLIO e P-FOLIO, que já dão os silogismos em linguagem natural (NL) e em FOL. O CLGC estende cada um através das notações suportadas para produzir FOLIO-KR e P-FOLIO-KR, ambos publicados em aberto no Hugging Face. A tarefa é uma classificação de três vias: rotular cada conclusão como Verdadeira (válida), Falsa (inválida) ou Desconhecida (não conclusiva). Os conjuntos de dados estão honestamente desbalanceados — nos rótulos de verdade, e também nas categorias SEF (em FOLIO-KR a categoria categorical é largamente superada por disjunctive e complex) — por isso os artigos reportam o escore F1 em vez da acurácia bruta onde importa o desbalanceamento dos rótulos de verdade.

O lado SEF do pipeline classifica cada silogismo em uma de quatro categorias estruturais, cada uma com uma definição precisa que se pode mostrar ao modelo:

• Hipotético — contém uma implicação.
• Disjuntivo — contém uma disjunção.
• Categórico — exatamente duas premissas, e nenhuma das anteriores.
• Complexo — nenhuma das anteriores.

Essas quatro categorias são o SEF tal como os artigos o definem conceitualmente. O método categorize() entregue é uma heurística leve por palavras-chave e por forma que aproxima esse esquema em vez de calculá-lo com exatidão: rotula um silogismo como disjunctive quando o texto contém um símbolo de disjunção (∨ ou ⊕); senão complex quando tem mais de três enunciados; senão categorical quando o texto em minúsculas contém um de um pequeno conjunto de quantificadores (all, any, some, no, few, most, none, several) como subcadeia; e hypothetical por padrão. É rápida e suficiente para agrupar um conjunto de dados em escala, mas é uma heurística que substitui as definições formais acima, não uma reimplementação — bom ter isso em mente ao ler os resultados por categoria.

Comparam-se dois regimes de modelos. No Supervised Fine-Tuning (SFT) o modelo é treinado com silogismos em uma notação dada com seus rótulos, e então prediz sobre exemplos reservados; os cavalos de batalha são os pequenos modelos codificador-decodificador Flan-T5 (small e large), escolhidos por sua frugalidade e reprodutibilidade. No Zero-Shot (ZS) pergunta-se ao modelo a frio, com dois cenários de prompt: o Cenário 1 dá o silogismo mais a gramática BNF da notação; o Cenário 2 acrescenta a categoria SEF, sua definição e um exemplo resolvido, para ver se dizer ao modelo de que tipo de argumento se trata ajuda. Os modelos ZS são pequenos sistemas baseados em decodificador com menos de dez bilhões de parâmetros — Gemma-2-2b-it, Llama-3.2-3b-instruct, Phi-3.5-mini-instruct. Os Python ML Labs funcionam exatamente sobre esta forma de trabalho: fixar uma métrica, mudar uma só coisa, ler o resultado com honestidade.

O que os resultados mostram

Vários achados atravessam os estudos, e vou enunciá-los tal como são.

O tamanho do modelo eleva o desempenho, em grande parte independentemente da notação. À medida que o Flan-T5 passa de small para large, a maioria das notações melhora junta. Isso dá uma base limpa: a escala ajuda em toda parte, então os efeitos interessantes são os que restam depois de descontada a escala.

Qual notação vence depende do modelo e do conjunto de dados. Em P-FOLIO-KR, com o modelo pequeno e muito poucos dados de treinamento, a compacta e abstrata TFL+ desempenhou-se surpreendentemente bem — seus tokens +/- já são familiares ao tokenizador, então uma notação curta deu ao modelo pequeno um apoio firme. Com o modelo maior, o NL retomou a dianteira. Ler isso com honestidade significa resistir a uma única manchete elegante: o efeito é real, e é condicional.

Um enquadramento híbrido torna o raciocínio mais prudente. Combinar NL com uma notação formal compacta deslocou os modelos para julgamentos mais conservadores. No estudo RuleML+RR, NL + CLIF em particular melhorou o raciocínio por refutação — detectar os casos inválidos — e foi de maneira consistente o mais forte no rótulo mais difícil, Desconhecida; no estudo SemEval, NL + FOL reduziu o efeito de conteúdo em relação ao NL sozinho. Para sistemas que, de outro modo, tendem a responder com segurança quando deveriam abster-se, um enquadramento que empurra para “Desconhecida” quando cabe é uma propriedade realmente útil.

As notações compactas rodam mais rápido. Na cronometragem ZS, o NL foi a notação mais custosa de processar, enquanto notações compactas como TFL+ e CLIF rodaram mais rápido; CLIF ficou num ponto ótimo entre velocidade e qualidade. Onde uma notação conserva a acurácia enquanto encurta a entrada, ela compra velocidade de inferência de graça — uma boa notícia para quem roda modelos com um orçamento apertado.

As descrições de categoria ajudam, conforme o caso. Acrescentar a categoria SEF a um prompt ZS (Cenário 2) elevou o desempenho para vários pares modelo/notação e deixou outros sem mudança. O ganho depende de quão sensível um dado modelo é à notação, o que é em si um resultado interessante sobre como esses modelos aproveitam uma estrutura adicional.

O complemento SemEval pôs números no viés. No estudo SemEval (Semantic Evaluation) 2026 Task 11 (Subtarefa 1: Disentangling Content and Formal Reasoning), o modelo pequeno mais forte — um Flan-T5-large pré-ajustado em FOLIO e depois ajustado à tarefa, lendo NL + FOL — atingiu 90,57 % de acurácia com um Content Score (CS) de 27,80 % no conjunto de avaliação às cegas, ficando em 10.º na acurácia e 7.º na métrica de efeito de conteúdo. O Content Score recompensa deliberadamente a acurácia enquanto penaliza o efeito de conteúdo — CS = ACC / (1 + log(1 + CE)), onde ACC é a acurácia e CE o efeito de conteúdo — por isso um escore alto é difícil de ganhar, e obter um competitivo com um modelo de menos de um bilhão de parâmetros, ao mesmo tempo reduzindo o efeito de conteúdo em relação ao NL sozinho, é a parte de que me alegro. O passo de linguagem-natural-para-FOL desse pipeline usou um modelo comercial, com as traduções revisadas à mão em uma amostra de 20 % do conjunto de treinamento e na totalidade do conjunto de avaliação.

O que resta melhorar

Um experimento honesto reporta as partes que resistiram, e estas apontam direto para o próximo trabalho.

Pegar os argumentos inválidos é a habilidade mais difícil. Os modelos reconheciam com facilidade os silogismos válidos e cometiam a maioria de seus erros nos inválidos, com tendência a aceitar um argumento inválido como válido (um padrão de falsos positivos). Confirmar que algo se encaixa é mais fácil do que provar que está quebrado; os próximos ganhos estão em fortalecer a refutação, e o enquadramento conservador NL + CLIF é uma via promissora para ela.

Os conjuntos de dados estão desbalanceados. Os silogismos categóricos dominam os conjuntos de trabalho, o que torna provisórias algumas conclusões em nível de categoria. Equilibrar as categorias SEF é uma tarefa concreta para um próximo conjunto de dados, e os artigos a nomeiam como tal.

Um passo se apoia em um modelo comercial. A tradução de linguagem-natural-para-FOL usa atualmente um sistema comercial hospedado. Isso mantém forte a frente do pipeline hoje, e também cria uma dependência: se o modelo externo mudar, o primeiro elo pode se mover sob o experimento. Nomear isso abertamente é o ponto — a reprodutibilidade é uma propriedade que se protege de propósito.

O resultado que defendo é a forma do achado, que se sustentou através de mais de um estudo e de mais de um palco: como um problema é formulado muda como um modelo pequeno raciocina sobre ele, e um enquadramento híbrido bem escolhido o ajuda a prestar atenção à estrutura e a abster-se quando deve. Os números precisos vivem nos artigos, e o código e os conjuntos de dados abertos permitem que qualquer pessoa os rode de novo.

05 A evidência, à vista

Tudo o que há por trás deste artigo é público.

• Código: o pacote CLGC — github.com/HannaAbiAkl/clgc, instalável com pip install clgc (no Python Package Index (PyPI), pypi.org/project/clgc), arquivado e citável via HAL / Software Heritage (hal-05608340).
• Conjuntos de dados: FOLIO-KR e P-FOLIO-KR, publicados no Hugging Face (FOLIO-KR, P-FOLIO-KR); os pesos das melhores configurações NL-CLIF e NL estão publicados, e o modelo NL-FOL virá depois.
• O arcabouço, em linguagem clara: Logic in the Era of AI — Parte 1 (Silogismos) e Parte 2 (Arcabouço CLGC).
• O estudo revisado por pares: Are you Talking Logic to Me? Assessing Language Models Syllogistic Reasoning Capabilities, aceito no RuleML+RR 2026, a 10.ª International Joint Conference on Rules and Reasoning (hal-05700643).
• O estudo de tarefa compartilhada: SEF-CLGC at SemEval-2026 Task 11 (hal-05606250; texto completo no arXiv).

O trabalho cresceu dentro da equipe Wimmics (Inria, CNRS, I3S, Université Côte d'Azur), da qual sou membro desde o início de 2023, e é o núcleo do meu doutorado com o Prof. Fabien Gandon e a Profa. Catherine Faron, com Pierre Monnin como colaborador próximo. Contou com apoio, dentro do plano France 2030, da Agência Nacional de Pesquisa da França (ANR), da Iniciativa de Excelência da Université Côte d'Azur, do instituto 3IA Côte d'Azur (um dos Institutos Interdisciplinares de Inteligência Artificial da França), do centro de computação de alto desempenho da universidade, e da DSTI School of Engineering. Nomear a linhagem importa: essas ideias inscrevem-se em um programa mais amplo sobre grafos de conhecimento, a web semântica e a IA neurossimbólica.

06 Para onde isto aponta

A direção é uma que considero de fato digna de perseguir. Se um modelo pequeno e frugal puder ser ajudado a raciocinar sobre a estrutura — escolhendo como um problema é escrito, e dizendo-lhe de que tipo de problema se trata — então duas portas se abrem.

A primeira é a engenharia de ontologias. Construir os vocabulários e regras formais que permitem às máquinas compartilhar significado é um trabalho cuidadoso e custoso; um modelo que raciocina de forma confiável sobre uma notação formal compacta poderia assumir uma parte maior do andaime, com uma pessoa conservando o julgamento sobre o resultado. Essa é a pergunta de doutorado para a qual o CLGC foi construído.

A segunda é o raciocínio rastreável. Como o CLGC mantém a forma lógica explícita a cada passo — gramática, árvore, tradução, categoria, validação — o caminho de uma pergunta em linguagem natural até a resposta de uma máquina permanece inspecionável. Um sistema de raciocínio cujos passos podem ser lidos é um sistema cujos erros podem ser encontrados, o que, para tudo o que importa, vale mais que um ponto de acurácia. A dicotomia entre notações naturais e abstratas aponta para pipelines neurossimbólicos de várias etapas que usam a linguagem natural como primeiro passo e afinam em uma notação formal compacta — uma linha concreta de trabalho futuro.

Resta muito por fazer: equilibrar os conjuntos de dados, fortalecer a detecção de argumentos inválidos, e reduzir a dependência do pipeline em relação a qualquer modelo externo único. Cada um é um próximo experimento preciso, e cada um é mais fácil de rodar porque a ferramenta por baixo é limpa.

Se você é estudante da DSTI e está lendo isto, o fio que vai de um exercício de Warm-Up sobre documentar seu código, a uma classe base Notation com uma gramática caprichada, até um artigo em uma conferência de raciocínio, é mais curto e mais reto do que parece na primeira semana. Posso dizê-lo com certa segurança: eu estava sentado onde você está, terminando meu próprio MSc in Data Science & AI aqui em 2018. Construa bem a coisa pequena, escreva o que ela faz, meça com honestidade, e compartilhe a evidência. O resto tende a seguir.

Correções e pull requests são bem-vindas — o repositório é o melhor lugar para estas últimas.