Como calcular o preço de opções compostas utilizando o modelo binomial?

Question

AntiquesNow é uma start-up que pretende construir uma loja física, assim como uma loja online para a venda de antiguidades. A empresa deseja utilizar a loja física como um galpão para realizar os pedidos feitos em seu site. A análise dos fluxos de caixa descontados utilizando uma taxa de desconto ajustada ao risco calculou o VPL da empresa em 450 milhões. A volatilidade anual desse payoff é de 25%. Baseada em sua competição AntiquesNow estima que possua três anos para decidir se realiza ou não esse projeto. A taxa de juros livre de risco durante esse período é de 5%. A construção da loja física terá um custo de $50 milhões e o desenvolvimento do comércio online custará $20 milhões. A empresa precisa construir a loja física antes do lançamento do seu site, criando assim uma opção composta. A empresa possui interesse em usufruir dessa opção no valuation do projeto, para realizar uma melhor escolha acerca do investimento, levando em conta a incerteza de seu retorno. Qual é o o valuation dessa opção real?

Answer 1

Para realizar o cálculo do valor dessa opção real, devemos analisar qual seria o preço de uma opção simples acerca do investimento que deve ser realizado primeiro, no caso, a construção da loja física.

Os valores do problema são:

\[ s_0 = milhões\] \[X_\ e\ X_2 = \ e\ milhões\]\[T_1\ e\ T_2 = 3\ anos\]\[\sigma = 25\%\]\[r = 5\%\]\[\delta t = 1\ ano\]

Serão necessárias as seguintes fórmulas:

\[u=exp(\sigma\sqrt(\delta t))\]\[d=1/u\]\[p=(exp(r\delta t)-d)/(u-d)\]

Utilizando o modelo binomial, avaliamos o valor da opção nos seus nós finais, e, a partir desses valores, calculamos o valor presente da opção nos nós intermediários, por meio da ponderação das possibilidades de acordo com suas probabilidades neutras ao risco, dadas por p. A árvore binomial da primeira opção possui a seguinte forma:

Onde os valores superiores são o valor da empresa e os inferiores o valor da opção.

Em seguida, utilizamos os valores da primeira opção como um payoff sintético para o cálculo da segunda. Realizando as mesmas etapas feitas anteriormente. A árvore binomial da segunda opção possui a seguinte forma:

Onde os valores superiores são o valor da opção calculada anteriormente e os inferiores o valor da opção final.

Com isso, temos que o valor da opção é de $4,8 milhões.

O cálculo desse tipo de opção pode ser realizado em python, utilizando o seguinte código:

import numpy as np

s = 50
invest1 = 50
invest2 = 20
t = 3
sigma = 0.25
rf = 0.05
deltat = 1

def Arvore_Binomial_Paralela(n, s0, inv1, inv2, r, std, t): 
    At = n/t
    u = np.exp(std*np.sqrt(At))
    d = 1/u
    p = (np.exp(r*At)-d)/(u-d)
    it = 0

    assetvalue = np.zeros((n+1, n+1))  #Valor do Ativo em cada nó da Árvore começando por S0
    assetvalue[0,0] = s0               
    for i in range (1, n+1):
        assetvalue[0, i] = assetvalue[0, i-1] * u
        for j in range (1, i+1):
            assetvalue[j, i] = assetvalue[j-1, i-1] * d

    while it < 2:

        i = 3
        optionvalue = np.zeros((n+1,n+1))    #Valor da opçao nos últimos nós da Árvore
        for j in range(n+1):
            optionvalue[j,n] = max(assetvalue[j,i] - inv1, 0)

        for i in range (n-1,-1,-1):   #Calcula valor da opção retroativamente 
            for j in range(i+1):
                optionvalue[j,i] = max( assetvalue[j,i] - inv1, np.exp(-r*At)*(p*optionvalue[j,i+1]+(1-p)*optionvalue[j+1,i+1]))

        inv1 = np.copy(inv2)
        it += 1

        if inv2!=0:

            valorempresa = np.copy(assetvalue)
            assetvalue = np.copy(optionvalue)
            inv2 = 0

        return valorempresa.round(1), assetvalue.round(1), optionvalue.round(1)

if __name__ == "__main__":
     print(Arvore_Binomial_Paralela(t, s, invest1, invest2, rf, sigma, t))

Esse código retorna três matrizes, a primeira com os valores da empresa em cada momento do tempo, a segunda com os valores da opção sintética e o terceiro com os valores da opção desejada. Com ele obtemos o seguinte resultado:

(array([[ 50. ,  64.2,  82.4, 105.9],
       [  0. ,  38.9,  50. ,  64.2],
       [  0. ,   0. ,  30.3,  38.9],
       [  0. ,   0. ,   0. ,  23.6]]), 

array([[12.5, 21.1, 34.9, 55.9],
       [ 0. ,  3.7,  7.3, 14.2],
       [ 0. ,  0. ,  0. ,  0. ],
       [ 0. ,  0. ,  0. ,  0. ]]),

 array([[ 4.8,  9.4, 18.4, 35.9],
       [ 0. ,  0. ,  0. ,  0. ],
       [ 0. ,  0. ,  0. ,  0. ],
       [ 0. ,  0. ,  0. ,  0. ]]))

Comments

Olá muito legal o problema e a solução!

Só queria acrescentar que para o código funcionar a parde de dentro do "def" deve estar "indendada" e é necessário acrescentar um "n=3" em algum momento antes de "assetvalue = np.zeros((n+1, n+1))"

---

Obrigado, Júlia! Já corrigi o engano. Quanto ao n, ele é definido ao chamar a função, sendo ele o valor de t.