Black-Scholes: Do Movimento Browniano às Opções • Curso prático

Black-Scholes: Do Movimento Browniano às Opções

Jornada completa pela precificação de opções. Começamos com o Movimento Browniano, evoluímos para o Movimento Browniano Geométrico aplicado a preços de ativos, simulamos trajetórias via Monte Carlo e chegamos à fórmula analítica de Black-Scholes. Cada grega explicada, cada premissa testada. Código executável no navegador.
Carregando ambiente…
Primeira execução baixa numpy, matplotlib e scipy. Depois é instantâneo.

1. A história que mudou Wall Street

1973. Fischer Black, Myron Scholes e Robert Merton publicam uma equação que transforma arte em ciência. Antes deles, precificar opções era intuição misturada com experiência de mesa de operações. Depois deles, nasce uma indústria trilionária de derivativos com base matemática sólida.

Mas a história começa décadas antes. Em 1827, o botânico escocês Robert Brown observa grãos de pólen flutuando na água. O movimento errático e imprevisível que ele documenta vira, um século depois, a base matemática para modelar incerteza em finanças. De pólen a opções, a conexão é o processo estocástico.

Nossa jornada: Movimento Browniano → Movimento Browniano Geométrico → Monte Carlo → Black-Scholes analítico → Gregas. Cada passo com código executável, gráficos e interpretação clara.

2. Movimento Browniano: A base estocástica

Um processo W(t) é Movimento Browniano se: W(0)=0, trajetórias contínuas, incrementos W(t)-W(s) seguem N(0,t-s) e são independentes. Em cada passo infinitesimal dt, o movimento segue dW = ε√dt onde ε ~ N(0,1).

Na prática, discretizamos o tempo e acumulamos choques aleatórios. O resultado visual: caminhos que flutuam sem direção definida, explorando todo o espaço ao longo do tempo.

Simulando trajetórias do Movimento Browniano
ok

import numpy as np import matplotlib.pyplot as plt def movimento_browniano(T=1, N=1000, num_paths=5): “”” Simula trajetórias de Movimento Browniano padrão T: horizonte de tempo N: número de passos num_paths: número de trajetórias “”” dt = T / N t = np.linspace(0, T, N+1) # Incrementos aleatórios independentes dW = np.random.normal(0, np.sqrt(dt), (num_paths, N)) # Trajetórias acumuladas (soma cumulativa) W = np.zeros((num_paths, N+1)) W[:, 1:] = np.cumsum(dW, axis=1) return t, W # Simula 8 trajetórias np.random.seed(42) t, W = movimento_browniano(T=1, N=1000, num_paths=8) print(“Propriedades observadas:”) print(f” Média final: {W[:, -1].mean():.4f} (esperado ≈ 0)”) print(f” Desvio padrão final: {W[:, -1].std():.4f} (esperado ≈ 1)”) print(f” Valor máximo observado: {W.max():.3f}”) print(f” Valor mínimo observado: {W.min():.3f}”) plt.figure(figsize=(7,4)) for i in range(W.shape[0]): plt.plot(t, W[i], alpha=0.7, linewidth=1.5) plt.axhline(0, color=’white’, linestyle=’–‘, alpha=0.3, linewidth=0.8) plt.xlabel(‘Tempo t’, fontsize=11) plt.ylabel(‘W(t)’, fontsize=11) plt.title(‘Trajetórias do Movimento Browniano’, fontsize=13) plt.grid(True, alpha=0.2) print(figb64())
(aguardando)

Interpretação: Cada trajetória é única, mas estatisticamente todas compartilham as mesmas propriedades. A média tende a zero, a variância cresce linearmente com o tempo. O processo não tem memória – conhecer W(s) não melhora sua previsão de W(t) além da distribuição N(W(s), t-s).

3. Movimento Browniano Geométrico: Preços de ativos

O problema do Browniano puro: pode ficar negativo. Preços de ações não podem. A solução: aplicar o processo ao logaritmo do preço, gerando o Movimento Browniano Geométrico (GBM).

dS(t) = μS(t)dt + σS(t)dW(t)

Solução (Lema de Itô): S(t) = S₀ exp[(μ – σ²/2)t + σW(t)]

Onde μ é o drift (tendência), σ a volatilidade, e o termo -σ²/2 é a correção de convexidade do Lema de Itô. Preços seguem lognormal, sempre positivos.

Simulando preços com GBM
ok

import numpy as np import matplotlib.pyplot as plt def simular_gbm(S0=100, mu=0.10, sigma=0.20, T=1, N=252, num_paths=100): “”” Simula trajetórias de preços via GBM S0: preço inicial mu: drift (retorno esperado anualizado) sigma: volatilidade anualizada T: horizonte em anos N: número de passos num_paths: número de simulações “”” dt = T / N t = np.linspace(0, T, N+1) # Incrementos do Browniano dW = np.random.normal(0, np.sqrt(dt), (num_paths, N)) # Matriz de preços S = np.zeros((num_paths, N+1)) S[:, 0] = S0 # Evolução usando a solução do GBM for i in range(1, N+1): S[:, i] = S[:, i-1] * np.exp( (mu – 0.5*sigma**2)*dt + sigma*dW[:, i-1] ) return t, S # Simula com parâmetros realistas np.random.seed(42) S0, mu, sigma = 100, 0.10, 0.20 t, S = simular_gbm(S0=S0, mu=mu, sigma=sigma, T=1, N=252, num_paths=200) # Estatísticas preco_final_medio = S[:, -1].mean() preco_esperado_teorico = S0 * np.exp(mu * 1) std_final = S[:, -1].std() print(“Estatísticas das 200 simulações:”) print(f” Preço final médio: R$ {preco_final_medio:.2f}”) print(f” Preço esperado (teórico): R$ {preco_esperado_teorico:.2f}”) print(f” Desvio padrão final: R$ {std_final:.2f}”) print(f” Mínimo observado: R$ {S[:, -1].min():.2f}”) print(f” Máximo observado: R$ {S[:, -1].max():.2f}”) # Plota amostra de trajetórias plt.figure(figsize=(7,4)) for i in range(min(50, S.shape[0])): plt.plot(t, S[i], alpha=0.15, color=’#4ea1ff’, linewidth=0.8) # Média das trajetórias plt.plot(t, S.mean(axis=0), color=’#56d17c’, linewidth=2, label=’Média’) plt.plot(t, [S0*np.exp(mu*ti) for ti in t], ‘–‘, color=’white’, linewidth=1.5, alpha=0.6, label=’E[S(t)]’) plt.xlabel(‘Tempo (anos)’, fontsize=11) plt.ylabel(‘Preço (R$)’, fontsize=11) plt.title(f’GBM: μ={mu:.0%}, σ={sigma:.0%}’, fontsize=13) plt.legend(fontsize=9) plt.grid(True, alpha=0.2) print(figb64())
(aguardando)

Leitura crítica: A média das simulações converge para o drift teórico. A dispersão cresce com o tempo devido à volatilidade. Nenhuma trajetória fica negativa. O GBM captura dois componentes: tendência determinística (μ) e ruído estocástico (σW). É essa combinação que Black-Scholes assume para o ativo subjacente.

4. Monte Carlo: Precificando opções por simulação

Stanislaw Ulam, trabalhando no Projeto Manhattan, joga paciência e percebe: probabilidades complexas podem ser estimadas por repetidas simulações aleatórias. O método de Monte Carlo nasce, batizado pelo cassino de Mônaco.

Para precificar uma opção europeia de compra (call): simule muitos caminhos do ativo sob medida neutra ao risco (drift = r), calcule o payoff max(S(T)-K, 0) em cada caminho, tire a média e desconte a valor presente.

C = e^(-rT) E[max(S(T) – K, 0)]
Monte Carlo para Call Europeia
ok

import numpy as np import matplotlib.pyplot as plt def monte_carlo_call(S0, K, T, r, sigma, num_sims=100000): “”” Precifica call europeia via Monte Carlo Sob medida neutra ao risco, drift = r “”” # Simula preços finais S(T) Z = np.random.standard_normal(num_sims) ST = S0 * np.exp((r – 0.5*sigma**2)*T + sigma*np.sqrt(T)*Z) # Payoffs da call payoffs = np.maximum(ST – K, 0) # Desconta a valor presente preco_call = np.exp(-r*T) * np.mean(payoffs) # Erro padrão para intervalo de confiança erro_padrao = np.exp(-r*T) * np.std(payoffs) / np.sqrt(num_sims) return preco_call, erro_padrao, ST, payoffs # Parâmetros de exemplo S0, K, T, r, sigma = 100, 100, 1.0, 0.05, 0.20 np.random.seed(42) preco, erro, ST, payoffs = monte_carlo_call(S0, K, T, r, sigma, num_sims=100000) print(f”Preço da Call (Monte Carlo): R$ {preco:.4f}”) print(f”Erro padrão: ± R$ {erro:.4f}”) print(f”IC 95%: [R$ {preco-1.96*erro:.4f}, R$ {preco+1.96*erro:.4f}]”) print(f”nEstatísticas dos preços finais S(T):”) print(f” Média: R$ {ST.mean():.2f} (teórico: {S0*np.exp(r*T):.2f})”) print(f” Mediana: R$ {np.median(ST):.2f}”) print(f” Desvio padrão: R$ {ST.std():.2f}”) # Histograma dos preços finais fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3.5)) ax1.hist(ST, bins=60, alpha=0.8, color=’#4ea1ff’, edgecolor=’none’) ax1.axvline(K, color=’#ffcd4e’, linestyle=’–‘, linewidth=2, label=f’Strike K={K}’) ax1.axvline(ST.mean(), color=’#56d17c’, linestyle=’-‘, linewidth=1.5, label=’Média S(T)’) ax1.set_xlabel(‘Preço Final S(T)’, fontsize=10) ax1.set_ylabel(‘Frequência’, fontsize=10) ax1.set_title(‘Distribuição de S(T)’, fontsize=11) ax1.legend(fontsize=8) ax1.grid(True, alpha=0.2) # Histograma dos payoffs ax2.hist(payoffs, bins=60, alpha=0.8, color=’#56d17c’, edgecolor=’none’) ax2.axvline(payoffs.mean(), color=’white’, linestyle=’–‘, linewidth=1.5, label=f’Payoff médio={payoffs.mean():.2f}’) ax2.set_xlabel(‘Payoff max(S(T)-K, 0)’, fontsize=10) ax2.set_ylabel(‘Frequência’, fontsize=10) ax2.set_title(‘Distribuição dos Payoffs’, fontsize=11) ax2.legend(fontsize=8) ax2.grid(True, alpha=0.2) plt.tight_layout() print(figb64())
(aguardando)

Interpretação: Note que muitas trajetórias terminam abaixo do strike K, gerando payoff zero. O valor da opção vem da cauda direita da distribuição. O IC 95% mostra a precisão da simulação – quanto mais simulações, menor o erro. Monte Carlo é flexível: funciona para opções exóticas, path-dependent, múltiplos ativos. O custo é computacional.

5. Black-Scholes: A solução analítica

A pergunta de Black e Scholes: e se pudéssemos construir um portfólio livre de risco combinando a opção com o ativo subjacente? Hedging dinâmico contínuo elimina o risco, levando a uma equação diferencial parcial cuja solução é surpreendentemente elegante.

Call Europeia: C = S₀N(d₁) – Ke^(-rT)N(d₂)

Put Europeia: P = Ke^(-rT)N(-d₂) – S₀N(-d₁)

d₁ = [ln(S₀/K) + (r + σ²/2)T] / (σ√T)

d₂ = d₁ – σ√T

N(·) = CDF da normal padrão

Premissas: (1) mercados eficientes sem arbitragem, (2) ativo segue GBM com σ constante, (3) taxa r constante, (4) exercício apenas no vencimento (europeia), (5) sem dividendos, (6) negociação contínua.

Black-Scholes com Gregas completas
ok

import numpy as np from scipy.stats import norm import matplotlib.pyplot as plt def black_scholes(S0, K, T, r, sigma, tipo=’call’): “”” Preço e gregas de opção europeia via Black-Scholes “”” d1 = (np.log(S0/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) d2 = d1 – sigma*np.sqrt(T) if tipo == ‘call’: preco = S0*norm.cdf(d1) – K*np.exp(-r*T)*norm.cdf(d2) delta = norm.cdf(d1) theta = (-S0*norm.pdf(d1)*sigma/(2*np.sqrt(T)) – r*K*np.exp(-r*T)*norm.cdf(d2)) / 365 rho = K*T*np.exp(-r*T)*norm.cdf(d2) / 100 else: # put preco = K*np.exp(-r*T)*norm.cdf(-d2) – S0*norm.cdf(-d1) delta = -norm.cdf(-d1) theta = (-S0*norm.pdf(d1)*sigma/(2*np.sqrt(T)) + r*K*np.exp(-r*T)*norm.cdf(-d2)) / 365 rho = -K*T*np.exp(-r*T)*norm.cdf(-d2) / 100 # Gregas independentes do tipo gamma = norm.pdf(d1) / (S0*sigma*np.sqrt(T)) vega = S0*norm.pdf(d1)*np.sqrt(T) / 100 # por 1% de vol return { ‘preco’: preco, ‘d1’: d1, ‘d2’: d2, ‘delta’: delta, ‘gamma’: gamma, ‘vega’: vega, ‘theta’: theta, ‘rho’: rho } # Exemplo: call at-the-money S0, K, T, r, sigma = 100, 100, 1.0, 0.05, 0.20 res_call = black_scholes(S0, K, T, r, sigma, ‘call’) print(“═══ BLACK-SCHOLES CALL ═══”) print(f”Preço: R$ {res_call[‘preco’]:.4f}”) print(f”d₁ = {res_call[‘d1’]:.4f} | d₂ = {res_call[‘d2’]:.4f}”) print(f”nGREGAS:”) print(f” Delta (Δ): {res_call[‘delta’]:.4f} — sensibilidade ao preço do ativo”) print(f” Gamma (Γ): {res_call[‘gamma’]:.5f} — curvatura do delta”) print(f” Vega (ν): {res_call[‘vega’]:.4f} — sensibilidade à volatilidade (por 1%)”) print(f” Theta (Θ): {res_call[‘theta’]:.4f} — decaimento temporal (por dia)”) print(f” Rho (ρ): {res_call[‘rho’]:.4f} — sensibilidade à taxa de juros”) # Superfície de preço em função de S e σ S_range = np.linspace(70, 130, 40) sigma_range = np.linspace(0.10, 0.40, 30) S_grid, sigma_grid = np.meshgrid(S_range, sigma_range) C_grid = np.zeros_like(S_grid) for i in range(len(sigma_range)): for j in range(len(S_range)): C_grid[i,j] = black_scholes(S_grid[i,j], K, T, r, sigma_grid[i,j], ‘call’)[‘preco’] plt.figure(figsize=(7,4)) plt.contourf(S_grid, sigma_grid, C_grid, levels=20, cmap=’viridis’) plt.colorbar(label=’Preço da Call (R$)’) plt.xlabel(‘Preço do Ativo S₀’, fontsize=11) plt.ylabel(‘Volatilidade σ’, fontsize=11) plt.title(‘Superfície de Preço Black-Scholes’, fontsize=13) plt.scatter([S0], [sigma], color=’red’, s=80, marker=’x’, linewidths=2, label=’Caso base’) plt.legend(fontsize=9) plt.grid(True, alpha=0.2) print(figb64())
(aguardando)

Entendendo as Gregas:

Delta: se S sobe R$1, a call sobe ~Delta reais. Para call ATM, Delta≈0.5. Para hedgers, Delta indica quantas ações comprar/vender.
Gamma: mede a convexidade. Alto gamma = delta muda rápido = risco de rehedge frequente.
Vega: se volatilidade implícita sobe 1%, a opção sobe ~Vega reais. Opções ATM têm máximo vega.
Theta: decaimento temporal. Opções perdem valor conforme T→0, especialmente quando OTM.
Rho: sensibilidade à taxa de juros. Menos relevante que as demais gregas em opções de curto prazo.

6. Comportamento das Gregas

Visualizar como as gregas mudam em função do preço do ativo e do tempo até vencimento revela dinâmicas de hedge e gestão de risco.

Gregas vs Preço do Ativo
ok

import numpy as np from scipy.stats import norm import matplotlib.pyplot as plt K, T, r, sigma = 100, 1.0, 0.05, 0.20 S_range = np.linspace(60, 140, 100) deltas = [] gammas = [] vegas = [] thetas = [] for S in S_range: res = black_scholes(S, K, T, r, sigma, ‘call’) deltas.append(res[‘delta’]) gammas.append(res[‘gamma’]) vegas.append(res[‘vega’]) thetas.append(res[‘theta’]) fig, axes = plt.subplots(2, 2, figsize=(8, 6)) axes[0,0].plot(S_range, deltas, color=’#4ea1ff’, linewidth=2) axes[0,0].axvline(K, color=’white’, linestyle=’–‘, alpha=0.4, linewidth=1) axes[0,0].set_title(‘Delta’, fontsize=11) axes[0,0].set_ylabel(‘Δ’, fontsize=10) axes[0,0].grid(True, alpha=0.2) axes[0,1].plot(S_range, gammas, color=’#56d17c’, linewidth=2) axes[0,1].axvline(K, color=’white’, linestyle=’–‘, alpha=0.4, linewidth=1) axes[0,1].set_title(‘Gamma’, fontsize=11) axes[0,1].set_ylabel(‘Γ’, fontsize=10) axes[0,1].grid(True, alpha=0.2) axes[1,0].plot(S_range, vegas, color=’#ffcd4e’, linewidth=2) axes[1,0].axvline(K, color=’white’, linestyle=’–‘, alpha=0.4, linewidth=1) axes[1,0].set_title(‘Vega’, fontsize=11) axes[1,0].set_xlabel(‘Preço do Ativo S’, fontsize=10) axes[1,0].set_ylabel(‘ν’, fontsize=10) axes[1,0].grid(True, alpha=0.2) axes[1,1].plot(S_range, thetas, color=’#ff6b6b’, linewidth=2) axes[1,1].axvline(K, color=’white’, linestyle=’–‘, alpha=0.4, linewidth=1) axes[1,1].set_title(‘Theta (por dia)’, fontsize=11) axes[1,1].set_xlabel(‘Preço do Ativo S’, fontsize=10) axes[1,1].set_ylabel(‘Θ’, fontsize=10) axes[1,1].grid(True, alpha=0.2) plt.tight_layout() print(figb64())
(aguardando)

Observações: Delta de call vai de 0 (deep OTM) a 1 (deep ITM). Gamma é máximo ATM, onde hedge precisa de ajustes mais frequentes. Vega também pico em ATM – onde incerteza mais afeta valor. Theta é mais negativo ATM para calls próximas ao vencimento.

7. Monte Carlo vs Black-Scholes: Convergência

Monte Carlo converge para Black-Scholes conforme aumentamos simulações. Vamos testar empiricamente essa convergência e ver o trade-off entre precisão e velocidade.

Teste de convergência
ok

import numpy as np from scipy.stats import norm import matplotlib.pyplot as plt import time S0, K, T, r, sigma = 100, 100, 1.0, 0.05, 0.20 # Preço Black-Scholes (referência) bs_price = black_scholes(S0, K, T, r, sigma, ‘call’)[‘preco’] # Testa diferentes números de simulações sim_counts = [100, 500, 1000, 5000, 10000, 50000, 100000] mc_prices = [] mc_errors = [] elapsed_times = [] np.random.seed(42) for n in sim_counts: start = time.time() preco, erro, _, _ = monte_carlo_call(S0, K, T, r, sigma, num_sims=n) elapsed = time.time() – start mc_prices.append(preco) mc_errors.append(abs(preco – bs_price)) elapsed_times.append(elapsed) print(“═══ CONVERGÊNCIA MONTE CARLO → BLACK-SCHOLES ═══”) print(f”Black-Scholes (analítico): R$ {bs_price:.4f}n”) for i, n in enumerate(sim_counts): print(f”{n:>6} sims: R$ {mc_prices[i]:.4f} | erro {mc_errors[i]:.4f} | {elapsed_times[i]*1000:.1f}ms”) # Gráficos fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3.5)) ax1.semilogx(sim_counts, mc_prices, ‘o-‘, color=’#4ea1ff’, linewidth=2, markersize=6, label=’Monte Carlo’) ax1.axhline(bs_price, color=’#56d17c’, linestyle=’–‘, linewidth=2, label=’Black-Scholes’) ax1.set_xlabel(‘Número de Simulações’, fontsize=10) ax1.set_ylabel(‘Preço da Call (R$)’, fontsize=10) ax1.set_title(‘Convergência do Preço’, fontsize=11) ax1.legend(fontsize=9) ax1.grid(True, alpha=0.2) ax2.loglog(sim_counts, mc_errors, ‘o-‘, color=’#ff6b6b’, linewidth=2, markersize=6) ax2.set_xlabel(‘Número de Simulações’, fontsize=10) ax2.set_ylabel(‘Erro Absoluto (R$)’, fontsize=10) ax2.set_title(‘Erro vs Simulações’, fontsize=11) ax2.grid(True, alpha=0.2, which=’both’) plt.tight_layout() print(figb64())
(aguardando)

Quando usar cada método?

Black-Scholes: Instantâneo, exato para opções europeias vanilla. Use sempre que as premissas forem razoáveis.
Monte Carlo: Flexível para opções exóticas, path-dependent (asiáticas, barreira), múltiplos ativos, volatilidade estocástica. Custo computacional cresce com dimensionalidade.

8. Paridade Put-Call: Relação de não-arbitragem

Relação fundamental que liga calls, puts, ativo e renda fixa. Se violada, existe arbitragem livre de risco.

C – P = S₀ – Ke^(-rT)
Verificação numérica da paridade
ok

import numpy as np from scipy.stats import norm S0, K, T, r, sigma = 100, 105, 0.5, 0.05, 0.25 call = black_scholes(S0, K, T, r, sigma, ‘call’) put = black_scholes(S0, K, T, r, sigma, ‘put’) lado_esq = call[‘preco’] – put[‘preco’] lado_dir = S0 – K*np.exp(-r*T) print(“═══ PARIDADE PUT-CALL ═══”) print(f”Call: R$ {call[‘preco’]:.4f}”) print(f”Put: R$ {put[‘preco’]:.4f}”) print(f”nC – P = {lado_esq:.4f}”) print(f”S – Ke^(-rT) = {lado_dir:.4f}”) print(f”Diferença (deve ser ~0): {abs(lado_esq – lado_dir):.8f}”) print(“n✓ Paridade confirmada numericamente”)
(aguardando)

9. Roteiro de estudo e exercícios

Passo a passo sugerido:

Execute a célula do Movimento Browniano. Observe que trajetórias não têm tendência definida, média zero, variância cresce linearmente.
Rode o GBM. Compare visualmente com Browniano puro. Note que preços nunca ficam negativos. Confira que média empírica converge para S₀e^(μT).
Simule a call via Monte Carlo. Veja que o payoff é assimétrico – limitado a zero na esquerda, ilimitado à direita. Aumente o número de simulações e observe o erro padrão diminuir.
Calcule com Black-Scholes. Compare com Monte Carlo. Entenda cada grega: Delta para hedge, Gamma para convexidade, Vega para vol, Theta para tempo.
Plote gregas vs S. Identifique onde gamma é máximo (risco de rehedge), onde vega é máximo (sensibilidade a vol implícita).
Teste a paridade put-call. Se houver desvio, investigue (erros numéricos, premissas violadas, oportunidade de arbitragem).

Exercícios propostos:

Calcule o preço de uma put europeia com S₀=50, K=55, r=0.03, σ=0.25, T=0.5. Compare BS vs MC.
Simule 10.000 trajetórias de GBM e compare distribuição final com lognormal teórica.
Para uma call ATM, plote Delta e Gamma em função do tempo até vencimento (fixando S=K). O que acontece quando T→0?
Implemente busca de volatilidade implícita: dado preço de mercado da opção, encontre σ que iguala BS ao mercado (use scipy.optimize).
Construa smile de volatilidade: para diferentes strikes K, calcule σ implícita de calls com mesmo T. Plote σ_impl vs K/S₀.

10. Além de Black-Scholes

O modelo clássico assume volatilidade constante, mercados contínuos, sem fricções. A realidade difere. Extensões importantes:

Volatilidade estocástica (Heston): σ varia no tempo seguindo processo estocástico próprio. Captura smile de volatilidade.
Saltos (Merton Jump-Diffusion): Adiciona processos de Poisson para capturar movimentos bruscos (crashes, anúncios).
Opções americanas: Exercício antecipado exige métodos numéricos – árvores binomiais, diferenças finitas, LSM.
Custos de transação: Hedging contínuo é impossível. Modelos com bandas de rehedge.
Dividendos: Fácil de incluir: S₀ → S₀e^(-qT) onde q é yield de dividendos.

Black-Scholes é ponto de partida, não ponto final. Dominar o modelo clássico permite entender e construir extensões sofisticadas.