Arquivo de Lógica - Área de Trampo

Simulação com Regras de Negócio: Decisões Automatizadas

25/04/202623/04/2026 Por antonino

– Python
– Logica (limitada)
1 – pyDatalog
2 – SymPy (lógica simbólica)
3 – Simulação com regras (ex: regras de negócio)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Regras de negócio definem decisões importantes. Elas capturam políticas e lógica da organização. Primeiramente, uma simulação aplica essas regras repetidamente. Dessa forma, permite testar cenários antes da implementação real. Por exemplo, “se renda maior que 2000 então aprovar crédito”. Sem regras, o código fica cheio de if-else espalhados. Além disso, alterar regras exige mudanças no código fonte. Com simulação declarativa, as regras ficam isoladas. Portanto, a manutenção se torna muito mais simples. Assim, os especialistas de negócio podem validar diretamente. Empresas ágeis adotaram essa abordagem. Consequentemente, erros são detectados mais cedo.

Características fundamentais da simulação com regras

Uma característica central envolve a separação lógica-dados. As regras residem em um módulo isolado da aplicação. Outra propriedade importante é o encadeamento de regras. Uma regra pode disparar outra automaticamente. Isso se chama inferência em cadeia. O motor de regras gerencia esse fluxo complexo. Além disso, regras podem ter prioridades diversas. Regras mais específicas sobrepõem as genéricas. Isso resolve conflitos de decisão naturalmente. Uma fórmula que representa uma regra é:

$\text{SE} \quad \text{Condição} \quad \text{ENTÃO} \quad \text{Ação}$

Isso representa o formato ECA (Evento-Condição-Ação). Primeiramente, avalie todas as condições disponíveis. Depois, execute as ações correspondentes. Portanto, a simulação replica o comportamento humano.

Outra característica consiste na transparência da decisão. Cada regra pode usar documentação em linguagem natural. Isso facilita auditoria e conformidade regulatória. Por exemplo, “cliente VIP recebe 15% de desconto”. Os stakeholders entendem sem conhecimento técnico. Consequentemente, a comunicação melhora significativamente.

Quando utilizar simulação baseada em regras

Use simulação para sistemas de aprovação automatizada. Crédito, empréstimos e seguros são exemplos clássicos. Além disso, use para motores de recomendação de produtos. Sistemas de precificação dinâmica se beneficiam muito. Outro bom uso aparece na validação de formulários complexos. Regras de elegibilidade para benefícios fiscais se aplicam. Da mesma forma, use para simular cenários “e se”. “E se aumentarmos o desconto para 20%?” é testável. Por outro lado, evite regras para processos com muitas exceções. Se o número de regras ultrapassar 500, avalie alternativas. Primeiramente, comece com um pequeno conjunto de regras. Depois, expanda gradualmente conforme necessário. Portanto, simulação com regras escala bem inicialmente.

Outro bom uso funciona em jogos de estratégia com regras. Simule jogadores virtuais seguindo regras fixas. Da mesma maneira, use em chatbots baseados em decisões estruturadas. Sistemas especialistas popularizaram isso nos anos 80. Hoje, ainda é útil para domínios bem definidos. Portanto, não subestime essa abordagem clássica. Em suma, a versatilidade das regras é notável.

Exemplo prático: sistema de aprovação de crédito

O código abaixo implementa um motor de regras simples. A base de conhecimento contém fatos sobre clientes. Um conjunto de regras avalia cada cliente candidato. As regras são representadas como funções puras. Primeiramente, coletamos todas as condições satisfeitas. Depois, aplicamos as ações correspondentes. Observe como as regras são fáceis de ler e modificar. Nenhum if-else aninhado polui a lógica principal. Além disso, novas regras são adicionadas sem dor. Vamos ao código completo com vários exemplos.

# ============================================
# SISTEMA DE REGRAS PARA APROVAÇÃO DE CRÉDITO
# ============================================

from typing import Dict, List, Callable, Any
from dataclasses import dataclass
from enum import Enum

class Decisao(Enum):
    APROVADO = "Aprovado"
    REPROVADO = "Reprovado"
    REVISAR_MANUAL = "Revisar manualmente"

@dataclass
class Cliente:
    nome: str
    renda_mensal: float
    divida_total: float
    score_credito: int
    tempo_emprego_meses: int
    idade: int
    ja_cliente: bool = False
    quantidade_parcelas_sugerida: int = 0

@dataclass
class ResultadoAvaliacao:
    cliente_nome: str
    decisao: Decisao
    razoes: List[str]
    score_final: int
    valor_maximo: float
    parcelas_sugeridas: int

# ============================================
# BASE DE REGRAS (DEFINIDAS DECLARATIVAMENTE)
# ============================================

# Formato: (condicao, acao, descricao)
regras = []

def regra(condicao, acao, descricao):
    """Decorador para adicionar regras à base."""
    regras.append((condicao, acao, descricao))
    return acao

# Regras de reprovação (motivos bloqueantes)
def motivo_reprovacao(cond):
    return lambda dados: cond(dados)

@regra(
    lambda c: c.score_credito < 300,
    lambda c: "Score abaixo de 300",
    "Cliente com score muito baixo é reprovado automaticamente"
)
def regra_score_minimo(cliente):
    return "Score abaixo de 300"

@regra(
    lambda c: c.renda_mensal < 1000,
    lambda c: "Renda abaixo de R$ 1.000",
    "Renda mínima necessária é R$ 1.000"
)
def regra_renda_minima(cliente):
    return "Renda abaixo de R$ 1.000"

@regra(
    lambda c: c.idade < 18,
    lambda c: "Idade mínima não atingida (18 anos)",
    "Cliente deve ser maior de idade"
)
def regra_idade_minima(cliente):
    return "Idade mínima não atingida"

@regra(
    lambda c: (c.divida_total / c.renda_mensal) > 0.5,
    lambda c: f"Comprometimento de renda alto: {(c.divida_total/c.renda_mensal)*100:.1f}%",
    "Dívida não pode exceder 50% da renda mensal"
)
def regra_comprometimento(cliente):
    return f"Comprometimento de renda alto"

# Regras de bonificação (aumento de score)
@regra(
    lambda c: c.tempo_emprego_meses > 24,
    lambda c: 15,
    "Bônus de +15 pontos por tempo de emprego (>2 anos)"
)
def bonus_tempo_emprego(cliente):
    return 15

@regra(
    lambda c: c.ja_cliente,
    lambda c: 10,
    "Bônus de +10 pontos por ser cliente antigo"
)
def bonus_cliente_antigo(cliente):
    return 10

@regra(
    lambda c: c.idade >= 25 and c.idade <= 40,
    lambda c: 5,
    "Bônus de +5 pontos pela faixa etária ideal"
)
def bonus_idade(cliente):
    return 5

# Regras de decisão final baseadas no score final
def calcular_valor_aprovado(score, renda):
    """Calcula valor máximo de crédito baseado no score."""
    if score >= 700:
        return renda * 0.8  # 80% da renda
    elif score >= 500:
        return renda * 0.5
    elif score >= 350:
        return renda * 0.3
    else:
        return 0

def calcular_parcelas(score, renda, valor):
    """Sugere número de parcelas baseado no score."""
    if score >= 700:
        return min(36, int(valor / (renda * 0.1)))
    elif score >= 500:
        return min(24, int(valor / (renda * 0.15)))
    else:
        return 12

# ============================================
# MOTOR DE SIMULAÇÃO
# ============================================

def simular_cliente(cliente: Cliente) -> ResultadoAvaliacao:
    """Aplica todas as regras a um cliente e retorna decisão."""
    razoes_reprovacao = []
    bonus_total = 0
    
    # Verificar regras de reprovação
    for condicao, acao, descricao in regras:
        # Se condição parece ser de reprovação (retorna string)
        if callable(acao) and descricao != "Bônus de ...":
            try:
                if condicao(cliente):
                    resultado = acao(cliente)
                    if isinstance(resultado, str):
                        razoes_reprovacao.append(resultado)
            except:
                pass
    
    # Calcular bônus (regras que retornam números)
    for condicao, acao, descricao in regras:
        if "Bônus" in descricao and callable(condicao):
            if condicao(cliente):
                if callable(acao):
                    bonus = acao(cliente)
                    if isinstance(bonus, (int, float)):
                        bonus_total += bonus
    
    # Score final
    score_final = cliente.score_credito + bonus_total
    
    # Decidir com base nas reprovações e score
    if razoes_reprovacao:
        decisao = Decisao.REPROVADO
    elif score_final >= 500:
        decisao = Decisao.APROVADO
    elif score_final >= 350:
        decisao = Decisao.REVISAR_MANUAL
    else:
        decisao = Decisao.REPROVADO
    
    # Calcular valor máximo e parcelas
    if decisao == Decisao.APROVADO:
        valor_maximo = calcular_valor_aprovado(score_final, cliente.renda_mensal)
        parcelas = calcular_parcelas(score_final, cliente.renda_mensal, valor_maximo)
    else:
        valor_maximo = 0
        parcelas = 0
    
    return ResultadoAvaliacao(
        cliente_nome=cliente.nome,
        decisao=decisao,
        razoes=razoes_reprovacao,
        score_final=score_final,
        valor_maximo=valor_maximo,
        parcelas_sugeridas=parcelas
    )

# ============================================
# SIMULAÇÃO DE MÚLTIPLOS CENÁRIOS
# ============================================

def simular_cenarios(clientes: List[Cliente]) -> List[ResultadoAvaliacao]:
    """Simula vários clientes em lote."""
    resultados = []
    for cliente in clientes:
        resultado = simular_cliente(cliente)
        resultados.append(resultado)
    return resultados

def analisar_sensibilidade(cliente_base: Cliente, variavel: str, valores: List[Any]):
    """Testa como uma variável impacta a decisão."""
    print(f"\n=== Análise de sensibilidade: {variavel} ===")
    for valor in valores:
        cliente_mod = Cliente(**cliente_base.__dict__)
        setattr(cliente_mod, variavel, valor)
        resultado = simular_cliente(cliente_mod)
        print(f"{variavel} = {valor}: {resultado.decisao.value} (Score: {resultado.score_final})")

# ============================================
# EXECUÇÃO DOS EXEMPLOS
# ============================================

if __name__ == "__main__":
    print("=== SIMULAÇÃO DE REGRAS DE CRÉDITO ===\n")
    
    # Cenários de teste
    clientes_teste = [
        Cliente("Ana Silva", 5000, 1000, 720, 36, 30, True),
        Cliente("Carlos Souza", 800, 200, 550, 12, 25, False),
        Cliente("Mariana Lima", 3000, 2000, 480, 6, 22, False),
        Cliente("Roberto Alves", 4500, 0, 650, 48, 45, True),
        Cliente("Juliana M", 2000, 1200, 320, 3, 19, False),
        Cliente("Fernando R", 6000, 2500, 590, 18, 35, True),
    ]
    
    # Simular todos
    resultados = simular_cenarios(clientes_teste)
    
    # Exibir resultados
    for r in resultados:
        print(f"Cliente: {r.cliente_nome}")
        print(f"  Decisão: {r.decisao.value}")
        print(f"  Score final: {r.score_final}")
        if r.razoes:
            for razao in r.razoes:
                print(f"  - {razao}")
        if r.decisao == Decisao.APROVADO:
            print(f"  Valor máximo: R$ {r.valor_maximo:,.2f}")
            print(f"  Parcelas sugeridas: {r.parcelas_sugeridas}x")
        print()
    
    # Análise de sensibilidade
    cliente_referencia = Cliente("Referência", 3000, 800, 550, 24, 30, True)
    
    analisar_sensibilidade(cliente_referencia, "score_credito", [300, 400, 500, 600, 700])
    analisar_sensibilidade(cliente_referencia, "renda_mensal", [1500, 2500, 3500, 5000])
    analisar_sensibilidade(cliente_referencia, "divida_total", [500, 1000, 1500, 2000])
    
    # ============================================
    # SIMULAÇÃO COM REGRAS BASEADAS EM PYTHON PURO
    # ============================================
    print("\n=== Simulação de Regras com pyDatalog (Opcional) ===")
    print("Para simulações mais avançadas, instale pyDatalog:")
    print("pip install pyDatalog")
    
    # Exemplo conceitual sem dependência
    print("\nExemplo de regras declarativas (simuladas):")
    print("""
    Regras para desconto progressivo:
    - SE valor > 1000 ENTÃO desconto = 10%
    - SE valor > 5000 ENTÃO desconto = 15%
    - SE cliente_vip ENTÃO desconto_adicional = 5%
    - SE primeira_compra ENTÃO desconto_adicional = 0%
    """)
    
    def calcular_desconto(valor, vip, primeira_compra):
        if valor > 5000:
            desconto = 0.15
        elif valor > 1000:
            desconto = 0.10
        else:
            desconto = 0.05
        
        if vip:
            desconto += 0.05
        if primeira_compra:
            desconto = max(0.05, desconto - 0.02)
        
        return min(desconto, 0.30)  # Cap de 30%
    
    testes_desconto = [
        (6000, True, False, "VIP com alto valor"),
        (2000, False, True, "Primeira compra valor médio"),
        (800, False, False, "Compra pequena normal"),
    ]
    
    for valor, vip, primeira, desc in testes_desconto:
        desc_calc = calcular_desconto(valor, vip, primeira)
        print(f"  {desc}: Valor R${valor}, VIP={vip}, 1ª compra={primeira} -> Desconto {desc_calc*100:.0f}%")

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

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

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

# SISTEMA DE REGRAS PARA APROVAÇÃO DE CRÉDITO

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

from typing import Dict, List, Callable, Any

from dataclasses import dataclass

from enum import Enum

class Decisao(Enum):

APROVADO = "Aprovado"

REPROVADO = "Reprovado"

REVISAR_MANUAL = "Revisar manualmente"

@dataclass

class Cliente:

nome: str

renda_mensal: float

divida_total: float

score_credito: int

tempo_emprego_meses: int

idade: int

ja_cliente: bool = False

quantidade_parcelas_sugerida: int = 0

@dataclass

class ResultadoAvaliacao:

cliente_nome: str

decisao: Decisao

razoes: List[str]

score_final: int

valor_maximo: float

parcelas_sugeridas: int

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

# BASE DE REGRAS (DEFINIDAS DECLARATIVAMENTE)

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

# Formato: (condicao, acao, descricao)

regras = []

def regra(condicao, acao, descricao):

"""Decorador para adicionar regras à base."""

regras.append((condicao, acao, descricao))

return acao

# Regras de reprovação (motivos bloqueantes)

def motivo_reprovacao(cond):

return lambda dados: cond(dados)

@regra(

lambda c: c.score_credito < 300,

lambda c: "Score abaixo de 300",

"Cliente com score muito baixo é reprovado automaticamente"

)

def regra_score_minimo(cliente):

return "Score abaixo de 300"

@regra(

lambda c: c.renda_mensal < 1000,

lambda c: "Renda abaixo de R$ 1.000",

"Renda mínima necessária é R$ 1.000"

)

def regra_renda_minima(cliente):

return "Renda abaixo de R$ 1.000"

@regra(

lambda c: c.idade < 18,

lambda c: "Idade mínima não atingida (18 anos)",

"Cliente deve ser maior de idade"

)

def regra_idade_minima(cliente):

return "Idade mínima não atingida"

@regra(

lambda c: (c.divida_total / c.renda_mensal) > 0.5,

lambda c: f"Comprometimento de renda alto: {(c.divida_total/c.renda_mensal)*100:.1f}%",

"Dívida não pode exceder 50% da renda mensal"

)

def regra_comprometimento(cliente):

return f"Comprometimento de renda alto"

# Regras de bonificação (aumento de score)

@regra(

lambda c: c.tempo_emprego_meses > 24,

lambda c: 15,

"Bônus de +15 pontos por tempo de emprego (>2 anos)"

)

def bonus_tempo_emprego(cliente):

return 15

@regra(

lambda c: c.ja_cliente,

lambda c: 10,

"Bônus de +10 pontos por ser cliente antigo"

)

def bonus_cliente_antigo(cliente):

return 10

@regra(

lambda c: c.idade >= 25 and c.idade <= 40,

lambda c: 5,

"Bônus de +5 pontos pela faixa etária ideal"

)

def bonus_idade(cliente):

return 5

# Regras de decisão final baseadas no score final

def calcular_valor_aprovado(score, renda):

"""Calcula valor máximo de crédito baseado no score."""

if score >= 700:

return renda * 0.8 # 80% da renda

elif score >= 500:

return renda * 0.5

elif score >= 350:

return renda * 0.3

else:

return 0

def calcular_parcelas(score, renda, valor):

"""Sugere número de parcelas baseado no score."""

if score >= 700:

return min(36, int(valor / (renda * 0.1)))

elif score >= 500:

return min(24, int(valor / (renda * 0.15)))

else:

return 12

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

# MOTOR DE SIMULAÇÃO

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

def simular_cliente(cliente: Cliente) -> ResultadoAvaliacao:

"""Aplica todas as regras a um cliente e retorna decisão."""

razoes_reprovacao = []

bonus_total = 0

# Verificar regras de reprovação

for condicao, acao, descricao in regras:

# Se condição parece ser de reprovação (retorna string)

if callable(acao) and descricao != "Bônus de ...":

try:

if condicao(cliente):

resultado = acao(cliente)

if isinstance(resultado, str):

razoes_reprovacao.append(resultado)

except:

pass

# Calcular bônus (regras que retornam números)

for condicao, acao, descricao in regras:

if "Bônus" in descricao and callable(condicao):

if condicao(cliente):

if callable(acao):

bonus = acao(cliente)

if isinstance(bonus, (int, float)):

bonus_total += bonus

# Score final

score_final = cliente.score_credito + bonus_total

# Decidir com base nas reprovações e score

if razoes_reprovacao:

decisao = Decisao.REPROVADO

elif score_final >= 500:

decisao = Decisao.APROVADO

elif score_final >= 350:

decisao = Decisao.REVISAR_MANUAL

else:

decisao = Decisao.REPROVADO

# Calcular valor máximo e parcelas

if decisao == Decisao.APROVADO:

valor_maximo = calcular_valor_aprovado(score_final, cliente.renda_mensal)

parcelas = calcular_parcelas(score_final, cliente.renda_mensal, valor_maximo)

else:

valor_maximo = 0

parcelas = 0

return ResultadoAvaliacao(

cliente_nome=cliente.nome,

decisao=decisao,

razoes=razoes_reprovacao,

score_final=score_final,

valor_maximo=valor_maximo,

parcelas_sugeridas=parcelas

)

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

# SIMULAÇÃO DE MÚLTIPLOS CENÁRIOS

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

def simular_cenarios(clientes: List[Cliente]) -> List[ResultadoAvaliacao]:

"""Simula vários clientes em lote."""

resultados = []

for cliente in clientes:

resultado = simular_cliente(cliente)

resultados.append(resultado)

return resultados

def analisar_sensibilidade(cliente_base: Cliente, variavel: str, valores: List[Any]):

"""Testa como uma variável impacta a decisão."""

print(f"\n=== Análise de sensibilidade: {variavel} ===")

for valor in valores:

cliente_mod = Cliente(**cliente_base.__dict__)

setattr(cliente_mod, variavel, valor)

resultado = simular_cliente(cliente_mod)

print(f"{variavel} = {valor}: {resultado.decisao.value} (Score: {resultado.score_final})")

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

# EXECUÇÃO DOS EXEMPLOS

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

if __name__ == "__main__":

print("=== SIMULAÇÃO DE REGRAS DE CRÉDITO ===\n")

# Cenários de teste

clientes_teste = [

Cliente("Ana Silva", 5000, 1000, 720, 36, 30, True),

Cliente("Carlos Souza", 800, 200, 550, 12, 25, False),

Cliente("Mariana Lima", 3000, 2000, 480, 6, 22, False),

Cliente("Roberto Alves", 4500, 0, 650, 48, 45, True),

Cliente("Juliana M", 2000, 1200, 320, 3, 19, False),

Cliente("Fernando R", 6000, 2500, 590, 18, 35, True),

]

# Simular todos

resultados = simular_cenarios(clientes_teste)

# Exibir resultados

for r in resultados:

print(f"Cliente: {r.cliente_nome}")

print(f" Decisão: {r.decisao.value}")

print(f" Score final: {r.score_final}")

if r.razoes:

for razao in r.razoes:

print(f" - {razao}")

if r.decisao == Decisao.APROVADO:

print(f" Valor máximo: R$ {r.valor_maximo:,.2f}")

print(f" Parcelas sugeridas: {r.parcelas_sugeridas}x")

print()

# Análise de sensibilidade

cliente_referencia = Cliente("Referência", 3000, 800, 550, 24, 30, True)

analisar_sensibilidade(cliente_referencia, "score_credito", [300, 400, 500, 600, 700])

analisar_sensibilidade(cliente_referencia, "renda_mensal", [1500, 2500, 3500, 5000])

analisar_sensibilidade(cliente_referencia, "divida_total", [500, 1000, 1500, 2000])

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

# SIMULAÇÃO COM REGRAS BASEADAS EM PYTHON PURO

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

print("\n=== Simulação de Regras com pyDatalog (Opcional) ===")

print("Para simulações mais avançadas, instale pyDatalog:")

print("pip install pyDatalog")

# Exemplo conceitual sem dependência

print("\nExemplo de regras declarativas (simuladas):")

print("""

Regras para desconto progressivo:

- SE valor > 1000 ENTÃO desconto = 10%

- SE valor > 5000 ENTÃO desconto = 15%

- SE cliente_vip ENTÃO desconto_adicional = 5%

- SE primeira_compra ENTÃO desconto_adicional = 0%

""")

def calcular_desconto(valor, vip, primeira_compra):

if valor > 5000:

desconto = 0.15

elif valor > 1000:

desconto = 0.10

else:

desconto = 0.05

if vip:

desconto += 0.05

if primeira_compra:

desconto = max(0.05, desconto - 0.02)

return min(desconto, 0.30) # Cap de 30%

testes_desconto = [

(6000, True, False, "VIP com alto valor"),

(2000, False, True, "Primeira compra valor médio"),

(800, False, False, "Compra pequena normal"),

]

for valor, vip, primeira, desc in testes_desconto:

desc_calc = calcular_desconto(valor, vip, primeira)

print(f" {desc}: Valor R${valor}, VIP={vip}, 1ª compra={primeira} -> Desconto {desc_calc*100:.0f}%")

No exemplo, as regras de negócio seguem estilo declarativo. Cada regra opera independente e permite testes fáceis. O motor de simulação aplica as regras em qualquer ordem. Primeiramente, avaliamos as regras bloqueantes. Depois, acumulamos os bônus progressivamente. A decisão final combina todas as informações disponíveis. Observe que a lógica principal não possui condicionais. Ela apenas itera sobre as regras registradas. Isso significa que novas regras são simples de adicionar. Portanto, a manutenção fica extremamente facilitada. Além disso, podemos auditar a simulação passo a passo. Cada regra aplicada ganha registro e explicação.

Outra vantagem importante consiste na análise de sensibilidade. Podemos modificar parâmetros e ver o impacto imediato. “E se o score mínimo subir para 400?” torna-se testável rapidamente. “E se aumentarmos o limite de comprometimento?” também. Isso permite decisões baseadas em dados simulados. Os stakeholders de negócio participam desse processo. Eles ajustam regras e observam resultados em tempo real. Portanto, a simulação com regras funciona como ferramenta colaborativa. Para sistemas maiores, use motores especializados como Drools. Contudo, o Python puro já resolve problemas pequenos. Primeiramente, comece com a abordagem mostrada aqui. Depois, escale se necessário. Assim, você evita complexidade prematura.

📌 Benefícios da simulação com regras:
✅ Separação clara entre lógica e dados
✅ Regras legíveis por não-programadores
✅ Simulação de cenários “e se” rápida
✅ Manutenção simplificada e auditável
✅ Testes isolados por regra individual

Finalmente, documente cada regra com exemplos claros. Use casos de teste para validar o comportamento esperado. Mantenha as regras atômicas e sem efeitos colaterais. Isso facilita a composição e a depuração eficiente. Além disso, versionar regras junto ao código faz diferença. Portanto, utilize Git para rastrear mudanças históricas. Assim, você reverte alterações problemáticas rapidamente. Lembre-se: regras de negócio mudam com frequência. Simular antes de implementar em produção evita surpresas. Portanto, adote essa prática desde o início. Seu projeto se tornará mais robusto e adaptável. Aproveite os exemplos e crie seu próprio sistema de regras.

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

25/04/202623/04/2026 Por antonino

– Python
– Logica (limitada)
1 – pyDatalog
2 – SymPy (lógica simbólica)
3 – Simulação com regras (ex: regras de negócio)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

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.