Arquivo de Programação Lógica - Página 13 de 13

Consultas em Prolog: Perguntando ao Mundo

16/07/202609/07/2026 Por antonino

Agora que já temos nossa base de fatos (a árvore genealógica), chegou a hora de fazer perguntas. Em Prolog, as consultas são a forma de interagir com o conhecimento que declaramos. Elas podem ser simples (sim/não) ou abertas, usando variáveis para descobrir relações. Neste artigo, vamos explorar o poder das consultas e entender como o motor do Prolog encontra respostas.

1. O que são consultas?

Uma consulta (ou goal) é uma pergunta que fazemos ao sistema Prolog. O motor de inferência tenta provar que a consulta é verdadeira, usando os fatos e regras disponíveis. Se conseguir, responde true (ou mostra os valores das variáveis); se não, responde false.

As consultas são feitas no prompt ?- do SWI-Prolog e são interativas — diferentemente dos fatos, que ficam salvos em arquivos. Elas são o seu “modo de conversa” com o conhecimento.

        💡 Analogia: Se os fatos são como as frases de um livro, as consultas são as perguntas que você faz a um especialista que leu o livro. O especialista (Prolog) consulta a memória e responde.
    

2. Consultas com fatos concretos: o veredito `yes/no`

O tipo mais simples de consulta é perguntar sobre um fato específico que já declaramos. Por exemplo, usando nossa árvore genealógica (vamos supor uma base bíblica simples):

Arquivo genealogia.pl:




% ===========================================
% Árvore genealógica da família 
% ===========================================
 
% Relação pai
pai(adão, cain).
pai(adão, abel).
pai(adão, seth).
pai(seth, enos).

% Relação mãe
mae(eva, cain).
mae(eva, abel).
mae(eva, seth).

% ===========================================

% Árvore genealógica da família

% ===========================================

% Relação pai

pai(adão, cain).

pai(adão, abel).

pai(adão, seth).

pai(seth, enos).

% Relação mãe

mae(eva, cain).

mae(eva, abel).

mae(eva, seth).

No SWI-Prolog, carregamos o arquivo:

?- [genealogia].
true.

1 2	?- [genealogia]. true.

Agora, consultas diretas:

?- pai(adão, cain).   % Adão é pai de Cain?
true.                  % Sim, o fato existe!

?- pai(adão, abel).   % Adão é pai de Abel?
true.

?- pai(adão, noé).    % Adão é pai de Noé?
false.                % Não, não declaramos esse fato.

?- pai(adão, cain). % Adão é pai de Cain?

true. % Sim, o fato existe!

?- pai(adão, abel). % Adão é pai de Abel?

true.

?- pai(adão, noé). % Adão é pai de Noé?

false. % Não, não declaramos esse fato.

⚠️ Importante: O Prolog só conhece o que você declarou. Se um fato não existe na base, a resposta é false — não importa se “no mundo real” é verdade. Você precisa declarar tudo o que quer que o sistema conheça.

3. Variáveis: perguntas abertas com `X`, `Y`, `Pessoa`

O verdadeiro poder das consultas aparece quando usamos variáveis. Uma variável em Prolog (sempre começando com maiúscula) representa um valor desconhecido que o sistema tentará descobrir.

Exemplo: “Quem é o pai de Abel?”

?- pai(X, abel).   % X é uma variável (maiúscula!)
X = adao.            % O sistema encontrou a resposta

1 2	?- pai(X, abel). % X é uma variável (maiúscula!) X = adao. % O sistema encontrou a resposta

O que aconteceu? O Prolog procurou em todos os fatos pai/2 e encontrou pai(adao, abel). Ele então unificou a variável X com o átomo adao, e nos mostrou o resultado.

        🧩 Unificação: É o processo de igualar uma consulta com um fato ou cabeça de regra, fazendo as substituições necessárias. Quando você pergunta pai(X, abel), o sistema diz: “Para provar isso, preciso encontrar um pai cujo segundo argumento seja abel; o primeiro argumento será o valor de X.” E encontra.
    

4. Múltiplas respostas: o ponto-e-vírgula (`;`) e o backtracking

E se houver mais de uma resposta? Exemplo: “Quem são os filhos de Adão?”

?- pai(adao, Filho).
Filho = caim ;   % Digite ';' (ponto-e-vírgula) para ver mais
Filho = abel ;   % O sistema voltou (backtracking) e encontrou outra
Filho = sete.    % Última resposta (ponto final ou Enter)

?- pai(adao, Filho).

Filho = caim ; % Digite ';' (ponto-e-vírgula) para ver mais

Filho = abel ; % O sistema voltou (backtracking) e encontrou outra

Filho = sete. % Última resposta (ponto final ou Enter)

O mecanismo que permite isso é o backtracking: quando o Prolog encontra uma solução, ele a apresenta e “marca” o ponto onde parou. Se você pedir mais (;), ele volta atrás (desfaz a unificação) e procura outra solução.

⌨️ Como navegar pelas respostas:

Digite ; (ponto-e-vírgula) → mostra a próxima solução.
Digite Enter (ou .) → para e aceita a solução atual.
Digite a → mostra todas as soluções de uma vez (útil para muitas respostas).
Digite Espaço → também avança para a próxima (funciona como ; em algumas versões).

Exemplo com muitas respostas:

?- pai(adao, Filho).
Filho = caim ;
Filho = abel ;
Filho = sete.

?- pai(Pai, Filho).   % Quem é pai de quem? (todas as relações)
Pai = adao, Filho = caim ;
Pai = adao, Filho = abel ;
Pai = adao, Filho = sete ;
Pai = sete, Filho = enos ;
... (continua)

?- pai(adao, Filho).

Filho = caim ;

Filho = abel ;

Filho = sete.

?- pai(Pai, Filho). % Quem é pai de quem? (todas as relações)

Pai = adao, Filho = caim ;

Pai = adao, Filho = abel ;

Pai = adao, Filho = sete ;

Pai = sete, Filho = enos ;

... (continua)

Se você digitar a após a primeira resposta, ele exibe todas de uma vez:

?- pai(adao, Filho).
Filho = caim
Filho = abel
Filho = sete.
true.

?- pai(adao, Filho).

Filho = caim

Filho = abel

Filho = sete.

true.

5. Explorando a árvore genealógica com consultas

🔹 Quem são os filhos de Adão?

?- pai(adao, Filho).
Filho = caim ;
Filho = abel ;
Filho = sete.

?- pai(adao, Filho).

Filho = caim ;

Filho = abel ;

Filho = sete.

🔹 Quem é o pai de Enos?

?- pai(Pai, enos).
Pai = sete.

1 2	?- pai(Pai, enos). Pai = sete.

🔹 Quem são os netos de Adão?

Para isso, precisamos de uma consulta com duas variáveis e uma condição implícita: o pai do neto deve ser filho de Adão.

?- pai(adao, Filho), pai(Filho, Neto).
Filho = sete, Neto = enos ;   % Sete é filho de Adão e pai de Enos
false.                         % (só um neto direto nessa base)

?- pai(adao, Filho), pai(Filho, Neto).

Filho = sete, Neto = enos ; % Sete é filho de Adão e pai de Enos

false. % (só um neto direto nessa base)

Explicação: a vírgula (,) significa “e” (conjunção lógica). O Prolog tenta satisfazer ambas as condições.

        🧠 Interpretação: A consulta pai(adao, Filho), pai(Filho, Neto) é lida como: “Existe um Filho que é filho de Adão e, para esse mesmo Filho, existe um Neto que é filho dele?” Isso nos dá os netos.
    

🔹 Quem são os bisnetos de Adão?

?- pai(adao, A), pai(A, B), pai(B, Bisneto).
A = sete,
B = enos,
Bisneto = cainã.

?- pai(adao, A), pai(A, B), pai(B, Bisneto).

A = sete,

B = enos,

Bisneto = cainã.

Perceba como as variáveis A e B são usadas para encadear as relações.

6. Consultas vs. Fatos: qual a diferença?

Fatos (no arquivo .pl)	Consultas (no prompt)
Declarações permanentes de verdade.	Perguntas temporárias ao sistema.
Fazem parte da base de conhecimento.	Não alteram a base de conhecimento.
Escritas com ponto final (`.`) e minúsculas.	Podem ter variáveis (maiúsculas) e terminam com ponto final também.
Exemplo: `pai(adao, caim).`	Exemplo: `?- pai(adao, X).`

📌 Importante: Você não pode digitar fatos diretamente no prompt esperando que eles fiquem salvos. Eles valem apenas para aquela sessão, a menos que você use assert/1 (que veremos depois). Para fatos permanentes, sempre use arquivos .pl.

7. 📝 Exercícios práticos para você

Use a base genealógica que criamos (ou a sua própria) e responda:

Quem são os filhos de Sete?
Quem é o avô de Cainã?
Quem são todos os descendentes diretos (filhos, netos, bisnetos) de Adão? (Dica: use múltiplas variáveis).
Existe alguém que seja pai de mais de um filho? Quem?
Quantos filhos Noé tem? (Se não tiver nenhum, a resposta será false).
Crie uma consulta que liste todas as relações pai/2 em ordem alfabética pelo nome do pai. (Dica: use findall/3 ou apenas listing(pai).).

Anote suas respostas e confira no SWI-Prolog. Lembre-se de usar ; para ver todas as soluções!

8. Resumo e próximos passos

O que aprendemos:

Consultas são perguntas feitas ao sistema no prompt ?-.
Consultas concretas retornam true ou false.
Variáveis (maiúsculas) permitem perguntas abertas, como “quem é o pai de X?”
O backtracking (com ;) encontra múltiplas respostas.
A unificação é o mecanismo que liga variáveis a valores.
Consultas são interativas; fatos são permanentes e ficam em arquivos.

Com as consultas, você já pode explorar toda a sua base de fatos. No próximo artigo, vamos aprender a criar regras — que são como “fatos derivados” — para responder perguntas mais complexas, como “quem são os avós?” ou “quem são os irmãos?”, sem precisar declarar cada relação explicitamente.

Fatos em Prolog: A Base do Conhecimento Lógico

16/07/202609/07/2026 Por antonino

Em Prolog, tudo começa com fatos. Eles são as verdades fundamentais sobre o mundo que o programa conhece. Enquanto em linguagens imperativas você declara variáveis e atribui valores, em Prolog você declara relações que são sempre verdadeiras. Neste artigo, vamos construir essa base sólida e aprender a criar, organizar e consultar fatos — o primeiro degrau para dominar a programação em lógica.

1. O que são fatos na programação em lógica?

Um fato é uma afirmação incondicionalmente verdadeira sobre o domínio do problema. Ele estabelece uma relação entre objetos do mundo real (ou abstratos) sem nenhuma condição adicional. Em Prolog, fatos são a base de conhecimento a partir da qual o sistema irá raciocinar.

Por exemplo, se estamos modelando uma árvore genealógica, podemos afirmar que “José é pai de Ana” e “Maria é mãe de Ana”. Essas são verdades absolutas no nosso universo — não dependem de nada mais para serem verdadeiras.

        💡 Analogia: Pense nos fatos como as “linhas da verdade” em um banco de dados relacional, mas com muito mais poder: eles não apenas armazenam dados, mas também servem como base para inferências lógicas.
    

2. Sintaxe correta dos fatos

A sintaxe de um fato em Prolog é simples, mas rigorosa. Cada fato segue a estrutura:

predicado(argumento1, argumento2, ...).

1	predicado(argumento1, argumento2, ...).

Regras de nomenclatura (essenciais!)

Predicados e átomos (nomes de relações e objetos) devem começar com letra minúscula. Exemplos: pai, ana, jose.
Variáveis (que ainda não conhecem valor) começam com letra maiúscula ou underscore. Exemplos: X, Pessoa, _Temp.
O ponto final (.) é obrigatório no final de cada fato e de cada consulta. Esquecê-lo é o erro mais comum entre iniciantes!
Números podem ser usados como átomos (ex: idade(jose, 42).), mas não podem iniciar um predicado.

⚠️ Atenção: Prolog diferencia maiúsculas de minúsculas. Escrever Pai(jose, ana). (com P maiúsculo) cria uma variável Pai, não o predicado pai. Isso é uma fonte clássica de erros!

3. Construindo nossa árvore genealógica (passo a passo)

Vamos criar uma base de fatos sobre uma família fictícia. Queremos registrar relações de pai e mãe.

Considere a seguinte família:

adão e eva são pai e mãe de cain, abel e set.

No arquivo familia.pl, escrevemos:

% Fatos sobre pais
% Fatos sobre pais
 
pai(adão, cain).
mae(eva, cain).

pai(adão, abel).
mae(eva, abel).

pai(adão, seth).
mae(eva, seth).

% Fatos sobre pais

pai(adão, cain).

mae(eva, cain).

pai(adão, abel).

mae(eva, abel).

pai(adão, seth).

mae(eva, seth).

Observe que usamos dois predicados diferentes (pai/2 e mae/2) para modelar relações progenitoras. Cada fato tem exatamente dois argumentos: o primeiro é o progenitor, o segundo é o descendente.

4. Organizando fatos em um arquivo `.pl`

Arquivos Prolog têm extensão .pl e contêm fatos, regras e consultas. Organize seu código de forma legível:

Agrupe fatos relacionados (ex: todos os pai juntos).
Use comentários com % para explicar seções.
Mantenha um fato por linha — isso facilita a leitura e a depuração.

Nosso arquivo familia.pl completo ficaria:



% ===========================================
% Árvore genealógica da família 
% ===========================================
 
% Relação pai
pai(adão, cain).
pai(adão, abel).
pai(adão, seth).

% Relação mãe
mae(eva, cain).
mae(eva, abel).
mae(eva, seth).

% ===========================================

% Árvore genealógica da família

% ===========================================

% Relação pai

pai(adão, cain).

pai(adão, abel).

pai(adão, seth).

% Relação mãe

mae(eva, cain).

mae(eva, abel).

mae(eva, seth).

5. Carregando fatos no SWI-Prolog com `consult/1`

Com o arquivo salvo, inicie o SWI-Prolog no mesmo diretório (ou use o caminho completo). Para carregar os fatos, use o predicado consult/1:

?- consult('familia.pl').
true.

1 2	?- consult('familia.pl'). true.

Atalho: você também pode usar ?- [familia]. (sem aspas e sem extensão).

Se o arquivo estiver em outro diretório, use o caminho absoluto ou mude o diretório com cd/1:

?- cd('c:/meus_projetos/prolog').
?- consult('familia.pl').

1 2	?- cd('c:/meus_projetos/prolog'). ?- consult('familia.pl').

        Verificação: Se o carregamento for bem-sucedido, o sistema responde com true. Se houver erro de sintaxe, ele apontará a linha e o problema — preste atenção ao ponto final e às maiúsculas/minúsculas.
    

6. Verificando os fatos carregados com `listing/1`

Para conferir se todos os fatos foram carregados corretamente, use o predicado listing/1. Ele exibe todos os fatos e regras de um predicado específico:

?- listing(pai).
% listando fatos de pai...
pai(jose, ana).
pai(jose, carlos).
pai(joao, jose).

?- listing(mae).
% listando fatos de mae...
mae(maria, ana).
mae(maria, carlos).
mae(paula, jose).
mae(ana, pedro).

?- listing(pai).

% listando fatos de pai...

pai(jose, ana).

pai(jose, carlos).

pai(joao, jose).

?- listing(mae).

% listando fatos de mae...

mae(maria, ana).

mae(maria, carlos).

mae(paula, jose).

mae(ana, pedro).

Se você usar listing. (sem argumento), o sistema mostra todos os predicados carregados. Isso é útil para depuração geral.

7. Erros comuns de sintaxe (e como evitá-los)

Erro	Exemplo errado	Correção
Esquecer o ponto final	`pai(jose, ana)`	`pai(jose, ana).`
Predicado com maiúscula	`Pai(jose, ana).` (vira variável)	`pai(jose, ana).`
Átomo com maiúscula	`pai(Jose, ana).` (vira variável)	`pai(jose, ana).`
Espaço entre predicado e parêntese	`pai (jose, ana).`	`pai(jose, ana).` (sem espaço)
Vírgula faltando entre argumentos	`pai(jose ana).`	`pai(jose, ana).`

Dica de ouro: Sempre que carregar um arquivo e receber false ou erro de sintaxe, verifique primeiro o ponto final e a capitalização. Mais de 80% dos erros de iniciantes vêm daí.

8. Exercício prático: crie uma base de fatos sobre um domínio diferente

Agora é sua vez! Escolha um domínio e crie um arquivo .pl com pelo menos 8 fatos. Exemplos:

Cardápio de restaurante: prato(lasanha, 25.90). bebida(agua, 4.50).
Biblioteca: livro(harry_potter, jk_rowling, 1997). autor(jk_rowling, britanica).
Times de futebol: time(flamengo, rio_de_janeiro). jogador(flamengo, gabigol).
Catálogo de filmes: filme(interestelar, ficcao, 2014). diretor(interestelar, christopher_nolan).

Passos sugeridos:

Crie o arquivo com seus fatos.
Carregue no SWI-Prolog.
Use listing. para confirmar.
Faça consultas simples: ?- prato(lasanha, Preco). (a variável Preco será ligada ao valor).
Teste com consultas que falham: ?- livro(senhor_dos_aneis, _, _).

9. Resumo e desafio final

Resumo: Fatos são a base de qualquer programa Prolog. Eles estabelecem relações incondicionalmente verdadeiras usando predicados e átomos em minúsculas, terminados por um ponto final. Organize seus fatos em arquivos .pl, carregue com consult/1 e verifique com listing/1. Dominar a sintaxe dos fatos é o primeiro passo para criar sistemas de conhecimento complexos.

🚀 Desafio: expanda a árvore genealógica

Com base nos fatos de familia.pl que criamos, adicione mais duas gerações:

Inclua os avós de Carlos (paternos e maternos).
Adicione irmãos para José.
Crie fatos para casado/2 (ex: casado(jose, maria).).
Por fim, use listing. para ver todos os fatos carregados e consulte: Quem é avô de Pedro? (ainda sem regras, apenas com os fatos que você inseriu).

Esse exercício vai consolidar a sintaxe e preparar o terreno para as regras que veremos no próximo artigo!

1. O que são consultas?

2. Consultas com fatos concretos: o veredito yes/no

3. Variáveis: perguntas abertas com X, Y, Pessoa

4. Múltiplas respostas: o ponto-e-vírgula (;) e o backtracking

5. Explorando a árvore genealógica com consultas

🔹 Quem são os filhos de Adão?

🔹 Quem é o pai de Enos?

🔹 Quem são os netos de Adão?

🔹 Quem são os bisnetos de Adão?

6. Consultas vs. Fatos: qual a diferença?

7. 📝 Exercícios práticos para você

8. Resumo e próximos passos

1. O que são fatos na programação em lógica?

2. Sintaxe correta dos fatos

Regras de nomenclatura (essenciais!)

3. Construindo nossa árvore genealógica (passo a passo)

4. Organizando fatos em um arquivo .pl

5. Carregando fatos no SWI-Prolog com consult/1

6. Verificando os fatos carregados com listing/1

7. Erros comuns de sintaxe (e como evitá-los)

8. Exercício prático: crie uma base de fatos sobre um domínio diferente

9. Resumo e desafio final

🚀 Desafio: expanda a árvore genealógica

2. Consultas com fatos concretos: o veredito `yes/no`

3. Variáveis: perguntas abertas com `X`, `Y`, `Pessoa`

4. Múltiplas respostas: o ponto-e-vírgula (`;`) e o backtracking

4. Organizando fatos em um arquivo `.pl`

5. Carregando fatos no SWI-Prolog com `consult/1`

6. Verificando os fatos carregados com `listing/1`