Métodos de Tomada de Decisão

Mapa da Aula 2

Conexão com a Aula 1

• Na Aula 1 vimos que SADs usam modelos para apoiar decisões
• Os sistemas especialistas baseados em regras são um tipo clássico de SAD orientado a modelos
• Essas regras seguem uma lógica formal — que é exatamente o que estudamos hoje
• A lógica clássica diz respeito ao raciocínio preciso; a lógica fuzzy ao raciocínio impreciso
• Na saúde, a maioria das informações é linguística e vaga: “febre alta”, “pressão elevada”, “dor moderada”

O que é Lógica?

• Lógica é o estudo das formas corretas de raciocínio e inferência
• Permite derivar conclusões válidas a partir de premissas dadas
• Em computação e IA, a lógica fornece a linguagem para representar e manipular conhecimento
• Tipos de lógica variam no que podem expressar e em como tratam a incerteza e a imprecisão

Proposições e Valores de Verdade

• Uma proposição (denotada por \(p\), \(q\), etc.) é uma sentença declarativa que pode ser verdadeira (V) ou falsa (F)
• Não é uma pergunta, ordem ou exclamação
• Exemplos de proposições:
  • “O paciente tem temperatura acima de 38°C” → V ou F
  • “A pressão sistólica é maior que 140 mmHg” → V ou F
• Não são proposições:
  • “Qual é a saturação de O₂?” → pergunta
  • “A dor está melhorando” → vago (sem medida precisa)

Conectivos Lógicos

Sejam \(p\) e \(q\) proposições.

Conectivos Lógicos em R

Conectivos Lógicos em R

# SIRS: Síndrome da Resposta Inflamatória Sistêmica
febre       <- c(TRUE,  TRUE,  FALSE, TRUE,  FALSE)
taquicardia <- c(TRUE,  FALSE, TRUE,  TRUE,  FALSE)
dispneia    <- c(FALSE, TRUE,  FALSE, TRUE,  FALSE)

# Conjunção vetorizada — alerta por paciente
alerta_sirs     <- febre & taquicardia
alerta_resp     <- taquicardia | dispneia
alerta_combinado <- febre & (taquicardia | dispneia)

data.frame(febre, taquicardia, dispneia,
           SIRS = alerta_sirs,
           Resp = alerta_resp,
           Comb = alerta_combinado)

  febre taquicardia dispneia  SIRS  Resp  Comb
1  TRUE        TRUE    FALSE  TRUE  TRUE  TRUE
2  TRUE       FALSE     TRUE FALSE  TRUE  TRUE
3 FALSE        TRUE    FALSE FALSE  TRUE FALSE
4  TRUE        TRUE     TRUE  TRUE  TRUE  TRUE
5 FALSE       FALSE    FALSE FALSE FALSE FALSE

Tabelas-Verdade: Negação, Conjunção, Disjunção e Condicional

Tabelas-Verdade dos Conectivos Lógicos

Formas Normais

• Qualquer fórmula lógica pode ser convertida em formas padrão:
• Forma Normal Conjuntiva (FNC): conjunção de cláusulas disjuntivas \[(p \vee q) \wedge (\neg p \vee r) \wedge (q \vee \neg r)\]
• Forma Normal Disjuntiva (FND): disjunção de cláusulas conjuntivas \[(p \wedge q) \vee (\neg p \wedge r)\]
• Úteis para algoritmos de inferência em sistemas especialistas
• A FNC é a base do algoritmo de resolução (Robinson, 1965)

Lógica de Predicados

• Estende a lógica proposicional com variáveis, predicados e quantificadores
• Um predicado expressa uma propriedade ou relação: \(\text{Febre}(x)\), \(\text{Alergia}(x, y)\)
• Quantificador universal \(\forall\): “para todo”
  • \(\forall x \; [\text{Diabético}(x) \rightarrow \text{MonitorarGlicemia}(x)]\)
• Quantificador existencial \(\exists\): “existe ao menos um”
  • \(\exists x \; [\text{Paciente}(x) \wedge \text{Internado}(x) \wedge \text{Febre}(x)]\)

Inferência: Modus Ponens e Modus Tollens

Sistemas Especialistas: Arquitetura

Fatores de Certeza (Certainty Factors)

• A lógica clássica é binária, mas na clínica as evidências têm graus de confiança
• Shortliffe & Buchanan (MYCIN, 1975) introduziram os fatores de certeza (CF)
• CF \(\in [-1, 1]\): \(-1\) = certamente falso, \(0\) = neutro, \(+1\) = certamente verdadeiro
• Combinação de evidências:
  • Se CF(\(p\)) = 0,7 e CF(\(q\)) = 0,6, então CF(\(p \wedge q\)) = min(0,7; 0,6) = 0,6
  • CF(\(p \vee q\)) = max(0,7; 0,6) = 0,7

Exemplo em R: Verificação de Regras Lógicas

# Fatos do paciente (V/F)
febre     <- TRUE   # temperatura > 38°C
tosse     <- TRUE   # tosse seca
mialgia   <- FALSE  # dor muscular
dispneia  <- FALSE  # falta de ar

# Regras
gripal     <- febre & tosse & mialgia
alerta_uci <- febre & dispneia   # UTI: Unidade de Terapia Intensiva
isolamento <- febre & (tosse | dispneia)

# Resultados
cat("=== Triagem por Regras Lógicas ===\n")

=== Triagem por Regras Lógicas ===

cat(sprintf("Síndrome Gripal:    %s\n", ifelse(gripal, "POSITIVO", "negativo")))

Síndrome Gripal:    negativo

cat(sprintf("Alerta UTI:         %s\n", ifelse(alerta_uci, "POSITIVO", "negativo")))

Alerta UTI:         negativo

cat(sprintf("Indicar Isolamento: %s\n", ifelse(isolamento, "POSITIVO", "negativo")))

Indicar Isolamento: POSITIVO

Limitações da Lógica Clássica em Saúde

• Tudo é V ou F — não há meio-termo
• “Febre alta” é verdadeiro ou falso? Depende do limiar — 37,9°C não é febre, mas 38,0°C é?
• Não modela gradações linguísticas: “dor leve”, “pressão levemente elevada”
• Regras são rígidas: uma condição fora do limiar invalida toda a regra
• Não lida bem com dados ruidosos ou imprecisos — comuns em ambientes clínicos

Exercício 1 — Bloco A

p <- c(TRUE, TRUE, FALSE, FALSE)
q <- c(TRUE, FALSE, TRUE, FALSE)

resultado <- !p | (p & q) | (!p)
# Equivalente a: ¬p ∨ (p → q) = ¬p ∨ (¬p ∨ q) = ¬p ∨ q
resultado_simples <- !p | (!p | q)

data.frame(
  p = p, q = q,
  `neg_p` = !p,
  `p→q` = !p | q,
  `neg_p ∨ (p→q)` = !p | (!p | q),
  check.names = FALSE
)

      p     q neg_p   p→q neg_p ∨ (p→q)
1  TRUE  TRUE FALSE  TRUE          TRUE
2  TRUE FALSE FALSE FALSE         FALSE
3 FALSE  TRUE  TRUE  TRUE          TRUE
4 FALSE FALSE  TRUE  TRUE          TRUE

Outras Lógicas

• Lógica Modal: adiciona os operadores de possibilidade (\(\Diamond p\) — “é possível que \(p\)”) e necessidade (\(\Box p\) — “é necessariamente verdade que \(p\)”). Usada implicitamente quando listamos diagnósticos diferenciais (“é possível que seja pneumonia”) ou definimos protocolos obrigatórios (“necessariamente isolar”).

• Lógica Temporal: adiciona operadores para raciocinar sobre sequência e duração de eventos (\(p \mathcal{U} q\) — “\(p\) até que \(q\)”). Base dos sistemas de alertas com janela de tempo em UTI (Unidade de Terapia Intensiva): “se SpO₂ (saturação periférica de oxigênio) < 90% por mais de 30 segundos, acionar alarme”.

A Motivação: Imprecisão na Linguagem Médica

• “O paciente está com febre alta” — o que é alto? Acima de 38? De 39? De 40?
• “Pressão elevada” — 135 mmHg é elevada? E 139? E 141?
• “Dor moderada” — como quantificar rigorosamente?
• “Idoso” — 60 anos é idoso? 65? 70?
• Forçar limiares rígidos cria saltos abruptos clinicamente injustificáveis

Conjuntos Crisp vs. Conjuntos Fuzzy

Definição Formal de Conjunto Fuzzy

• Um conjunto fuzzy \(A\) num universo \(U\) é uma função: \[A: U \rightarrow [0, 1]\]
• \(A(x) = \mu_A(x)\) é o grau de pertinência de \(x\) em \(A\)
• \(\mu_A(x) = 0\): \(x\) definitivamente não pertence a \(A\)
• \(\mu_A(x) = 1\): \(x\) definitivamente pertence a \(A\)
• \(0 < \mu_A(x) < 1\): \(x\) pertence parcialmente a \(A\)
• Conjuntos crisp são casos especiais: \(\mu_A(x) \in \{0, 1\}\)

Funções de Pertinência

library(ggplot2)
tri_mf <- function(x,a,b,c) pmax(0,pmin((x-a)/(b-a),(c-x)/(c-b)))
x <- seq(35,42,by=0.05)
df <- rbind(
  data.frame(x=x,mu=tri_mf(x,36.0,36.8,37.5),cat="Normal"),
  data.frame(x=x,mu=tri_mf(x,37.0,38.0,39.0),cat="Subfebril"),
  data.frame(x=x,mu=tri_mf(x,38.0,39.0,40.5),cat="Febre Mod."),
  data.frame(x=x,mu=tri_mf(x,39.5,41.0,42.0),cat="Febre Alta"))
ggplot(df,aes(x=x,y=mu,color=cat))+geom_line(linewidth=1.1)+
  scale_color_manual(values=c("#7ecff7","#a8f77e","#f7c87e","#f07050"))+
  labs(x="Temperatura (°C)",y="μ(x)",color="")+
  theme_minimal(base_size=11)+theme(legend.position="bottom")

library(ggplot2)
x <- seq(100,180,by=0.5)
df <- rbind(
  data.frame(x=x,mu=pmax(0,pmin((x-120)/10,1,(175-x)/5)),
             tipo="Trapezoidal — Normal/Limítrofe"),
  data.frame(x=x,mu=1/(1+exp(-0.15*(x-140))),
             tipo="Sigmoide — Hipertensão"))
ggplot(df,aes(x=x,y=mu,color=tipo))+geom_line(linewidth=1.1)+
  scale_color_manual(values=c("#7ecff7","#f07050"))+
  geom_vline(xintercept=140,color="#aaa",linetype="dashed")+
  annotate("text",x=140,y=0.6,label="140 mmHg",
           color="#aaa",hjust=-0.1,size=3)+
  labs(x="PAS (mmHg)",y="μ(x)",color="")+
  theme_minimal(base_size=11)+theme(legend.position="bottom")

\(\alpha\)-Cortes: Conectando Fuzzy e Crisp

• Um \(\alpha\)-corte de um conjunto fuzzy \(A\) é o conjunto crisp de todos os elementos com pertinência \(\geq \alpha\):

\[A_\alpha = \{x \in U : \mu_A(x) \geq \alpha\}\]

• Para \(\alpha = 1\): obtemos o núcleo — os elementos que pertencem completamente
• Para \(\alpha \to 0\): obtemos o suporte — todos os elementos com pertinência positiva
• α-cortes permitem converter conclusões fuzzy em decisões binárias quando necessário

Operações em Conjuntos Fuzzy

Dadas duas funções de pertinência \(A\) e \(B\) sobre o mesmo universo \(U\):

T-normas e T-conormas

• O mínimo e o máximo são as operações padrão, mas não as únicas
• T-norma (AND generalizado): qualquer função \(T: [0,1]^2 \to [0,1]\) satisfazendo condições de comutatividade, associatividade, monotonicidade e \(T(x,1)=x\)
• T-conorma (OR generalizado): dual da t-norma

Visualizando Operações Fuzzy

library(ggplot2)

# Para visualização, usamos um paciente na zona de transição
# temp=38.2°C: rampa de febre (37.5→38.5), mf = (38.2-37.5)/1 = 0.70
# PAS=136mmHg: rampa de hipertensão (130→140),  mh = (136-130)/10 = 0.60
t_val <- 38.2; p_val <- 136
mf <- pmax(0, pmin((t_val - 37.5) / 1, 1))
mh <- pmax(0, pmin((p_val - 130) / 10, 1))

df_ops <- data.frame(
  Operacao = c("μ(Febre Alta)", "μ(Hipertensão)",
               "E (min)", "OU (max)", "Sem Febre (1-μ)"),
  Valor = c(mf, mh, min(mf, mh), max(mf, mh), 1 - mf)
)

ggplot(df_ops, aes(x = Operacao, y = Valor, fill = Operacao)) +
  geom_col(width = 0.6) +
  scale_fill_manual(values = c("#f07050","#7ecff7","#f7c87e","#a8f77e","#c87ef7")) +
  scale_y_continuous(limits = c(0, 1)) +
  geom_text(aes(label = round(Valor, 2)), vjust = -0.4, size = 4.5) +
  labs(title = sprintf("Operações Fuzzy — Paciente: temp=%.1f°C, PAS=%.0f mmHg",
                       t_val, p_val),
       x = "", y = "Grau de pertinência") +
  theme_minimal(base_size = 13) +
  theme(legend.position = "none")

Regras Fuzzy: Estrutura

• Regras da forma: SE <antecedente fuzzy> ENTÃO <consequente fuzzy>
• Antecedentes e consequentes são proposições fuzzy — não V/F, mas com grau
• Exemplo de base de regras para triagem de dor:

Etapa 1: Fuzzificação

• Converter o valor nítido de entrada em graus de pertinência para cada conjunto fuzzy
• Exemplo: temperatura = 39,2°C

temp_val <- 39.2

# Funções de pertinência para temperatura
tri_mf  <- function(x, a, b, c) pmax(0, pmin((x-a)/(b-a), (c-x)/(c-b), 1))
ramp_mf <- function(x, a, b)    pmax(0, pmin((x-a)/(b-a), 1))

mu_normal    <- tri_mf(temp_val,  36.0, 36.8, 37.4)
mu_subfebril <- tri_mf(temp_val,  37.0, 37.5, 38.5)
mu_febre_mod <- tri_mf(temp_val,  38.0, 38.7, 40.0)  # pico em 38.7
mu_febre_alt <- ramp_mf(temp_val, 39.0, 39.5)        # plato a partir de 39.5

cat(sprintf("Temperatura: %.1f°C\n\n", temp_val))

Temperatura: 39.2°C

cat(sprintf("μ(Normal):       %.3f\n", mu_normal))

μ(Normal):       0.000

cat(sprintf("μ(Subfebril):    %.3f\n", mu_subfebril))

μ(Subfebril):    0.000

cat(sprintf("μ(Febre Mod.):   %.3f\n", mu_febre_mod))

μ(Febre Mod.):   0.615

cat(sprintf("μ(Febre Alta):   %.3f\n", mu_febre_alt))

μ(Febre Alta):   0.400

Etapa 2: Sistema de Inferência Mamdani

• Método mais intuitivo e amplamente usado em aplicações clínicas (Mamdani & Assilian, 1975)
• Para cada regra: o grau de ativação é determinado pela t-norma (mín) dos antecedentes
• O consequente é truncado na altura do grau de ativação

Etapa 3: Agregação

• Combinar os consequentes (já truncados) de todas as regras ativas
• Operação padrão: máximo ponto a ponto das funções de saída truncadas
• Resulta numa função fuzzy de saída que representa a conclusão combinada do sistema

library(ggplot2)

urgencia <- seq(0, 10, by = 0.05)

# Funções de pertinência da saída
mu_mod  <- pmax(0, pmin((urgencia - 3)/2, (8 - urgencia)/2, 1))
mu_alta <- pmax(0, pmin((urgencia - 6)/1.5, 1))

# Graus de ativação das regras
a_R1 <- 0.25; a_R2 <- 0.40

# Consequentes truncados
tronc_mod  <- pmin(mu_mod,  a_R1)
tronc_alta <- pmin(mu_alta, a_R2)

# Agregação: máximo ponto a ponto
agregado <- pmax(tronc_mod, tronc_alta)

# Original (sem truncamento): referência visual
original <- pmax(mu_mod, mu_alta)

df <- data.frame(
  x    = rep(urgencia, 3),
  mu   = c(tronc_mod, tronc_alta, agregado),#, original),
  tipo = rep(c("R1 truncada (mod, \u03b1=0.25)",
               "R2 truncada (alta, \u03b1=0.40)",
               "Agregado (m\u00e1ximo)"),#,
               #"Original (sem truncamento)"),
             each = length(urgencia))
)

ggplot(df, aes(x = x, y = mu, color = tipo, linetype = tipo)) +
  geom_line(linewidth = 1.1) +
  scale_color_manual(values = c(
  "Agregado (m\u00e1ximo)"            = "#a8f77e",
  #"Original (sem truncamento)"        = "#c87ef7",
  "R1 truncada (mod, \u03b1=0.25)"   = "#7ecff7",
  "R2 truncada (alta, \u03b1=0.40)"  = "#f07050"
)) +
scale_linetype_manual(values = c(
  "Agregado (m\u00e1ximo)"            = "solid",
  #"Original (sem truncamento)"        = "dashed",
  "R1 truncada (mod, \u03b1=0.25)"   = "dashed",
  "R2 truncada (alta, \u03b1=0.40)"  = "dashed"
)) +
  labs(title = "Agregação Mamdani — Função de Saída Combinada",
       x = "Urgência (0–10)", y = "Grau de pertinência",
       color = "", linetype = "") +
  theme_minimal(base_size = 13) +
  theme(legend.position = "bottom")

Etapa 4: Defuzzificação

• Converter a função fuzzy de saída em um único valor nítido
• Centroide (Centro de Gravidade) — método mais comum:

\[x^* = \frac{\int x \cdot \mu_{\text{agg}}(x) \, dx}{\int \mu_{\text{agg}}(x) \, dx} \approx \frac{\sum_i x_i \cdot \mu_{\text{agg}}(x_i)}{\sum_i \mu_{\text{agg}}(x_i)}\]

urgencia <- seq(0, 10, by = 0.05)
mu_mod   <- pmax(0, pmin((urgencia - 3)/2, (8 - urgencia)/2))
mu_alta  <- pmax(0, pmin((urgencia - 6)/1.5, 1))
tronc_mod  <- pmin(mu_mod,  0.25)
tronc_alta <- pmin(mu_alta, 0.40)
agregado   <- pmax(tronc_mod, tronc_alta)

# Centroide
centroide <- sum(urgencia * agregado) / sum(agregado)
cat(sprintf("Valor defuzzificado (centroide): %.2f / 10\n", centroide))

Valor defuzzificado (centroide): 7.02 / 10

cat(sprintf("Interpretação: urgência %.0f%%\n", centroide * 10))

Interpretação: urgência 70%

Funções de Pertinência na Prática Clínica

library(ggplot2)

# Escala de dor (0-10) com 4 categorias linguísticas
dor <- seq(0, 10, by = 0.05)

mu_leve    <- pmax(0, pmin(1, (3 - dor)/2))
mu_mod     <- pmax(0, pmin((dor - 1)/2, (6 - dor)/2))
mu_intensa <- pmax(0, pmin((dor - 4)/2, (9 - dor)/2))
mu_insup   <- pmax(0, pmin((dor - 7)/2, 1))

df <- data.frame(
  x   = rep(dor, 4),
  mu  = c(mu_leve, mu_mod, mu_intensa, mu_insup),
  cat = rep(c("Leve", "Moderada", "Intensa", "Insuportável"), each = length(dor))
)
df$cat <- factor(df$cat, levels = c("Leve","Moderada","Intensa","Insuportável"))

ggplot(df, aes(x = x, y = mu, color = cat)) +
  geom_line(linewidth = 1.2) +
  scale_color_manual(values = c("#a8f77e","#7ecff7","#f7c87e","#f07050")) +
  labs(title = "Funções de Pertinência — Escala de Dor (0–10)",
       x = "Intensidade da dor (EVA — Escala Visual Analógica)", y = "Grau de pertinência μ(x)",
       color = "Categoria") +
  theme_minimal(base_size = 13)

Aplicação: Triagem de Urgência Clínica

• Um sistema de triagem fuzzy avalia múltiplas variáveis linguísticas simultaneamente
• Variáveis de entrada: temperatura, frequência cardíaca, SpO₂, escala de dor
• Base de regras: definida por especialistas em triagem (protocolo Manchester fuzzy)
• Saída: escore de urgência contínuo → classificação em cores (verde/amarelo/laranja/vermelho)

Exercícios — Bloco C

Ex. 1 — Fuzzificação: SpO₂ = 93%

spo2 <- 91
mu_normal    <- pmax(0, pmin((spo2 - 94)/2, 1))
mu_hip_leve  <- pmax(0, pmin((spo2 - 89)/2, (96 - spo2)/2, 1))
mu_hip_grave <- pmax(0, pmin((92 - spo2)/2, 1))

cat(sprintf("μ(Normal):    %.3f\n", mu_normal))

μ(Normal):    0.000

cat(sprintf("μ(Hip. Leve): %.3f\n", mu_hip_leve))

μ(Hip. Leve): 1.000

cat(sprintf("μ(Hip. Grave):%.3f\n", mu_hip_grave))

μ(Hip. Grave):0.500

Exercícios — Bloco C

Paciente predominantemente em hipoxemia leve, com componente crescente de grave.

Ex. 2 — Sistema Mamdani: temp = 39°C, SpO₂ = 93%

t <- 39.0; s <- 91.0
mu_tf <- pmax(0, pmin((t-37.5)/1, (40.5-t)/1, 1))
mu_ta <- pmax(0, pmin((t-39.0)/0.8, 1))
mu_sl <- pmax(0, pmin((s-89)/2, (96-s)/2, 1))
mu_sg <- pmax(0, pmin((92-s)/2, 1))

R <- c(min(mu_tf, mu_sl), min(mu_ta, mu_sl), min(mu_tf, mu_sg))
centros <- c(4.0, 7.0, 9.5)
escore  <- sum(centros * R) / sum(R)

cat(sprintf("Escore: %.2f/10 → %s\n", escore,
    ifelse(escore < 5, "Amarelo",
    ifelse(escore < 7, "Laranja", "Vermelho"))))

Escore: 5.83/10 → Laranja

Lógica Fuzzy em Aplicações Reais de Saúde

• Dosagem de medicamentos: sistemas fuzzy para calcular doses de insulina, heparina ou sedação em UTI com base em múltiplos parâmetros fisiológicos
• Classificação de imagens médicas: sistemas de auxílio ao diagnóstico por imagem com saída de grau de suspeição (não “positivo/negativo”)
• Monitoramento contínuo: detecção precoce de deterioração clínica combinando múltiplos sinais com graus de alarme graduais
• Protocolos de triagem: versões fuzzy dos protocolos de Manchester e ESI, reduzindo paradoxos de limiar

Exercício 4 — Integrador: Lógica Clássica vs. Fuzzy

# Dados do paciente
idade <- 68; fe <- 36; intern <- 2

# Sistema A (lógica clássica — binário)
risco_a <- (idade > 70) & (fe < 35) & (intern > 2)
cat(sprintf("Sistema A (clássico): %s\n\n",
            ifelse(risco_a, "RISCO ALTO", "risco baixo")))

Sistema A (clássico): risco baixo

# Sistema B (lógica fuzzy)
mu_idoso <- pmax(0, pmin((idade - 60)/15, 1))
mu_fe    <- pmax(0, pmin((40 - fe)/10, 1))
mu_int   <- pmax(0, pmin((intern - 1)/3, 1))

grau_min  <- min(mu_idoso, mu_fe, mu_int)
grau_prod <- mu_idoso * mu_fe * mu_int

classificar <- function(g)
  ifelse(g < 0.25, "baixo",
  ifelse(g < 0.50, "moderado",
  ifelse(g < 0.75, "alto", "muito alto")))

cat("Sistema B (fuzzy):\n")

Sistema B (fuzzy):

cat(sprintf("  μ(idoso):              %.3f\n", mu_idoso))

  μ(idoso):              0.533

cat(sprintf("  μ(FE muito reduzida):  %.3f\n", mu_fe))

  μ(FE muito reduzida):  0.400

cat(sprintf("  μ(múltiplas intern.):  %.3f\n", mu_int))

  μ(múltiplas intern.):  0.333

cat(sprintf("  Grau de risco (min):   %.3f → %s\n", grau_min,  classificar(grau_min)))

  Grau de risco (min):   0.333 → moderado

cat(sprintf("  Grau de risco (prod.): %.3f → %s\n", grau_prod, classificar(grau_prod)))

  Grau de risco (prod.): 0.071 → baixo

cat("\nConclusão: Sistema A detecta risco baixo; Sistema B indica risco moderado (min)\nou baixo (produto) — ambos capturam vulnerabilidade que o sistema clássico ignora.\n")

Conclusão: Sistema A detecta risco baixo; Sistema B indica risco moderado (min)
ou baixo (produto) — ambos capturam vulnerabilidade que o sistema clássico ignora.

Leitura Complementar para a Próxima Aula

• NGUYEN & WALKER (2019): Caps. 1–2 (conjuntos fuzzy e operações) e Cap. 13 (controle e modelagem fuzzy)
• KLIR & YUAN (1995): Cap. 1 (introdução) e Cap. 12 (aplicações em engenharia)
• Para a Aula 3: revisar probabilidade condicional e Teorema de Bayes (já visto na Aula 1); os slides de revisão ainda estarão disponíveis

Referências

Lógica Clássica e Sistemas Especialistas

• GENESERETH, M.; NILSSON, N. Logical Foundations of Artificial Intelligence. Morgan Kaufmann, 1987.
• SHORTLIFFE, E. H.; BUCHANAN, B. G. A model of inexact reasoning in medicine. Mathematical Biosciences, v. 23, p. 351–379, 1975. (Artigo original do MYCIN)

Lógica Fuzzy

• ZADEH, L. A. Fuzzy sets. Information and Control, v. 8, n. 3, p. 338–353, 1965. (Artigo original)
• KLIR, G. J.; YUAN, B. Fuzzy Sets and Fuzzy Logic: Theory and Applications. Prentice Hall, 1995.
• NGUYEN, H. T.; WALKER, E. A. A First Course in Fuzzy Logic. 4. ed. CRC Press, 2019.
• LOOTSMA, F. A. Fuzzy Logic for Planning and Decision Making. Springer, 1997.
• MAMDANI, E. H.; ASSILIAN, S. An experiment in linguistic synthesis with a fuzzy logic controller. International Journal of Man-Machine Studies, v. 7, p. 1–13, 1975.