Lógica – Página: 2 – Área de Trampo

SymPy: Lógica Proposicional e Matemática Simbólica

22/05/202623/04/2026 Por antonino

SymPy é uma biblioteca Python para matemática simbólica. Ela manipula expressões exatas, não números aproximados. Primeiramente, o módulo de lógica proposicional merece destaque. Ele permite criar e avaliar fórmulas booleanas. Operadores como And, Or e Not são suportados. Além disso, é possível verificar validade e equivalência. Use satisfiable() para encontrar valores verdadeiros. Isso foi inspirado em provadores de teoremas automáticos. Portanto, SymPy oferece um kit de ferramentas lógico. Assim, você resolve problemas de raciocínio formal. Diferente de programas imperativos, você declara fatos. O sistema deduz consequências logicamente válidas.

Fundamentos da lógica proposicional no SymPy

A lógica proposicional trabalha com variáveis booleanas. Cada variável pode ser Verdadeiro (True) ou Falso (False). Conectivos lógicos combinam essas variáveis básicas. And(A, B) é verdadeiro apenas se A e B forem verdadeiros. Or(A, B) é verdadeiro se pelo menos um for verdadeiro. Not(A) inverte o valor da variável. Implies(A, B) representa “se A então B”. Isso é equivalente a Or(Not(A), B) logicamente. Equivalent(A, B) testa igualdade entre expressões. Primeiramente, crie símbolos com symbols(). Depois, construa expressões aninhadas livremente. Uma fórmula típica seria: And(A, Or(B, C)). Portanto, você codifica sentenças lógicas diretamente.

Uma fórmula que representa tautologia é:

\(\vdash (P \lor \neg P)\)

Isso significa que “P ou não P” é sempre verdadeiro. SymPy pode verificar tautologias automaticamente. Consequentemente, você valida argumentos lógicos. Outra operação útil é a simplificação lógica. simplify_logic(expr) reduz expressões complexas. Isso foi projetado para otimizar condições de programas. Portanto, SymPy é útil antes da geração de código.

Quando utilizar SymPy para lógica simbólica

Use SymPy para verificar regras de negócio críticas. Elas devem ser logicamente consistentes e corretas. Também use para simplificar condições complexas de if. Sistemas de aprovação com múltiplos critérios são exemplos. Outro bom uso é para tabelas verdade educacionais. Estudantes podem explorar conectivos lógicos visualmente. Além disso, use para resolver problemas de satisfatibilidade. O quebra-cabeça “Quem é o assassino?” pode ser solucionado. Evite SymPy para fórmulas com milhões de variáveis. A complexidade cresce exponencialmente nesse caso. Primeiramente, modele problemas de tamanho pequeno. Depois, escale para problemas médios gradualmente. Portanto, SymPy é educacional e prático.

Outra aplicação importante é a prova de teoremas. Você demonstra que uma fórmula é consequência de outras. Use Implies(premissas, conclusao) e teste validade. Isso foi usado em cursos de lógica computacional. Também em validação de circuitos digitais simples. Portanto, SymPy conecta matemática à programação prática.

Exemplo prático: verificação e simplificação lógica

O código abaixo explora o módulo lógico do SymPy. Criamos variáveis e expressões booleanas variadas. Verificamos equivalências e tautologias conhecidas. Também demonstramos tabelas verdade simplificadas. Por fim, resolvemos um quebra-cabeça lógico real. Observe como a lógica é expressa naturalmente. SymPy se encarrega dos cálculos e deduções. Vamos ao código comentado para detalhes.

# Instalação: pip install sympy

from sympy import symbols, satisfiable, simplify_logic, to_dnf, to_cnf
from sympy.logic.boolalg import (
    And, Or, Not, Implies, Equivalent, Nand, Nor, Xor,
    truth_table, is_tautology, is_contradiction, is_satisfiable
)
from sympy.logic import simplify

# ============================================
# EXEMPLO 1: CONSTRUINDO EXPRESSÕES LÓGICAS
# ============================================
print("=== Criando Expressões Lógicas ===\n")

# Definir símbolos (variáveis proposicionais)
a, b, c, d = symbols('a b c d')

# Expressões básicas
expr1 = And(a, b)                    # a AND b
expr2 = Or(a, b)                     # a OR b
expr3 = Not(a)                       # NOT a
expr4 = Implies(a, b)                # a -> b (se a então b)
expr5 = Equivalent(a, b)             # a <-> b
expr6 = Xor(a, b)                    # OU exclusivo

print(f"a AND b: {expr1}")
print(f"a OR b: {expr2}")
print(f"NOT a: {expr3}")
print(f"a -> b: {expr4}")
print(f"a <-> b: {expr5}")
print(f"XOR a b: {expr6}")

# Expressão composta
composta = And(a, Or(b, c))
print(f"\nComposta: {composta}")


# ============================================
# EXEMPLO 2: SIMPLIFICAÇÃO DE EXPRESSÕES
# ============================================
print("\n=== Simplificação Lógica ===\n")

# Expressão complexa
expr_complexa = Or(And(a, b), And(a, Not(b)))
print(f"Original: {expr_complexa}")
print(f"Simplificada: {simplify_logic(expr_complexa)}")

# Outro exemplo com redundância
exemplo2 = Or(And(a, b), And(a, b, c))
print(f"\nOriginal: {exemplo2}")
print(f"Simplificada: {simplify_logic(exemplo2)}")

# Exemplo da lei de absorção
absorcao = Or(a, And(a, b))
print(f"\nAbsorção: {absorcao} = {simplify_logic(absorcao)}")

# Forma normal disjuntiva (DNF) e conjuntiva (CNF)
dnf_form = to_dnf(exemplo2)
cnf_form = to_cnf(exemplo2)
print(f"\nForma DNF: {dnf_form}")
print(f"Forma CNF: {cnf_form}")


# ============================================
# EXEMPLO 3: VERIFICAÇÃO DE TAUTOLOGIAS E CONTRADIÇÕES
# ============================================
print("\n=== Verificação de Propriedades ===\n")

# Tautologia: sempre verdadeira
tautologia = Or(a, Not(a))
print(f"Lei do terceiro excluído: {tautologia}")
print(f"É tautologia? {is_tautology(tautologia)}")

# Contradição: sempre falsa
contradicao = And(a, Not(a))
print(f"\nContradição: {contradicao}")
print(f"É contradição? {is_contradiction(contradicao)}")

# Lei de De Morgan
lei_demorgan = Equivalent(Not(And(a, b)), Or(Not(a), Not(b)))
print(f"\nLei de De Morgan: {lei_demorgan}")
print(f"É tautologia? {is_tautology(lei_demorgan)}")

# Equivalência lógica dupla negacao
eq_dupla = Equivalent(a, Not(Not(a)))
print(f"\nDupla negação: {eq_dupla}")
print(f"É tautologia? {is_tautology(eq_dupla)}")


# ============================================
# EXEMPLO 4: SATISFATIBILIDADE E MODELOS
# ============================================
print("\n=== Resolução de Fórmulas (SAT) ===\n")

# Expressão: a AND b
expr_sat = And(a, b)
print(f"Expressão: {expr_sat}")
print(f"É satisfatível? {is_satisfiable(expr_sat)}")
print(f"Modelos encontrados: {list(satisfiable(expr_sat, all_models=True))}")

# Expressão: a AND NOT a (insatisfatível)
expr_insat = And(a, Not(a))
print(f"\nExpressão: {expr_insat}")
print(f"É satisfatível? {is_satisfiable(expr_insat)}")
print(f"Modelo: {satisfiable(expr_insat)}")

# Expressão sem variáveis (True/False)
print(f"\nTrue é satisfatível? {is_satisfiable(True)}")
print(f"False é satisfatível? {is_satisfiable(False)}")

# Quebra-cabeça simples: (a ou b) e (não a) -> b deve ser verdadeiro
regra = And(Or(a, b), Not(a))
print(f"\nRegra: {regra}")
modelos = list(satisfiable(regra, all_models=True))
print(f"Modelos para a regra: {modelos}")
print(f"Avaliação: em todos, b = {modelos[0][b]} (como esperado)")


# ============================================
# EXEMPLO 5: TABELA VERDADE
# ============================================
print("\n=== Tabela Verdade ===\n")

# Função para mostrar tabela verdade formatada
def mostrar_tabela_verdade(expr, var_list):
    """Exibe tabela verdade de uma expressão lógica."""
    print(f"Tabela verdade para: {expr}")
    print("  " + "\t".join(var_list) + f"\t| {expr}")
    print("-" * (len(var_list) * 10 + 15))
    
    from itertools import product
    for valores in product([True, False], repeat=len(var_list)):
        substituicao = {var: val for var, val in zip(var_list, valores)}
        resultado = expr.subs(substituicao)
        linha = "\t".join(str(val) for val in valores)
        print(f"  {linha}\t| {resultado}")

# Criar expressão: a XOR b
xpr = Xor(a, b)
mostrar_tabela_verdade(xpr, [a, b])

# Expressão: (a AND b) OR c
expr_tab = Or(And(a, b), c)
print("\n")
mostrar_tabela_verdade(expr_tab, [a, b, c])


# ============================================
# EXEMPLO 6: QUEBRA-CABEÇA LÓGICO (SUSPEITOS)
# ============================================
print("\n=== Quebra-cabeça: Amigos e Honestidade ===\n")

# Enunciado: Três pessoas, A, B, e C.
# A diz: "B é mentiroso"
# B diz: "C é mentiroso"
# C diz: "A e B são mentirosos"
# Mentiroso sempre mente, honesto sempre fala verdade.
# Quem é honesto?

# Símbolos: h_A significa "A é honesto"
h_A, h_B, h_C = symbols('h_A h_B h_C')

# Mentiroso é o contrário de honesto
m_A = Not(h_A)
m_B = Not(h_B)
m_C = Not(h_C)

# A diz "B é mentiroso". Isso é verdade se h_A verdadeiro.
# Portanto: h_A <-> m_B
frase_A = Equivalent(h_A, m_B)

# B diz "C é mentiroso"
frase_B = Equivalent(h_B, m_C)

# C diz "A e B são mentirosos"
frase_C = Equivalent(h_C, And(m_A, m_B))

# Todas as frases são verdade simultaneamente
# (o que cada um disse deve ser consistente com quem é honesto)
sistema = And(frase_A, frase_B, frase_C)

print(f"Sistema lógico: {sistema}\n")

# Encontrar soluções
solucoes = list(satisfiable(sistema, all_models=True))

if solucoes:
    for i, sol in enumerate(solucoes, 1):
        print(f"Solução {i}:")
        for var, val in sol.items():
            print(f"  {var} = {val}")
        # Identificar honestos
        honestos = [str(var) for var, val in sol.items() if val == True]
        print(f"  Honestos: {honestos if honestos else 'Nenhum'}")
        print()
else:
    print("Nenhuma solução encontrada!")

# Verificação manual (para clareza)
print("=== Interpretação da solução ===")
print("Se h_A é falso, A é mentiroso. Sua frase 'B é mentiroso' é falsa,")
print("então B é honesto. Se h_B verdadeiro, sua frase 'C é mentiroso' é verdade,")
print("logo C é mentiroso. Se C é mentiroso, sua frase 'A e B são mentirosos' é falsa,")
print("portanto A ou B é honesto. Como B é honesto, a frase de C é falsa. Tudo consistente!")
print("Solução única: A = mentiroso, B = honesto, C = mentiroso.")


# ============================================
# EXEMPLO 7: EQUIVALÊNCIA DE CIRCUITOS LÓGICOS
# ============================================
print("\n=== Verificação de Equivalentes ===")

# Circuito 1: (A AND B) OR (A AND C)
circuito1 = Or(And(a, b), And(a, c))
print(f"Circuito 1: {circuito1}")

# Circuito 2: A AND (B OR C)
circuito2 = And(a, Or(b, c))
print(f"Circuito 2: {circuito2}")

# Verificar se são equivalentes
equivalencia = Equivalent(circuito1, circuito2)
print(f"\nSão logicamente equivalentes? {is_tautology(equivalencia)}")

# Simplificar diferença
print(f"Lei distributiva: {circuito1} = {simplify_logic(circuito1)}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

# Instalação: pip install sympy

from sympy import symbols, satisfiable, simplify_logic, to_dnf, to_cnf

from sympy.logic.boolalg import (

And, Or, Not, Implies, Equivalent, Nand, Nor, Xor,

truth_table, is_tautology, is_contradiction, is_satisfiable

)

from sympy.logic import simplify

# ============================================

# EXEMPLO 1: CONSTRUINDO EXPRESSÕES LÓGICAS

# ============================================

print("=== Criando Expressões Lógicas ===\n")

# Definir símbolos (variáveis proposicionais)

a, b, c, d = symbols('a b c d')

# Expressões básicas

expr1 = And(a, b) # a AND b

expr2 = Or(a, b) # a OR b

expr3 = Not(a) # NOT a

expr4 = Implies(a, b) # a -> b (se a então b)

expr5 = Equivalent(a, b) # a <-> b

expr6 = Xor(a, b) # OU exclusivo

print(f"a AND b: {expr1}")

print(f"a OR b: {expr2}")

print(f"NOT a: {expr3}")

print(f"a -> b: {expr4}")

print(f"a <-> b: {expr5}")

print(f"XOR a b: {expr6}")

# Expressão composta

composta = And(a, Or(b, c))

print(f"\nComposta: {composta}")

# ============================================

# EXEMPLO 2: SIMPLIFICAÇÃO DE EXPRESSÕES

# ============================================

print("\n=== Simplificação Lógica ===\n")

# Expressão complexa

expr_complexa = Or(And(a, b), And(a, Not(b)))

print(f"Original: {expr_complexa}")

print(f"Simplificada: {simplify_logic(expr_complexa)}")

# Outro exemplo com redundância

exemplo2 = Or(And(a, b), And(a, b, c))

print(f"\nOriginal: {exemplo2}")

print(f"Simplificada: {simplify_logic(exemplo2)}")

# Exemplo da lei de absorção

absorcao = Or(a, And(a, b))

print(f"\nAbsorção: {absorcao} = {simplify_logic(absorcao)}")

# Forma normal disjuntiva (DNF) e conjuntiva (CNF)

dnf_form = to_dnf(exemplo2)

cnf_form = to_cnf(exemplo2)

print(f"\nForma DNF: {dnf_form}")

print(f"Forma CNF: {cnf_form}")

# ============================================

# EXEMPLO 3: VERIFICAÇÃO DE TAUTOLOGIAS E CONTRADIÇÕES

# ============================================

print("\n=== Verificação de Propriedades ===\n")

# Tautologia: sempre verdadeira

tautologia = Or(a, Not(a))

print(f"Lei do terceiro excluído: {tautologia}")

print(f"É tautologia? {is_tautology(tautologia)}")

# Contradição: sempre falsa

contradicao = And(a, Not(a))

print(f"\nContradição: {contradicao}")

print(f"É contradição? {is_contradiction(contradicao)}")

# Lei de De Morgan

lei_demorgan = Equivalent(Not(And(a, b)), Or(Not(a), Not(b)))

print(f"\nLei de De Morgan: {lei_demorgan}")

print(f"É tautologia? {is_tautology(lei_demorgan)}")

# Equivalência lógica dupla negacao

eq_dupla = Equivalent(a, Not(Not(a)))

print(f"\nDupla negação: {eq_dupla}")

print(f"É tautologia? {is_tautology(eq_dupla)}")

# ============================================

# EXEMPLO 4: SATISFATIBILIDADE E MODELOS

# ============================================

print("\n=== Resolução de Fórmulas (SAT) ===\n")

# Expressão: a AND b

expr_sat = And(a, b)

print(f"Expressão: {expr_sat}")

print(f"É satisfatível? {is_satisfiable(expr_sat)}")

print(f"Modelos encontrados: {list(satisfiable(expr_sat, all_models=True))}")

# Expressão: a AND NOT a (insatisfatível)

expr_insat = And(a, Not(a))

print(f"\nExpressão: {expr_insat}")

print(f"É satisfatível? {is_satisfiable(expr_insat)}")

print(f"Modelo: {satisfiable(expr_insat)}")

# Expressão sem variáveis (True/False)

print(f"\nTrue é satisfatível? {is_satisfiable(True)}")

print(f"False é satisfatível? {is_satisfiable(False)}")

# Quebra-cabeça simples: (a ou b) e (não a) -> b deve ser verdadeiro

regra = And(Or(a, b), Not(a))

print(f"\nRegra: {regra}")

modelos = list(satisfiable(regra, all_models=True))

print(f"Modelos para a regra: {modelos}")

print(f"Avaliação: em todos, b = {modelos[0][b]} (como esperado)")

# ============================================

# EXEMPLO 5: TABELA VERDADE

# ============================================

print("\n=== Tabela Verdade ===\n")

# Função para mostrar tabela verdade formatada

def mostrar_tabela_verdade(expr, var_list):

"""Exibe tabela verdade de uma expressão lógica."""

print(f"Tabela verdade para: {expr}")

print(" " + "\t".join(var_list) + f"\t| {expr}")

print("-" * (len(var_list) * 10 + 15))

from itertools import product

for valores in product([True, False], repeat=len(var_list)):

substituicao = {var: val for var, val in zip(var_list, valores)}

resultado = expr.subs(substituicao)

linha = "\t".join(str(val) for val in valores)

print(f" {linha}\t| {resultado}")

# Criar expressão: a XOR b

xpr = Xor(a, b)

mostrar_tabela_verdade(xpr, [a, b])

# Expressão: (a AND b) OR c

expr_tab = Or(And(a, b), c)

print("\n")

mostrar_tabela_verdade(expr_tab, [a, b, c])

# ============================================

# EXEMPLO 6: QUEBRA-CABEÇA LÓGICO (SUSPEITOS)

# ============================================

print("\n=== Quebra-cabeça: Amigos e Honestidade ===\n")

# Enunciado: Três pessoas, A, B, e C.

# A diz: "B é mentiroso"

# B diz: "C é mentiroso"

# C diz: "A e B são mentirosos"

# Mentiroso sempre mente, honesto sempre fala verdade.

# Quem é honesto?

# Símbolos: h_A significa "A é honesto"

h_A, h_B, h_C = symbols('h_A h_B h_C')

# Mentiroso é o contrário de honesto

m_A = Not(h_A)

m_B = Not(h_B)

m_C = Not(h_C)

# A diz "B é mentiroso". Isso é verdade se h_A verdadeiro.

# Portanto: h_A <-> m_B

frase_A = Equivalent(h_A, m_B)

# B diz "C é mentiroso"

frase_B = Equivalent(h_B, m_C)

# C diz "A e B são mentirosos"

frase_C = Equivalent(h_C, And(m_A, m_B))

# Todas as frases são verdade simultaneamente

# (o que cada um disse deve ser consistente com quem é honesto)

sistema = And(frase_A, frase_B, frase_C)

print(f"Sistema lógico: {sistema}\n")

# Encontrar soluções

solucoes = list(satisfiable(sistema, all_models=True))

if solucoes:

for i, sol in enumerate(solucoes, 1):

print(f"Solução {i}:")

for var, val in sol.items():

print(f" {var} = {val}")

# Identificar honestos

honestos = [str(var) for var, val in sol.items() if val == True]

print(f" Honestos: {honestos if honestos else 'Nenhum'}")

print()

else:

print("Nenhuma solução encontrada!")

# Verificação manual (para clareza)

print("=== Interpretação da solução ===")

print("Se h_A é falso, A é mentiroso. Sua frase 'B é mentiroso' é falsa,")

print("então B é honesto. Se h_B verdadeiro, sua frase 'C é mentiroso' é verdade,")

print("logo C é mentiroso. Se C é mentiroso, sua frase 'A e B são mentirosos' é falsa,")

print("portanto A ou B é honesto. Como B é honesto, a frase de C é falsa. Tudo consistente!")

print("Solução única: A = mentiroso, B = honesto, C = mentiroso.")

# ============================================

# EXEMPLO 7: EQUIVALÊNCIA DE CIRCUITOS LÓGICOS

# ============================================

print("\n=== Verificação de Equivalentes ===")

# Circuito 1: (A AND B) OR (A AND C)

circuito1 = Or(And(a, b), And(a, c))

print(f"Circuito 1: {circuito1}")

# Circuito 2: A AND (B OR C)

circuito2 = And(a, Or(b, c))

print(f"Circuito 2: {circuito2}")

# Verificar se são equivalentes

equivalencia = Equivalent(circuito1, circuito2)

print(f"\nSão logicamente equivalentes? {is_tautology(equivalencia)}")

# Simplificar diferença

print(f"Lei distributiva: {circuito1} = {simplify_logic(circuito1)}")

Os exemplos mostram a versatilidade da lógica no SymPy. Primeiramente, você define variáveis como símbolos. Depois, constrói expressões usando conectivos. A função simplify_logic() reduz complexidade automaticamente. Isso é útil para otimizar condições de programas. Além disso, a verificação de tautologias é direta. Use is_tautology() para checar verdades universais. O método satisfiable() encontra modelos que satisfazem a fórmula. Isso resolve problemas de restrição lógica. No quebra-cabeça dos suspeitos, a solução foi encontrada. Observe como a especificação é declarativa e clara. Portanto, SymPy é uma ferramenta educacional poderosa.

Outro ponto importante é a integração com matemática. Expressões lógicas podem conter comparações numéricas. Por exemplo, And(x > 0, x < 10) é suportado. Isso amplia o uso para sistemas de restrições híbridos. A resolução de quebra-cabeças lógicos é um caso de uso natural. Também é útil para verificação de circuitos digitais. Engenheiros podem validar simplificações de portas lógicas. Portanto, SymPy conecta matemática simbólica à lógica. Primeiramente, estude os exemplos básicos fornecidos. Depois, aplique a problemas reais de validação. Assim, você evita erros sutis em regras complexas. Finalmente, a documentação oficial tem muitos recursos adicionais.

📌 Funções úteis do módulo lógico SymPy:
✅ And, Or, Not, Implies, Equivalent, Xor – conectivos
✅ simplify_logic() – simplifica expressões
✅ is_tautology() / is_contradiction() – verifica propriedades
✅ satisfiable() – encontra valores verdadeiros
✅ to_dnf() / to_cnf() – formas normais
✅ truth_table() – gera tabelas verdade

SymPy lida bem com até dezenas de variáveis lógicas. Para centenas ou milhares, use solvers SAT dedicados. No entanto, para aprendizado e prototipação é excelente. A integração com outras partes da biblioteca é forte. Você pode combinar lógica com álgebra e cálculo. Isso foi projetado para pesquisas acadêmicas. Portanto, invista tempo aprendendo SymPy logic. Você ganhará uma ferramenta valiosa e divertida. Experimente escrever suas próprias regras de negócio. Valide-as com o verificador de tautologias. Assim, você garante que as regras são consistentes. Por fim, compartilhe seus achados com a comunidade.

pyDatalog: Lógica Declarativa Dentro do Python

22/05/202623/04/2026 Por antonino

pyDatalog é uma biblioteca que implementa programação lógica. Ela é inspirada em Prolog, mas usa sintaxe Python. Primeiramente, você declara fatos sobre o mundo. Depois, define regras que derivam novos fatos. Por fim, faz consultas para extrair informações. Isso é muito diferente da programação imperativa comum. Em vez de dizer “como” fazer, você diz “o que” é verdade. O motor de inferência encontra todas as soluções. Além disso, pyDatalog suporta operações aritméticas. Também permite agregações como contagem e soma. Portanto, é uma ferramenta para problemas baseados em regras. Assim, você resolve problemas complexos de forma elegante.

Conceitos fundamentais do pyDatalog

Três conceitos principais formam o pyDatalog. Fatos são afirmações verdadeiras e indivisíveis. Por exemplo, +pai('joao', 'maria') é um fato. Regras definem relacionamentos condicionais. Elas usam o operador <= para implicação. Por exemplo, avo(X,Z) <= pai(X,Y) & pai(Y,Z). Consultas perguntam ao sistema por verdades. Use print(pai(X, 'maria')) para achar pais. Primeiramente, todos símbolos devem ser declarados. Use pyDatalog.create_terms() para isso. Além disso, pyDatalog usa avaliação de curto-circuito. Isso foi inspirado na resolução lógica de Robinson. Portanto, o sistema é completo e consistente.

Uma fórmula que representa uma regra é:

\(\text{Conclusão} \leftarrow \text{Condição}_1 \land \text{Condição}_2 \land \dots\)

Isso significa que a conclusão deriva das condições. O pyDatalog implementa isso com unificação de variáveis. Consequentemente, variáveis com maiúsculas são curingas. Constantes com minúsculas são valores literais. Essa convenção veio diretamente do Prolog tradicional.

Quando utilizar pyDatalog no seu projeto

Use pyDatalog para sistemas baseados em regras. Sistemas especialistas de diagnóstico são ideais. Também para motores de recomendação personalizados. Árvores genealógicas e grafos de parentesco são clássicos. Outro bom uso é para validação de regras de negócio. Por exemplo, regras de aprovação de crédito. Além disso, use para problemas de caminho em grafos. O pyDatalog encontra todas as rotas possíveis. Evite pyDatalog para cálculos numéricos pesados. Também não é adequado para milhões de fatos. Primeiramente, modele seu domínio com poucos dados. Depois, escale gradualmente se necessário. Portanto, avalie o tamanho do seu problema antes.

Outro caso de uso é em jogos baseados em lógica. Quebra-cabeças como Sudoku ou 8-rainhas. Você declara as regras e o pyDatalog resolve. Isso foi demonstrado em competições de IA. Use também para validação de pré-requisitos educacionais. “Aluno pode cursar P2 se aprovado em P1”. Assim, você centraliza a lógica de negócio. Portanto, pyDatalog é uma ferramenta versátil.

Exemplo prático: árvore genealógica e regras

O código abaixo implementa um sistema de parentesco. Definimos fatos sobre uma família típica. Regras estabelecem relações como avô e irmão. Consultas encontram parentes por inferência. Observe como nenhum loop foi escrito manualmente. O pyDatalog gerencia toda a recursão necessária. Isso é o poder da programação declarativa. Vamos ao código comentado para demonstração.

# Instalação: pip install pyDatalog

from pyDatalog import pyDatalog

# ============================================
# Passo 1: Declarar termos (símbolos)
# ============================================
pyDatalog.create_terms(
    'pai, mae, homem, mulher, filho, filha',
    'avo, avo_paterno, avo_materno, irmao, irma',
    'ancestral, descendente, primo',
    'X, Y, Z, W'
)

# ============================================
# Passo 2: Inserir fatos (base de conhecimento)
# ============================================

# Relações de parentesco direto
+pai('joao', 'maria')
+pai('joao', 'jose')
+pai('jose', 'lucas')
+pai('jose', 'sofia')
+pai('carlos', 'ana')
+pai('carlos', 'paulo')
+pai('paulo', 'rafa')

+mae('maria', 'ana')
+mae('maria', 'paulo')
+mae('ana', 'sofia')
+mae('ana', 'lucas')
+mae('lucia', 'jose')
+mae('lucia', 'maria')

# Gêneros (para regras como irmão vs irmã)
+homem('joao')
+homem('jose')
+homem('carlos')
+homem('paulo')
+homem('lucas')
+homem('rafa')

+mulher('maria')
+mulher('ana')
+mulher('lucia')
+mulher('sofia')


# ============================================
# Passo 3: Definir regras (lógica derivada)
# ============================================

# Regra: avô (pai do pai ou pai da mãe)
avo(X, Z) <= pai(X, Y) & pai(Y, Z)
avo(X, Z) <= pai(X, Y) & mae(Y, Z)

# Regra: avô paterno (pai do pai)
avo_paterno(X, Z) <= pai(X, Y) & pai(Y, Z)

# Regra: avô materno (pai da mãe)
avo_materno(X, Z) <= pai(X, Y) & mae(Y, Z)

# Regra: irmão (mesmo pai ou mesma mãe, diferente gênero)
irmao(X, Y) <= (pai(Z, X) & pai(Z, Y) | mae(Z, X) & mae(Z, Y)) & (X != Y) & homem(Y)

# Regra: irmã (mesmo pai ou mesma mãe, diferente gênero)
irma(X, Y) <= (pai(Z, X) & pai(Z, Y) | mae(Z, X) & mae(Z, Y)) & (X != Y) & mulher(Y)

# Regra: ancestral (recursiva)
ancestral(X, Y) <= pai(X, Y)
ancestral(X, Y) <= mae(X, Y)
ancestral(X, Y) <= pai(X, Z) & ancestral(Z, Y)
ancestral(X, Y) <= mae(X, Z) & ancestral(Z, Y)

# Regra: descendente (inverso do ancestral)
descendente(Y, X) <= ancestral(X, Y)

# Regra: primo (primos de primeiro grau)
primo(X, Y) <= pai(A, X) & pai(B, Y) & irmao(A, B)
primo(X, Y) <= pai(A, X) & mae(B, Y) & irmao(A, B)
primo(X, Y) <= mae(A, X) & pai(B, Y) & irmao(A, B)
primo(X, Y) <= mae(A, X) & mae(B, Y) & irmao(A, B)


# ============================================
# Passo 4: Consultas
# ============================================
print("=== Consultas Familiares ===")

print("\n1. Quem é avô de ana?")
print(avo(X, 'ana'))

print("\n2. Quem é avô paterno de lucas?")
print(avo_paterno(X, 'lucas'))

print("\n3. Quem é avô materno de sofia?")
print(avo_materno(X, 'sofia'))

print("\n4. Irmãos de ana:")
print(irmao(X, 'ana'))

print("\n5. Irmãs de jose:")
print(irma(X, 'jose'))

print("\n6. Antepassados de lucas:")
print(ancestral(X, 'lucas'))

print("\n7. Descendentes de joao:")
print(descendente(X, 'joao'))

print("\n8. Primos de ana:")
print(primo(X, 'ana'))

print("\n9. Todos os avôs e netos:")
print(avo(X, Y))


# ============================================
# Passo 5: Exemplo com aritmética e agregação
# ============================================
print("\n=== Aritmética e Agregação ===")

pyDatalog.create_terms('idade, total_idades, media_idade, N, Soma, Media')

# Fatos com idades
+idade('joao', 70)
+idade('maria', 65)
+idade('jose', 45)
+idade('ana', 40)
+idade('lucas', 15)
+idade('sofia', 12)

# Regra para somar idades (agregação)
total_idades(Soma) <= (Soma == sum_(idade(Y, N), for_each=N))

# Regra para calcular média
media_idade(Media) <= (Media == (sum_(idade(Y, N), for_each=N)) / (count_(idade(Y, N), for_each=N)))

print("Idades registradas:")
print(idade(X, Y))

print("\nSoma total das idades:")
print(total_idades(Soma))

print("\nMédia de idade:")
print(media_idade(Media))


# ============================================
# Passo 6: Resolvendo um quebra-cabeça lógico
# ============================================
print("\n=== Quebra-cabeça: Quem é o assassino? ===")

pyDatalog.create_terms('assassino, mentiroso, honesto, suspeito')

# Fatos: quem diz o quê
# Suspeitos: A, B, C, D
# A diz: "B é o assassino"
# B diz: "C é o assassino"  
# C diz: "D é o assassino"
# D diz: "Eu não sou o assassino"
# Apenas um é honesto, os outros mentem

# Regra: mentiroso se a afirmação é falsa
mentiroso('A') <= (assassino('B') != True)
mentiroso('B') <= (assassino('C') != True)
mentiroso('C') <= (assassino('D') != True)
mentiroso('D') <= (assassino('D') == True)

# Regra: honesto se não é mentiroso
honesto(X) <= ~mentiroso(X)

# Restrição: exatamente um honesto
# (implementado pelo número de soluções para honesto)

# Tentar cada possível assassino
for sus in ['A', 'B', 'C', 'D']:
    # Limpar fatos anteriores
    pyDatalog.clear()
    pyDatalog.create_terms('assassino, mentiroso, honesto, X')
    
    # Afirmar quem é o assassino
    +assassino(sus)
    
    # Recriar regras
    mentiroso('A') <= (assassino('B') != True)
    mentiroso('B') <= (assassino('C') != True)
    mentiroso('C') <= (assassino('D') != True)
    mentiroso('D') <= (assassino('D') == True)
    honesto(X) <= ~mentiroso(X)
    
    # Contar honestos
    honestos = list(honesto(X))
    if len(honestos) == 1:
        print(f"Solução encontrada! Assassino é {sus}")
        print(f"Honesto: {honestos[0][0]}")

print("\nNota: Este é um exemplo didático de inferência lógica.")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

# Instalação: pip install pyDatalog

from pyDatalog import pyDatalog

# ============================================

# Passo 1: Declarar termos (símbolos)

# ============================================

pyDatalog.create_terms(

'pai, mae, homem, mulher, filho, filha',

'avo, avo_paterno, avo_materno, irmao, irma',

'ancestral, descendente, primo',

'X, Y, Z, W'

)

# ============================================

# Passo 2: Inserir fatos (base de conhecimento)

# ============================================

# Relações de parentesco direto

+pai('joao', 'maria')

+pai('joao', 'jose')

+pai('jose', 'lucas')

+pai('jose', 'sofia')

+pai('carlos', 'ana')

+pai('carlos', 'paulo')

+pai('paulo', 'rafa')

+mae('maria', 'ana')

+mae('maria', 'paulo')

+mae('ana', 'sofia')

+mae('ana', 'lucas')

+mae('lucia', 'jose')

+mae('lucia', 'maria')

# Gêneros (para regras como irmão vs irmã)

+homem('joao')

+homem('jose')

+homem('carlos')

+homem('paulo')

+homem('lucas')

+homem('rafa')

+mulher('maria')

+mulher('ana')

+mulher('lucia')

+mulher('sofia')

# ============================================

# Passo 3: Definir regras (lógica derivada)

# ============================================

# Regra: avô (pai do pai ou pai da mãe)

avo(X, Z) <= pai(X, Y) & pai(Y, Z)

avo(X, Z) <= pai(X, Y) & mae(Y, Z)

# Regra: avô paterno (pai do pai)

avo_paterno(X, Z) <= pai(X, Y) & pai(Y, Z)

# Regra: avô materno (pai da mãe)

avo_materno(X, Z) <= pai(X, Y) & mae(Y, Z)

# Regra: irmão (mesmo pai ou mesma mãe, diferente gênero)

irmao(X, Y) <= (pai(Z, X) & pai(Z, Y) | mae(Z, X) & mae(Z, Y)) & (X != Y) & homem(Y)

# Regra: irmã (mesmo pai ou mesma mãe, diferente gênero)

irma(X, Y) <= (pai(Z, X) & pai(Z, Y) | mae(Z, X) & mae(Z, Y)) & (X != Y) & mulher(Y)

# Regra: ancestral (recursiva)

ancestral(X, Y) <= pai(X, Y)

ancestral(X, Y) <= mae(X, Y)

ancestral(X, Y) <= pai(X, Z) & ancestral(Z, Y)

ancestral(X, Y) <= mae(X, Z) & ancestral(Z, Y)

# Regra: descendente (inverso do ancestral)

descendente(Y, X) <= ancestral(X, Y)

# Regra: primo (primos de primeiro grau)

primo(X, Y) <= pai(A, X) & pai(B, Y) & irmao(A, B)

primo(X, Y) <= pai(A, X) & mae(B, Y) & irmao(A, B)

primo(X, Y) <= mae(A, X) & pai(B, Y) & irmao(A, B)

primo(X, Y) <= mae(A, X) & mae(B, Y) & irmao(A, B)

# ============================================

# Passo 4: Consultas

# ============================================

print("=== Consultas Familiares ===")

print("\n1. Quem é avô de ana?")

print(avo(X, 'ana'))

print("\n2. Quem é avô paterno de lucas?")

print(avo_paterno(X, 'lucas'))

print("\n3. Quem é avô materno de sofia?")

print(avo_materno(X, 'sofia'))

print("\n4. Irmãos de ana:")

print(irmao(X, 'ana'))

print("\n5. Irmãs de jose:")

print(irma(X, 'jose'))

print("\n6. Antepassados de lucas:")

print(ancestral(X, 'lucas'))

print("\n7. Descendentes de joao:")

print(descendente(X, 'joao'))

print("\n8. Primos de ana:")

print(primo(X, 'ana'))

print("\n9. Todos os avôs e netos:")

print(avo(X, Y))

# ============================================

# Passo 5: Exemplo com aritmética e agregação

# ============================================

print("\n=== Aritmética e Agregação ===")

pyDatalog.create_terms('idade, total_idades, media_idade, N, Soma, Media')

# Fatos com idades

+idade('joao', 70)

+idade('maria', 65)

+idade('jose', 45)

+idade('ana', 40)

+idade('lucas', 15)

+idade('sofia', 12)

# Regra para somar idades (agregação)

total_idades(Soma) <= (Soma == sum_(idade(Y, N), for_each=N))

# Regra para calcular média

media_idade(Media) <= (Media == (sum_(idade(Y, N), for_each=N)) / (count_(idade(Y, N), for_each=N)))

print("Idades registradas:")

print(idade(X, Y))

print("\nSoma total das idades:")

print(total_idades(Soma))

print("\nMédia de idade:")

print(media_idade(Media))

# ============================================

# Passo 6: Resolvendo um quebra-cabeça lógico

# ============================================

print("\n=== Quebra-cabeça: Quem é o assassino? ===")

pyDatalog.create_terms('assassino, mentiroso, honesto, suspeito')

# Fatos: quem diz o quê

# Suspeitos: A, B, C, D

# A diz: "B é o assassino"

# B diz: "C é o assassino"

# C diz: "D é o assassino"

# D diz: "Eu não sou o assassino"

# Apenas um é honesto, os outros mentem

# Regra: mentiroso se a afirmação é falsa

mentiroso('A') <= (assassino('B') != True)

mentiroso('B') <= (assassino('C') != True)

mentiroso('C') <= (assassino('D') != True)

mentiroso('D') <= (assassino('D') == True)

# Regra: honesto se não é mentiroso

honesto(X) <= ~mentiroso(X)

# Restrição: exatamente um honesto

# (implementado pelo número de soluções para honesto)

# Tentar cada possível assassino

for sus in ['A', 'B', 'C', 'D']:

# Limpar fatos anteriores

pyDatalog.clear()

pyDatalog.create_terms('assassino, mentiroso, honesto, X')

# Afirmar quem é o assassino

+assassino(sus)

# Recriar regras

mentiroso('A') <= (assassino('B') != True)

mentiroso('B') <= (assassino('C') != True)

mentiroso('C') <= (assassino('D') != True)

mentiroso('D') <= (assassino('D') == True)

honesto(X) <= ~mentiroso(X)

# Contar honestos

honestos = list(honesto(X))

if len(honestos) == 1:

print(f"Solução encontrada! Assassino é {sus}")

print(f"Honesto: {honestos[0][0]}")

print("\nNota: Este é um exemplo didático de inferência lógica.")

No código, a base de conhecimento é declarativa. Nenhum loop ou condicional foi escrito manualmente. O pyDatalog unifica variáveis e resolve recursões. Primeiramente, declare todos os termos usados. Depois, insira fatos com o operador +. Regras usam <= para implicação lógica. Consultas são feitas com expressões simples. O retorno é uma lista de tuplas com soluções. Além disso, o pyDatalog suporta negação com ~. Isso é útil para regras do tipo “não é verdade que”. Agregações como sum_ e count_ são suportadas. Portanto, você tem um sistema lógico completo.

Outro ponto importante é a recursão em regras. A regra ancestral é recursiva e funciona. O pyDatalog detecta automaticamente a recursão. Isso foi inspirado em bancos de dados dedutivos. Cuidado com recursão infinita em regras mal formuladas. Sempre tenha um caso base que não seja recursivo. Além disso, a performance piora com profundidade extrema. Para árvores muito profundas, considere outras soluções. Primeiramente, teste com dados pequenos e consistentes. Depois, expanda gradualmente o conhecimento. Assim, você evita surpresas de desempenho. Portanto, pyDatalog é robusto para problemas bem modelados.

📌 Resumo do pyDatalog:
✅ Fatos: conhecimento base (+fato)
✅ Regras: implicações (conclusão <= condição)
✅ Consultas: perguntas ao sistema (fato(X,Y))
✅ Agregações: sum_, count_, min_, max_
✅ Aritmética: operadores matemáticos padrão

Finalmente, explore exemplos da documentação oficial. O pyDatalog é mantido ativo e bem documentado. Use para prototipar sistemas especialistas rapidamente. Também para ensinar programação lógica em Python. A curva de aprendizado é suave para iniciantes. No entanto, problemas muito grandes podem exigir otimização. Nesses casos, exporte fatos para banco de dados. Use pyDatalog para a camada de regras apenas. Assim, você combina escalabilidade com expressividade. Portanto, pyDatalog merece um lugar no seu toolkit. Instale e comece a programar logicamente hoje mesmo. Você descobrirá um novo paradigma encantador.