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 é:
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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.
✅
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.