Python vai além da lógica booleana tradicional. Bibliotecas como pyDatalog e SymPy expandem esse horizonte. Primeiramente, pyDatalog implementa programação lógica. Ela é inspirada em Prolog para Python puro. SymPy é uma biblioteca de matemática simbólica. Ambas permitem simular sistemas baseados em regras. Por exemplo, regras de negócio podem ser formalizadas. Isso é útil para sistemas especialistas e inferência. Além disso, a simulação com regras é declarativa. Você descreve o que o sistema deve fazer, não como. Portanto, essas ferramentas elevam o nível de abstração. Assim, problemas complexos se tornam mais tratáveis.
pyDatalog: programação lógica em Python
pyDatalog adiciona fatos e regras a programas Python.
Um fato é uma afirmação verdadeira sobre o mundo.
Por exemplo, “pai(jose, ana)” significa que José é pai de Ana.
Uma regra define relacionamentos condicionais.
Por exemplo, “avô(X, Z) :- pai(X, Y), pai(Y, Z)”.
Isso significa: X é avô de Z se X é pai de Y e Y é pai de Z.
Primeiramente, instale com pip install pyDatalog.
As consultas retornam todas as soluções possíveis.
Isso foi inspirado em bancos de dados dedutivos.
Consequentemente, você faz perguntas complexas declarativamente.
Use pyDatalog para sistemas de recomendação.
Também para validação de regras de negócio.
Portanto, é uma ferramenta poderosa para lógica simbólica.
Uma fórmula que representa uma regra pyDatalog é:
SymPy: matemática simbólica e lógica formal
SymPy manipula expressões matemáticas simbolicamente.
Ela resolve equações, simplifica termos e calcula derivadas.
Além disso, SymPy possui módulo de lógica proposicional.
Você pode criar símbolos lógicos e avaliar expressões.
Por exemplo, And(x, Or(y, z)) representa uma fórmula.
Use satisfiable() para encontrar valores que a tornam verdadeira.
Isso foi projetado para verificação de tautologias.
Primeiramente, instale com pip install sympy.
SymPy também resolve quantificadores lógicos.
Por exemplo, “existe um x tal que P(x) é verdadeiro”.
Use para sistemas de verificação formal.
Também para provadores de teoremas educacionais.
Portanto, SymPy é uma ferramenta acadêmica robusta.
Outra aplicação é a simulação com restrições. Defina regras de negócio como equações matemáticas. SymPy resolve sistemas de inequações automaticamente. Isso foi usado em planejamento financeiro e logística. Por exemplo, “orçamento < custo_total + margem”. A biblioteca encontra os valores que satisfazem as restrições. Assim, você automatiza decisões complexas. Portanto, SymPy vai além da matemática pura.
Quando usar cada ferramenta na simulação de regras
Use pyDatalog para relações hierárquicas e recursivas. Árvores genealógicas, grafos e sistemas de permissões são ideais. Também use para motores de inferência simples. Por outro lado, use SymPy para restrições numéricas. Regras de preços, descontos e impostos se encaixam. Além disso, use SymPy quando precisar de provas formais. Para sistemas mistos, combine ambas as bibliotecas. Primeiramente, modele as regras em linguagem natural. Depois, traduza para fatos pyDatalog ou equações SymPy. Isso facilita a validação com stakeholders de negócio. Evite pyDatalog para cálculos numéricos intensivos. SymPy não é otimizada para milhões de fatos. Portanto, escolha a ferramenta adequada ao seu problema.
Outro bom uso é para simulação de cenários de negócio. Por exemplo, regras de aprovação de crédito. “Cliente aprovado se renda > 2000 e sem restrições”. Você implementa como regras declarativas. Depois, testa diferentes combinações de entradas. Isso foi adotado em fintechs e seguradoras. Portanto, essas ferramentas são práticas e relevantes.
Exemplo prático: sistema de regras com pyDatalog e SymPy
O código abaixo demonstra ambas as bibliotecas. Primeiro, um sistema de parentesco com pyDatalog. Definimos fatos sobre uma família típica. Regras definem avô, irmão e tio. Depois, consultamos relações interessantes. Em seguida, usamos SymPy para lógica proposicional. Criamos símbolos para variáveis lógicas. Avaliamos expressões e verificamos consistência. Por fim, um sistema de restrições financeiras. Resolvemos inequações para encontrar valores permitidos. Observe como a lógica declarativa simplifica a tarefa. 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 |
# Instalação: pip install pyDatalog sympy # ============================================ # PARTE 1: PYDATALOG - RELAÇÕES FAMILIARES # ============================================ print("=== pyDatalog: Genealogia ===") from pyDatalog import pyDatalog # Criar termos pyDatalog.create_terms('pai, mae, avo, irmao, tio, X, Y, Z') # Fatos (base de conhecimento) +pai('joao', 'maria') +pai('joao', 'jose') +pai('carlos', 'ana') +pai('jose', 'lucas') +mae('maria', 'ana') +mae('maria', 'paulo') +mae('ana', 'sofia') # Regra: avô avo(X, Z) <= pai(X, Y) & pai(Y, Z) # Regra: irmão (mesmo pai) irmao(X, Y) <= pai(Z, X) & pai(Z, Y) & (X != Y) # Regra: tio (irmão dos pais) tio(X, Y) <= irmao(X, Z) & pai(Z, Y) # Consultas print("Avôs de ana:") print(avo(X, 'ana')) print("\nIrmãos de ana:") print(irmao(X, 'ana')) print("\nTios de sofia:") print(tio(X, 'sofia')) # Consulta com argumento variável print("\nTodos os avôs e netos:") print(avo(X, Y)) # ============================================ # PARTE 2: SYMPY - LÓGICA PROPOSICIONAL # ============================================ print("\n=== SymPy: Lógica e Tabelas Verdade ===") from sympy import symbols, And, Or, Not, Implies, satisfiable, simplify_logic from sympy.logic.boolalg import truth_table # Definir símbolos lógicos a, b, c = symbols('a b c') # Expressão: (a AND b) OR (NOT a AND c) expr = Or(And(a, b), And(Not(a), c)) print(f"Expressão: {expr}") # Simplificar simplificada = simplify_logic(expr) print(f"Simplificada: {simplificada}") # Verificar se é satisfatória print(f"Satisfatível? {satisfiable(expr)}") # Encontrar uma solução (valores que tornam verdadeiro) solucao = satisfiable(expr, all_models=False) print(f"Uma solução: {solucao}") # Leis de De Morgan demonstradas dm = Not(And(a, b)) dm_equiv = Or(Not(a), Not(b)) print(f"\nDe Morgan: {dm} é equivalente a {dm_equiv}") print(f"São equivalentes? {simplify_logic(dm) == simplify_logic(dm_equiv)}") # Implicação lógica: A -> B é equivalente a NOT A OR B implicacao = Implies(a, b) equivalente = Or(Not(a), b) print(f"Implicação {implicacao} = {equivalente}") # ============================================ # PARTE 3: SYMPY - RESTRIÇÕES E REGRAS DE NEGÓCIO # ============================================ print("\n=== SymPy: Restrições de Negócio ===") from sympy.solvers import solve_univariate_inequality from sympy import Symbol, Eq, Le, And # Regra de aprovação de crédito renda = Symbol('renda', real=True) divida = Symbol('divida', real=True) score = Symbol('score', real=True) # Regra: renda > 2000, divida/renda < 0.3, score > 600 regra1 = renda > 2000 regra2 = (divida / renda) < 0.3 regra3 = score > 600 regra_aprovacao = And(regra1, regra2, regra3) print(f"Regra de aprovação: {regra_aprovacao}") # Testar um cenário específico from sympy import solve cenario = {renda: 5000, divida: 1000, score: 650} avaliacao = {} for cond in regra_aprovacao.args: resultado = cond.subs(cenario) avaliacao[str(cond)] = resultado print(f"Avaliação do cenário: {avaliacao}") # Resolver a faixa de renda permitida (dívida e score fixos) divida_fixa = 1000 score_fixo = 700 regra_renda = (renda > 2000) & ((divida_fixa / renda) < 0.3) # Simplificar a condição da renda from sympy import reduce_inequalities try: rendas_permitidas = reduce_inequalities(regra_renda, renda) print(f"Renda permitida: {rendas_permitidas}") except: # Solução manual cond1 = renda > 2000 cond2 = renda > (divida_fixa / 0.3) limiar = divida_fixa / 0.3 print(f"Renda deve ser > 2000 e > {limiar:.2f}, ou seja > {max(2000, limiar):.2f}") # ============================================ # PARTE 4: SIMULAÇÃO COM REGRAS MISTAS # ============================================ print("\n=== Simulação de Regras de Negócio ===") # Simular diferentes combinações de renda e dívida cenarios = [ {"renda": 1800, "divida": 500, "score": 700, "nome": "Renda baixa"}, {"renda": 3000, "divida": 1200, "score": 580, "nome": "Score baixo"}, {"renda": 3000, "divida": 1200, "score": 650, "nome": "Dívida alta"}, {"renda": 5000, "divida": 800, "score": 720, "nome": "Aprovado ideal"}, {"renda": 2500, "divida": 400, "score": 710, "nome": "Aprovado limite"}, ] def avaliar_cliente(renda_val, divida_val, score_val): """Avalia cliente baseado nas regras.""" regras = [ ("Renda adequada", renda_val > 2000), ("Dívida controlada", (divida_val / renda_val) < 0.3), ("Score suficiente", score_val > 600), ] resultados = [] for nome, ok in regras: resultados.append(f"{nome}: {'✅' if ok else '❌'}") aprovado = all(ok for _, ok in regras) return aprovado, resultados print("\nAnálise de cenários:") for cenario in cenarios: aprovado, detalhes = avaliar_cliente(cenario["renda"], cenario["divida"], cenario["score"]) print(f"\n{cenario['nome']} (R${cenario['renda']}, Dívida: R${cenario['divida']}, Score: {cenario['score']})") print(f" Aprovado: {'✅ SIM' if aprovado else '❌ NÃO'}") for det in detalhes: print(f" {det}") |
Nos exemplos, a abordagem declarativa é evidenciada. pyDatalog resolve relações recursivas com facilidade. Apenas declaramos fatos e regras. O motor de inferência encontra as respostas automaticamente. SymPy, por outro lado, manipula símbolos matematicamente. As regras de negócio são expressas como inequações. O sistema encontra os valores que as satisfazem. Primeiramente, modele seu domínio como fatos ou equações. Depois, deixe a biblioteca fazer as deduções. Isso reduz drasticamente a complexidade do código imperativo. Além disso, a manutenção das regras se torna mais simples. Portanto, para problemas com muitas regras, vale o esforço.
Outro ponto importante é a documentação das regras. Regras declarativas são quase linguagem natural. Stakeholders de negócio podem validá-las diretamente. Isso foi um diferencial em projetos de sucesso. Para sistemas maiores, combine pyDatalog com bancos de dados. SymPy integra-se bem com pandas para análise numérica. Porém, o desempenho tem seus limites inevitáveis. Para milhões de fatos ou equações, considere outras soluções. Nesses casos, use bancos de dados gráficos ou solvers dedicados. Primeiramente, prototipe com Python para validar a lógica. Depois, escale para soluções mais robustas se necessário. Assim, você ganha agilidade sem comprometer qualidade.
✅ pyDatalog: relações lógicas, árvores, sistemas especialistas
✅ SymPy: matemática simbólica, restrições, lógica formal
✅ Combinação: regras mistas (relações + matemática)
Finalmente, experimente criar seu próprio sistema de regras. Comece com um domínio pequeno, como aprovação de empréstimos. Ou implemente um sistema de recomendação de filmes. Use pyDatalog para relações de gêneros e atores. Use SymPy para calcular notas e preferências. A combinação delas é extremamente poderosa. Portanto, essas bibliotecas merecem seu estudo. Instale e brinque com os exemplos fornecidos. Você descobrirá novas formas de resolver problemas. Assim, seu repertório técnico se expande significativamente.