# Ensinar as máquinas a ler lógica
Canonical HTML: https://dsti.school/pt/techblog/ensinar-as-maquinas-a-ler-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/pt/techblog) / IA é tecnologia
Corpo docente IA é tecnologia
Um modelo de linguagem moderno sabe traduzir um cardápio e sustentar uma conversa fluida, e no entanto hesita em dizer se um breve argumento é realmente válido. O diretor acadêmico Hanna Abi Akl passou boa parte do seu doutorado nessa lacuna — entre um argumento que soa correto e um que é correto — e construiu um pequeno pacote Python aberto, [Common Logic Grammar Construction](https://github.com/HannaAbiAkl/clgc) (CLGC), para tornar a pergunta mensurável. Aqui estão a ciência, a engenharia que a sustenta, e um relato honesto do que o trabalho alcançou e do que resta melhorar.
Por Hanna Abi Akl Diretor acadêmico, DSTI · ex-aluno da DSTI (MSc in Data Science & AI, 2018) · doutorando, Wimmics (Inria, CNRS, I3S, Université Côte d’Azur)
12 de setembro de 2026 22 min de leitura IA é tecnologia
syllogistic-reasoning first-order-logic knowledge-representation neuro-symbolic-ai semantic-web small-language-models open-science
Figura — o efeito de conteúdo
**Figure:** Um silogismo inválido representado por um diagrama de Euler. Carros é um subconjunto de Veículos; Animais é disjunto de Carros mas se sobrepõe a Veículos. A sobreposição com estrela — um animal que também é um veículo — satisfaz ambas as premissas ao mesmo tempo que contradiz a conclusão, portanto o argumento é inválido.
> **Figure caption:** Por que a conclusão não se segue: um animal pode ser um veículo sem ser um carro; as premissas deixam a conclusão em aberto — o argumento é inválido.
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](https://dsti.school/pt/msc-data-science-ai#course-clean-it) do Warm-Up e nossas diretrizes de Software
Engineering ([SE1](https://dsti.school/pt/msc-data-analytics-ai#course-software-engineering-part-1)/[SE2](https://dsti.school/pt/msc-data-analytics-ai#course-software-engineering-part-2));
o reflexo da gramática de uma linguagem formal que os cursos
[The Relational Model and SQL](https://dsti.school/pt/bsc-computer-science-engineering#course-the-relational-model-and-sql)
e [SQL](https://dsti.school/pt/bsc-computer-science-engineering#course-the-relational-model-and-sql) (Structured Query Language) constroem — onde ensinamos SQL
como uma notação sobre a [álgebra relacional](https://pt.wikipedia.org/wiki/%C3%81lgebra_relacional), e
um plano de consulta se lê como a árvore de operadores que um
[otimizador](https://pt.wikipedia.org/wiki/Otimiza%C3%A7%C3%A3o_de_consulta) reescreve; o ciclo de
“medir uma só coisa por vez” dos
[Python Machine Learning Labs](https://dsti.school/pt/msc-data-science-ai#course-python-machine-learning-labs); e os
fundamentos de treinamento de modelos dos cursos
[Artificial Neural Networks](https://dsti.school/pt/msc-data-science-ai#course-artificial-neural-networks) e
[Deep Learning](https://dsti.school/pt/msc-data-science-ai#course-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](https://pt.wikipedia.org/wiki/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](https://pt.wikipedia.org/wiki/L%C3%B3gica_proposicional),
[lógica de primeira ordem](https://pt.wikipedia.org/wiki/L%C3%B3gica_de_primeira_ordem) e a
[lógica matemática](https://pt.wikipedia.org/wiki/L%C3%B3gica_matem%C3%A1tica) 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](https://en.wikipedia.org/wiki/Belief_bias)) — 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](https://hal.science/hal-05709316)) e responde com uma
ferramenta ([Parte 2](https://hal.science/hal-05709317)).
## 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:
```text
∀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](https://dsti.school/pt/corpo-docente#prof-CORNIGLION) 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](https://pt.wikipedia.org/wiki/Representa%C3%A7%C3%A3o_de_conhecimento)
(KR) , e John Sowa —cujo trabalho sobre [Common Logic](https://en.wikipedia.org/wiki/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](https://en.wikipedia.org/wiki/Conceptual_graph) Interchange Format): próximas de FOL, projetadas para permanecer legíveis.
- Álgebra Plus-Minus — TFL / TFL+ ([Term Functor Logic](https://en.wikipedia.org/wiki/Term_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](https://pt.wikipedia.org/wiki/Answer_set_programming) (ASP) — CLINGO, a linguagem de entrada de um solucionador ASP.
- [Prolog](https://pt.wikipedia.org/wiki/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.
- MINIFOL x — 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:
Notação | O silogismo, exatamente como o CLGC o emite
Linguagem natural | Todo ateniense é grego. Todo grego é mortal. Portanto, todo ateniense é mortal.
FOL (fonte) | `∀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))`
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](https://inria.hal.science/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](https://pt.wikipedia.org/wiki/Formalismo_de_Backus-Naur) (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:
- 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](https://pt.wikipedia.org/wiki/Princ%C3%ADpio_do_aberto/fechado) na prática — aberto à extensão, fechado à modificação — o que SE1/SE2 realmente buscam.
- 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:
- analisa o enunciado FOL contra a gramática FOL para construir uma [árvore de sintaxe abstrata](https://pt.wikipedia.org/wiki/%C3%81rvore_de_sintaxe_abstrata) (AST) — o mesmo intermediário em forma de árvore que um compilador constrói a partir do código-fonte;
- constrói uma árvore equivalente na notação destino por meio da gramática BNF dessa notação;
- 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).
Figura — gramática → árvore → emissão
**Figure:** O pipeline gramática-para-árvore-para-emissão. Uma cadeia fonte em lógica de primeira ordem é analisada contra a gramática FOL em uma árvore de sintaxe abstrata, mapeada para uma árvore equivalente na notação destino por meio da gramática destino, e então emitida como cadeia na sintaxe destino. A cadeia emitida é revalidada contra a gramática destino antes de ser enviada.
> **Figure caption:** O pipeline gramática → árvore → emissão: FOL é analisado em uma AST, mapeado para a árvore da notação destino, emitido como texto e revalidado contra a gramática destino antes de ser enviado.
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](https://dsti.school/pt/techblog/reconstrucao-dsti-school-primavera-2026) analisando
o [CSS](https://pt.wikipedia.org/wiki/Cascading_Style_Sheets) (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](https://dsti.school/pt/techblog/engenharia-dsti-school-parte-2) é 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](https://dsti.school/pt/techblog/reconstrucao-dsti-school-primavera-2026) e
[Parte 2](https://dsti.school/pt/techblog/engenharia-dsti-school-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 MINIFOL x 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:
```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)
```
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](https://pt.wikipedia.org/wiki/HAL_%28arquivo_aberto%29) e no
[Software Heritage](https://pt.wikipedia.org/wiki/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](https://pt.wikipedia.org/wiki/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](https://pt.wikipedia.org/wiki/F-score) 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
> **Figure caption:** CLGC — aberto no GitHub e no PyPI, arquivado e citável no HAL e no Software Heritage.
Tudo o que há por trás deste artigo é público.
- Código: o pacote CLGC — [github.com/HannaAbiAkl/clgc](https://github.com/HannaAbiAkl/clgc), instalável com `pip install clgc` (no [Python Package Index](https://pt.wikipedia.org/wiki/Python_Package_Index) (PyPI), [pypi.org/project/clgc](https://pypi.org/project/clgc/)), arquivado e citável via HAL / Software Heritage ([hal-05608340](https://hal.science/hal-05608340)).
- Conjuntos de dados: FOLIO-KR e P-FOLIO-KR, publicados no Hugging Face ([FOLIO-KR](https://huggingface.co/datasets/HannaAbiAkl/FOLIO-KR), [P-FOLIO-KR](https://huggingface.co/datasets/HannaAbiAkl/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)](https://hal.science/hal-05709316) e [Parte 2 (Arcabouço CLGC)](https://hal.science/hal-05709317).
- 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](https://hal.science/hal-05700643)).
- O estudo de tarefa compartilhada: SEF-CLGC at SemEval-2026 Task 11 ([hal-05606250](https://hal.science/hal-05606250); texto completo no [arXiv](https://arxiv.org/abs/2606.09157)).
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](https://pt.wikipedia.org/wiki/Intelig%C3%AAncia_artificial_neuro-simb%C3%B3lica).
## 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](https://pt.wikipedia.org/wiki/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](https://github.com/HannaAbiAkl/clgc) é o
melhor lugar para estas últimas.
---
© DSTI School of Engineering 2026 - Todos os direitos reservados. Instituição privada de ensino superior - V2026.389 - 12 de setembro de 2026