Variáveis Aleatórias Discretas - Sistemas de TI/Engenharia de Software

.title[
# Variáveis Aleatórias Discretas - Sistemas de TI/Engenharia de Software
]
.subtitle[
## Um Problema · Uma Fila · Sete Conceitos
]
.author[
### Prof. Hidelbrando Ferreira Rodrigues
]
.institute[
### Universidade Federal do Amazonas — UFAM
]
.date[
### 14 de maio de 2026
]

---

.inverse {
  background-color: #1a3a5c;
  color: #f0f0f0;
  text-shadow: none;
}
.inverse h1, .inverse h2, .inverse h3 { color: #f0f0f0; }

.pull-left  { float: left;  width: 48%; }
.pull-right { float: right; width: 48%; }
.center { text-align: center; }
.small  { font-size: 0.82em; }

/* caixas temáticas */
.conceito {
  background: #eaf4fb;
  border-left: 6px solid #2980b9;
  padding: 13px 16px;
  margin: 10px 0;
  border-radius: 4px;
}
.pergunta {
  background: #fef9e7;
  border-left: 6px solid #e67e22;
  padding: 13px 16px;
  margin: 10px 0;
  border-radius: 4px;
}
.solucao {
  background: #eafaf1;
  border-left: 6px solid #27ae60;
  padding: 13px 16px;
  margin: 10px 0;
  border-radius: 4px;
}
.alerta {
  background: #fdedec;
  border-left: 6px solid #c0392b;
  padding: 13px 16px;
  margin: 10px 0;
  border-radius: 4px;
}
.pausa {
  text-align: center;
  color: #e67e22;
  font-weight: bold;
  font-size: 1.05em;
  margin-top: 14px;
}
</style>

---

# Variáveis Aleatórias Discretas - Sistemas de TI/Engenharia de Software

## Um Problema · Uma Fila · Sete Conceitos

### Prof. Hidelbrando Ferreira Rodrigues  
### Universidade Federal do Amazonas — UFAM  
### 14 de maio de 2026

---

## O Cenário: SLA de uma API

Uma startup mantém uma **API pública** usada por vários clientes.  
O contrato prevê:

- SLA: **no máximo 2% de requisições com erro** por hora;
- Monitoramento minuto a minuto: contagem de **requisições** e **erros**.

Dados típicos em um minuto:

- média de 12 requisições/min;
- média de 1.5 erros/min;
- cada requisição individual tem probabilidade de sucesso aproximada de 0.97.

O time quer responder:

- “Quantos erros **esperar** por minuto?”
- “Qual a probabilidade de **estourar o SLA** numa janela curta?”
- “Quando os dados de log gritam que há um problema?”

---

# Bloco 1  
## Da contagem ao modelo: variável aleatória

---

## Conceito: Variável Aleatória Discreta

.conceito[
Uma **variável aleatória discreta** é uma função que associa a cada resultado do experimento um **número**, assumindo apenas **valores isolados** (contáveis).

Exemplos em TI:

- `$X$` = número de requisições com erro em 1 minuto;
- `$Y$` = número de usuários logados no sistema às 10h;
- `$Z$` = número de chamados abertos no suporte hoje.
]

A chave: saímos da descrição “verbal” do evento e passamos a uma **função que conta / mede** resultados.

---

## Pergunta 1

1. Defina, em linguagem natural, uma **variável aleatória discreta** associada ao cenário da API.
2. Escreva a mesma definição em notação matemática: `$X = \dots$`
3. Qual é o **conjunto de valores possíveis** de `$X$`?
]

---

## Resposta 1

- Em português:  
  ** `$X$` = número de requisições com erro em um minuto.**

- Em notação matemática:  
  `$$X: \Omega \rightarrow \{0,1,2,\dots\} \qquad X(\omega) = \text{nº de erros no minuto observado}$$`

- Conjunto de valores possíveis:  
  `$$\mathcal{X} = \{0,1,2,\dots, n\}$$`  
  onde `$n$` é o total de requisições na janela (ou `$\mathbb{N}_0$` se não fixarmos `$n$`).
]

---

# Bloco 2  
## Distribuição de Probabilidades

---

## Conceito: Distribuição de Probabilidade

`$$p(x) = P(X = x), \quad x \in \mathcal{X}$$`

Propriedades:

- `$p(x) \ge 0$` para todo `$x$`;
- `$\displaystyle\sum_{x \in \mathcal{X}} p(x) = 1$`.
]

No cenário da API: precisamos modelar **$P(X = x)$**, isto é, a probabilidade de ter exatamente `$x$` erros num minuto.

---

## Duas Situações Clássicas

.conceito[
1. **Número de erros em `$n$` requisições** (janela pequena, `$n$` conhecido):  
   Modelo natural: **Binomial**.

2. **Número de erros em 1 minuto** (chegadas raras, em fluxo contínuo):  
   Modelo natural: **Poisson**.
]

Hoje vamos trabalhar com os dois, mas tudo em torno do **mesmo problema da API**.

---

# Bloco 3  
## Distribuição Binomial: número de erros em n requisições

---

## Conceito: Binomial `$B(n,p)$`

.conceito[
Uma variável aleatória `$X$` tem distribuição **Binomial** `$B(n,p)$` se modela o número de “sucessos” em `$n$` ensaios de Bernoulli independentes, cada um com probabilidade `$p$` de sucesso:

`$$P(X = k) = \binom{n}{k} p^k (1-p)^{n-k}, \quad k = 0,1,\dots,n.$$`

- `$n$` = número de tentativas;
- `$p$` = probabilidade de sucesso (no nosso caso, podemos chamar de “erro”).
]

No cenário: **cada requisição** é um ensaio, “sucesso” = “erro de requisição”.

---

## Pergunta 2

Considere uma janela de `$n = 50$` requisições, com probabilidade de erro `$p = 0.03$`.

1. Modele `$X$` = número de erros em 50 requisições usando uma binomial.
2. Escreva `$P(X = k)$`.
3. Qual o valor de `$p$`: probabilidade de erro ou de sucesso?
]

---

## Resposta 2

- Função de probabilidade:
  `$$P(X = k) = \binom{50}{k} (0.03)^k (1-0.03)^{50 - k}$$`

- Aqui, **“sucesso” = “erro”**. Logo, `$p = P(\text{erro}) = 0.03$`.
]

---

## Visualizando a Binomial

.small[
Note a concentração da massa de probabilidade em torno de `$np$`.  
No nosso caso, $E(X) = np = 50 \times 0.03 \approx 1.5 erros por bloco.
]

---

## Pergunta 3

Considere que o SLA tolera até **2% de erros** por bloco de 50 requisições:  
`$2\%$` de 50 `$\approx$` 1 erros.

1. Qual o maior número de erros `$k_{\max}$` **ainda aceitável** na janela?
2. Calcule `$P(X \le k_{\max})$` e `$P(X > k_{\max})$`.
3. Interprete `$P(X > k_{\max})$` em termos de risco de violar o SLA.
]

---

## Resposta 3

- Probabilidades:
  `$$P(X \le 1) \approx 0.5553$$`
  `$$P(X > 1) = 1 - P(X \le 1) \approx 0.4447$$`

- Interpretação: em cada bloco de 50 requisições, há cerca de  
  **44.47% de chance de o SLA ser violado**.
]

---

# Bloco 4  
## Esperança, Variância e Tomada de Decisão

---

## Conceitos: Esperança e Variância (Binomial)

- **Esperança** (valor esperado):  
  `$$E(X) = np$$`

- **Variância**:  
  `$$\mathrm{Var}(X) = np(1-p)$$`

- **Desvio-padrão**:  
  `$$\sigma_X = \sqrt{np(1-p)}$$`
]

Em termos práticos:

- `$E(X)$` = **média esperada** de erros por bloco;
- `$\sigma_X$` mede a **dispersão**: o quão “variável” é o número de erros de bloco para bloco.

---

## Pergunta 4

1. Calcule `$E(X)$` e `$\mathrm{Var}(X)$`.
2. Compare `$E(X)$` com a tolerância do SLA.
3. Se o valor esperado já estiver **próximo** do limite do SLA, que decisão de engenharia você sugeriria?
]

---

## Resposta 4

.solucao[
- $E(X) = np = 50 \times 0.03 \approx 1.5 erros por bloco;
- `$\mathrm{Var}(X) \approx 1.455$`;  
  `$\sigma_X \approx 1.206$`.

Comparação com o SLA (até 1 erros):

- se `$E(X)$` for muito próximo de 1, a operação já está “no limite”;
- decisões de engenharia: reduzir `$p$` (corrigir bugs), aumentar capacidade, introduzir mecanismos de retry inteligentes, etc.
]

---

# Bloco 5  
## Distribuição de Poisson: erros por unidade de tempo

---

## Conceito: Poisson `$\mathrm{Po}(\lambda)$`

.conceito[
Uma variável aleatória `$Y$` tem distribuição **Poisson** com parâmetro `$\lambda > 0$` se:

`$$P(Y = k) = \frac{e^{-\lambda} \lambda^k}{k!}, \quad k = 0,1,2,\dots$$`

É um modelo natural para o **número de ocorrências de eventos raros** em um intervalo de tempo ou espaço, sob:

- ocorrências independentes;
- taxa média constante `$\lambda$`.
]

No cenário: **número de erros de requisição em 1 minuto** de operação.

---

## Ligando com a API

.conceito[
Suponha que o log histórico mostra que, em média, ocorrem  
`$\lambda = 1.5$` erros por minuto.

Modelamos:

`$$Y = \text{nº de erros em 1 minuto} \sim \mathrm{Poisson}(\lambda = 1.5).$$`
]

Isso captura diretamente a contagem por tempo, sem fixar `$n$` requisições.

---

## Visualizando a Poisson

---

## Pergunta 5

Para `$Y \sim \mathrm{Poisson}(1.5)$`:

1. Calcule `$P(Y = 0)$`: probabilidade de **zero erros** em 1 min.
2. Calcule `$P(Y = 1)$` e `$P(Y = 2)$`.
3. Qual a probabilidade de **no máximo 2 erros** em 1 min: `$P(Y \le 2)$`?
]

---

## Resposta 5

.solucao[
- `$P(Y = 0) \approx 0.2231$`  
- `$P(Y = 1) \approx 0.3347$`  
- `$P(Y = 2) \approx 0.251$`

`$$P(Y \le 2) = P(0) + P(1) + P(2) \approx 0.8088$$`

Interpretação: em um minuto, há cerca de **80.9%** de chance de termos **até 2 erros**.
]

---

## Pergunta 6

Chamemos de **minuto crítico** aquele em que o número de erros é **5 ou mais**: `$Y \ge 5$`.

1. Calcule `$P(Y \ge 5)$`.
2. Interprete esse valor: isso é raro o suficiente para acionar um alerta no monitoramento?
]

---

## Resposta 6

Ou seja, há aproximadamente **1.86%** de chance de um minuto ser “crítico”.

Se isso for considerado suficientemente raro, pode-se usar **“5 ou mais erros/min”** como gatilho para alertas automáticos.
]

---

# Bloco 6  
## Ligando Binomial e Poisson & Projeto de Monitoramento

---

## Binomial vs Poisson

- Se `$X_n \sim \text{Binomial}(n,p)$` com `$n$` grande e `$p$` pequeno, mantendo `$\lambda = np$` **fixo**, então:
  `$$X_n \xrightarrow{d} \mathrm{Poisson}(\lambda).$$`

Isto é, a Poisson pode ser vista como um **limite** da Binomial quando temos muitos ensaios independentes, cada um com pequena probabilidade de sucesso.
]

No cenário:

- muitos requests por minuto;
- cada um com baixa probabilidade de erro `$\Rightarrow$` Poisson é um modelo adequado para contagens por tempo.

---

## Pergunta 7

1. Calcule `$\lambda = np$`.
2. Compare a binomial `$B(n,p)$` com uma Poisson(`$\lambda$`) aproximada.
3. Em qual situação prática você preferiria a **Poisson** à Binomial para modelar erros?
]

---

## Resposta 7

2. A binomial `$B(50, 0.03)$` e a Poisson(`$1.5$`) terão distribuições de probabilidade **muito parecidas** para `$k$` não muito grande.

3. A Poisson é especialmente conveniente quando:
   - não faz sentido fixar `$n$` (fluxo contínuo de requisições);
   - queremos modelar a contagem por unidade de tempo (erros/min, erros/hora);
   - os cálculos binomiais se tornam pesados para `$n$` grande.
]

---

# Bloco 7  
## Síntese e gancho para inferência

---

## O Que Modelamos

| Conceito | Aplicação no problema da API |
|----------|------------------------------|
| Variável aleatória discreta | `$X$` = nº de erros em 50 requisições; `$Y$` = nº de erros/min |
| Distribuição de probabilidade | `$P(X = k)$`, `$P(Y = k)$` como base para o monitoramento |
| Binomial | Erros em um bloco de requisições, `$X \sim B(n,p)$` |
| Esperança e variância | `$E(X)=np$`, `$\mathrm{Var}(X)=np(1-p)$` `$\Rightarrow$` previsão de erros “típicos” |
| Poisson | Erros por minuto, `$Y \sim \mathrm{Poisson}(\lambda)$` |
| Probabilidades de SLA | `$P(X > k_{\max})$`: risco de violar o SLA em uma janela |
| Minuto crítico | `$P(Y \ge 5)$`: gatilho probabilístico para alertas |

---

## Para Pensar na Próxima Aula

> “Com base nos **logs dos últimos 30 dias**, conseguimos estimar se nossa taxa de erros **real** é maior que 2%?”

- Quais **parâmetros desconhecidos** aparecem nos modelos binomial e Poisson?
- Que tipo de **variáveis aleatórias** precisaremos considerar (amostras)?
- Como vamos passar de **modelos teóricos** para **estimativas com dados reais**?

Esse será o passo para **inferência estatística**: estimação e testes de hipóteses.
]

---

## Obrigado!

Prof. Hidelbrando Ferreira Rodrigues  
Universidade Federal do Amazonas — UFAM