Uma firma que possui uma opção de contração tem o direito de reduzir (contrair) sua escala de produção em determinada fração caso as condições de mercado são piores que as esperadas. O exercício não informa a validade do contrato, então iremos assumir uma validade de 5 anos, pois é o padrão adotado no livro.
Vamos resolver o problema usando Python. O código a seguir irá montar a Árvore Binomial com valor do ativo em cada nó. Em seguida irá calcular o valor da opção em cada nó final. Depois irá calcular, retroativamente o valor da opção nos outros nós, ou seja, o maior valor entre continuar a operação e manter a opção aberta ou exercer o direito de contração.
Os parâmetros são: n é numero de períodos, S0 é o valor presente do fluxo de caixa livre, X é o valor adquirido caso a opção seja exercida, r é a taxa de juros livre de risco, v é a volatilidade, c é a fração que a operação irá reduzir caso a opção seja exercida e t é o tempo de validade da opção.
def Arvore_Binomial_Contração(n, S0, X, r, v, c, t):
import numpy as np
At=n/t
u=np.exp(v*np.sqrt(At))
d=1/u
p=(np.exp(r*At)-d)/(u-d)
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
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,n], (assetvalue[j,n]*c)+X)
for i in range (n-1,-1,-1): #Calcula valor da opção retroativamente
for j in range(i+1):
optionvalue[j,i]=max(0, c*assetvalue[j,i]+X, np.exp(-r*At)*(p*optionvalue[j,i+1]+(1-p)*optionvalue[j+1,i+1]))
return assetvalue.round(1), optionvalue.round(1)
if __name__=='__main__':
print(Arvore_Binomial_Contração(5, 400, 200, 0.05, 0.3, 0.75, 5))
A primeira matriz é a árvore binomial com valor do ativo, a segunda matriz é a árvore binomial com valor da opção:

Para o item 2 vamos utilizar o mesmo código, mudando apenas o parâmetro v. Lembre que queremos apenas a árvore binomial com os valores da opção, ou seja, a segunda matriz que o código gera. As matrizes para v=0.5, 0.4, 0.2, 0.1 são, respectivamente:

Como era de se esperar, o gap entre o maior e o menor valor da opção diminui à medida que a volatilidade se reduz.