# Resolução da Prova 1 - Programação Estatística

## Exercício 1

### (a) Cálculo de $ F^{-1}(u) $

Dada a função de distribuição acumulada:
$$
F(x) = \frac{1}{1 + (\beta/x)^\alpha}
$$

Queremos encontrar $ x = F^{-1}(u) $:

$$
u = \frac{1}{1 + (\beta/x)^\alpha}
$$
$$
1 + (\beta/x)^\alpha = \frac{1}{u}
$$
$$
(\beta/x)^\alpha = \frac{1}{u} - 1 = \frac{1 - u}{u}
$$
$$
\beta/x = \left( \frac{1 - u}{u} \right)^{1/\alpha}
$$
$$
x = \beta \left( \frac{u}{1 - u} \right)^{1/\alpha}
$$

Portanto:
$$
F^{-1}(u) = \beta \left( \frac{u}{1 - u} \right)^{1/\alpha}
$$

### (b) Pseudo-código para simular n amostras

ALGORITMO: Gerar n amostras da Log-Logística(α,β)
ENTRADA: n, α, β
SAÍDA: Amostras x₁, x₂, ..., xₙ

PARA i DE 1 ATÉ n FAÇA:
    1. Gerar u ~ Uniforme(0,1)
    2. Calcular xᵢ = β × (u/(1-u))^(1/α)
    3. Armazenar xᵢ

RETORNAR {x₁, x₂, ..., xₙ}

### (c) Implementação em Python

import numpy as np

def rloglogistica(n, alpha, beta):
    """
    Gera n amostras de uma distribuição Log-Logística(α,β)
    """
    u = np.random.uniform(0, 1, n)
    x = beta * (u / (1 - u)) ** (1/alpha)
    return x

# Exemplo de uso:
# amostras = rloglogistica(1000, 2, 1)

## Exercício 2

### (a) Cálculo de $P(X = m)$

$$
P(X = m) = P(Y = m | Y > 0) = \frac{P(Y = m)}{P(Y > 0)} =
\frac{P(Y = m)}{1-P(Y = 0)} = \frac{e^{-\lambda} \lambda^m / m!}{1 - e^{-\lambda}}
$$
para $m = 1, 2, 3, \ldots$

### (b) Demonstração da função de distribuição

Para $m \in \{1, 2, \ldots\}$:

$$
F_X(m) = P(X \leq m) = P(Y \leq m | Y > 0) = \frac{P(0 < Y \leq m)}{P(Y > 0)} = \frac{F_Y(m) - P(Y = 0)}{1 - P(Y = 0)}.
$$
Logo,
$$
F_X(m) = \frac{F_Y(m) - e^{-\lambda}}{1 - e^{-\lambda}}.
$$

Para $m = 0$:
$$
F_X(0) = P(X \leq 0) = 0 \quad \text{(pois X > 0 sempre)}
$$

### (c) Descrição do algoritmo por inversão

ALGORITMO: Gerar X ~ Poisson truncada em 0
ENTRADA: λ
SAÍDA: X

1. Gerar U ~ Uniforme(0,1)
2. Calcular u* = e^{-λ} + (1 - e^{-λ}) × U
3. Encontrar X = min{m ≥ 1: F_Y(m) ≥ u*}
   Onde F_Y é a CDF da Poisson(λ)

RETORNAR X

### (d) Implementação em Python

import numpy as np
from scipy.stats import poisson

def rpoisson_truncada(lambda_param):
    """
    Gera uma observação da Poisson truncada em 0
    """
    U = np.random.uniform(0, 1)
    u_star = np.exp(-lambda_param) + (1 - np.exp(-lambda_param)) * U
    
    m = 1
    while poisson.cdf(m, lambda_param) < u_star:
        m += 1
    
    return m

# Exemplo de uso:
# amostra = rpoisson_truncada(2.5)

## Exercício 3

### (a) Cálculo da constante c

A densidade Beta é:
$$
f(x) = \frac{1}{B(\alpha, \beta)} x^{\alpha-1} (1-x)^{\beta-1}, \quad 0 < x < 1
$$

Para encontrar o máximo, derivamos o logaritmo:
$$
\ln f(x) = -\ln B(\alpha, \beta) + (\alpha-1)\ln x + (\beta-1)\ln(1-x)
$$
$$
\frac{d}{dx} \ln f(x) = \frac{\alpha-1}{x} - \frac{\beta-1}{1-x}
$$

Igualando a zero:
$$
\frac{\alpha-1}{x} = \frac{\beta-1}{1-x} \Rightarrow x = \frac{\alpha-1}{\alpha+\beta-2}
$$

Substituindo na densidade:
$$
c = \max_{x \in (0,1)} f(x) = \frac{1}{B(\alpha, \beta)} \left( \frac{\alpha-1}{\alpha+\beta-2} \right)^{\alpha-1} \left( \frac{\beta-1}{\alpha+\beta-2} \right)^{\beta-1}
$$
$$
c = \frac{(\alpha-1)^{\alpha-1}(\beta-1)^{\beta-1}}{B(\alpha, \beta)(\alpha+\beta-2)^{\alpha+\beta-2}}
$$

### (b) Algoritmo de rejeição e implementação

ALGORITMO: Gerar Beta(α,β) por rejeição
ENTRADA: α, β
SAÍDA: X ~ Beta(α,β)

1. Calcular c = (α-1)^{α-1}(β-1)^{β-1} / [B(α,β)(α+β-2)^{α+β-2}]
2. REPETIR:
    2.1 Gerar X ~ Uniforme(0,1)
    2.2 Gerar U ~ Uniforme(0,1)
    2.3 Calcular razão = f(X)/(c × g(X)) = f(X)/c
    2.4 SE U ≤ razão ENTÃO ACEITAR X
   ATÉ QUE X seja aceito

RETORNAR X

Implementação em Python:

import numpy as np
from scipy.special import beta as beta_func

def rbeta_rejeicao(alpha, beta):
    """
    Gera uma amostra de Beta(α,β) usando rejeição
    """
    # Constante c
    if alpha > 1 and beta > 1:
        numerador = (alpha-1)**(alpha-1) * (beta-1)**(beta-1)
        denominador = beta_func(alpha, beta) * (alpha+beta-2)**(alpha+beta-2)
        c = numerador / denominador
    else:
        # Para α ≤ 1 ou β ≤ 1, usar valor conservador
        c = 2.0
    
    while True:
        X = np.random.uniform(0, 1)
        U = np.random.uniform(0, 1)
        
        f_X = (X**(alpha-1) * (1-X)**(beta-1)) / beta_func(alpha, beta)
        razao = f_X / c
        
        if U <= razao:
            return X

# Exemplo de uso:
# amostra = rbeta_rejeicao(2, 3)

## Exercício 4

### (a) Constante c e simplificação do algoritmo

Temos:
- $X$: Poisson truncada em 0
- $Y$: Poisson(λ) completa

A densidade de X é:
$$
f_X(m) = \frac{e^{-\lambda} \lambda^m / m!}{1 - e^{-\lambda}}, \quad m = 1, 2, \ldots
$$

A densidade de Y é:
$$
f_Y(m) = e^{-\lambda} \lambda^m / m!, \quad m = 0, 1, 2, \ldots
$$

A constante c deve satisfazer:
$$
f_X(m) \leq c f_Y(m) \quad \text{para todo } m
$$

Calculando a razão:
$$
\frac{f_X(m)}{f_Y(m)} = \frac{1}{1 - e^{-\lambda}} \quad \text{para } m \geq 1
$$
e
$$
\frac{f_X(0)}{f_Y(0)} = 0
$$

Portanto:
$$
c = \frac{1}{1 - e^{-\lambda}} = \frac{1}{P(Y > 0)}
$$

Assim, o algoritmo de rejeição se reduz a:
- Gerar Y ~ Poisson(λ)
- Aceitar se Y > 0, caso contrário rejeitar

### (b) Taxa de aceitação e eficiência

A taxa de aceitação é:
$$
\text{Taxa} = \frac{1}{c} = 1 - e^{-\lambda} = P(Y > 0)
$$

A eficiência do algoritmo:
- Quando λ → 0: Taxa ≈ λ → 0 (ineficiente)
- Quando λ → ∞: Taxa → 1 (eficiente)

**Interpretação**: O algoritmo é mais eficiente para valores grandes de λ, pois a probabilidade de gerar Y = 0 diminui. Para λ pequeno, muitas amostras são rejeitadas, tornando o algoritmo ineficiente.