Nota

Esta página foi gerada a partir de tutorials/finance/03_european_call_option_pricing.ipynb.

Execute interativamente no IBM Quantum lab.

Precificando Opções de Compra Europeias

Introdução

Suponha uma opção de compra Europeia com preço contratado \(K\) e um ativo subjacente cujo preço à vista na maturidade \(S_T\) segue uma determinada distribuição aleatória. A função de pagamento correspondente é definida como:

\[\max\ {S_T-K, 0 \}\]

A seguir, um algoritmo quântico baseado na estimativa de amplitude é usado para estimar o pagamento esperado, por exemplo, o preço justo antes de desconto, para a opção:

\[\mathbb{E}\left[ \max\{S_T - K, 0\} \right]\]

bem como o correspondente \(\Delta\), ou seja, a derivada do preço de opção no que diz respeito ao preço à vista, definida como:

\[\Delta = \mathbb{P}\left[S_T \geq K\right]\]

A aproximação da função objetivo e uma introdução geral aos preços de opção e à análise de risco nos computadores quânticos são indicadas nos seguintes documentos:

• Quantum Risk Analysis. Woerner, Egger. 2018.

• Precificação de Opções utilizando Computadores Quânticos. Stamatopoulos et al. 2019.

import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np

from qiskit import Aer, QuantumCircuit
from qiskit.aqua.algorithms import IterativeAmplitudeEstimation
from qiskit.circuit.library import LogNormalDistribution, LinearAmplitudeFunction

Modelo de Incerteza

Construímos uma fábrica de circuitos para carregar uma distribuição aleatória log-normal em um estado quântico. A distribuição é truncada para um determinado intervalo \([\text{low}, \text{high}]\) e discretizada utilizando uma grade de \(2^n\) pontos, onde \(n\) denota o número de qubits usados. O operador unitário correspondente à fábrica de circuitos implementa o seguinte:

\[\big|0\rangle_{n} \mapsto \big|\psi\rangle_{n} = \sum_{i=0}^{2^n-1} \sqrt{p_i}\big|i\rangle_{n},\]

onde \(p_i\) denota as probabilidades correspondentes à distribuição truncada e discretizada e onde \(i\) é mapeado para o intervalo correto utilizando o mapeamento afim:

\[\{0, \ldots, 2^n-1\} \ni i \mapsto \frac{\text{high} - \text{low}}{2^n - 1} * i + \text{low} \in [\text{low}, \text{high}].\]

# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3

# parameters for considered random distribution
S = 2.0       # initial spot price
vol = 0.4     # volatility of 40%
r = 0.05      # annual interest rate of 4%
T = 40 / 365  # 40 days to maturity

# resulting parameters for log-normal distribution
mu = ((r - 0.5 * vol**2) * T + np.log(S))
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2/2)
variance = (np.exp(sigma**2) - 1) * np.exp(2*mu + sigma**2)
stddev = np.sqrt(variance)

# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low  = np.maximum(0, mean - 3*stddev)
high = mean + 3*stddev

# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high))

# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel('Spot Price at Maturity $S_T$ (\$)', size=15)
plt.ylabel('Probability ($\%$)', size=15)
plt.show()

Função de Payoff

A função de Payoff é igual a zero enquanto o preço à vista na maturidade \(S_T\) for menor do que o preço acordado \(K\) e então aumentar o valor de forma linear. A implementação usa um comparador, que vira um qubit de ancila de \(\big|0\rangle\) to \(\big|1\rangle\) if \(S_T \geq K\), e este ancila é usado para controlar a parte linear da função de payoff.

A própria parte linear é então aproximada da seguinte maneira. Exploramos o fato de que \(\sin^2(y + \pi/4) \approx y + 1/2\) para \(|y|\) pequeno. Assim, para um dado fator de reescalonamento de aproximação \(c_\text{approx} \in [0, 1]\) e \(x \in [0, 1]\) consideramos

\[\sin^2( \pi/2 * c_\text{approx} * ( x - 1/2 ) + \pi/4) \approx \pi/2 * c_\text{approx} * ( x - 1/2 ) + 1/2\]

for small \(c_\text{approx}\).

Podemos facilmente construir um operador que atua como

\[\big|x\rangle \big|0\rangle \mapsto \big|x\rangle \left( \cos(a*x+b) \big|0\rangle + \sin(a*x+b) \big|1\rangle \right),\]

usando rotações Y controladas.

Eventualmente, estamos interessados na probabilidade de medir \(\big|1\rangle\) no último qubit, o que corresponde a \(\sin^2(a*x+b)\). Juntamente com a aproximação, acima, isto permite aproximar os valores de interesse. Quanto menor o \(c_\text{approx}\) escolhido, melhor a aproximação. No entanto, uma vez que estamos estimando uma propriedade escalonada por \(c_\text{approx}\) em seguida, o número de qubits de avaliação \(m\) precisa ser ajustado de acordo.

Para mais detalhes sobre a aproximação podemos consultar: Quantum Risk Analysis. Woerner, Egger. 2018.

# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 1.896

# set the approximation scaling for the payoff function
c_approx = 0.25

# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = high - strike_price
european_call_objective = LinearAmplitudeFunction(
    num_uncertainty_qubits,
    slopes,
    offsets,
    domain=(low, high),
    image=(f_min, f_max),
    breakpoints=breakpoints,
    rescaling_factor=c_approx
)

# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
num_qubits = european_call_objective.num_qubits
european_call = QuantumCircuit(num_qubits)
european_call.append(uncertainty_model, range(num_uncertainty_qubits))
european_call.append(european_call_objective, range(num_qubits))

# draw the circuit
european_call.draw()

     ┌───────┐┌────┐
q_0: ┤0      ├┤0   ├
     │       ││    │
q_1: ┤1 P(X) ├┤1   ├
     │       ││    │
q_2: ┤2      ├┤2   ├
     └───────┘│    │
q_3: ─────────┤3 F ├
              │    │
q_4: ─────────┤4   ├
              │    │
q_5: ─────────┤5   ├
              │    │
q_6: ─────────┤6   ├
              └────┘

# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.maximum(0, x - strike_price)
plt.plot(x, y, 'ro-')
plt.grid()
plt.title('Payoff Function', size=15)
plt.xlabel('Spot Price', size=15)
plt.ylabel('Payoff', size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()

# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = sum(uncertainty_model.probabilities[x >= strike_price])
print('exact expected value:\t%.4f' % exact_value)
print('exact delta value:   \t%.4f' % exact_delta)

exact expected value:   0.1623
exact delta value:      0.8098

Avaliando o Payoff Esperado

# set target precision and confidence level
epsilon = 0.01
alpha = 0.05

# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha,
                                  state_preparation=european_call,
                                  objective_qubits=[3],
                                  post_processing=european_call_objective.post_processing)

result = ae.run(quantum_instance=Aer.get_backend('qasm_simulator'), shots=100)

conf_int = np.array(result['confidence_interval'])
print('Exact value:        \t%.4f' % exact_value)
print('Estimated value:    \t%.4f' % (result['estimation']))
print('Confidence interval:\t[%.4f, %.4f]' % tuple(conf_int))

Exact value:            0.1623
Estimated value:        0.1694
Confidence interval:    [0.1633, 0.1755]

Em vez de construir esses circuitos manualmente, o módulo Qiskit finance oferece o circuito EuropeanCallExpectedValue, que já implementa esta funcionalidade como bloco de construção.

from qiskit.finance.applications import EuropeanCallExpectedValue

european_call_objective = EuropeanCallExpectedValue(num_uncertainty_qubits,
                                                    strike_price,
                                                    rescaling_factor=c_approx,
                                                    bounds=(low, high))

# append the uncertainty model to the front
european_call = european_call_objective.compose(uncertainty_model, front=True)

# set target precision and confidence level
epsilon = 0.01
alpha = 0.05

# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha,
                                  state_preparation=european_call,
                                  objective_qubits=[3],
                                  post_processing=european_call_objective.post_processing)
result = ae.run(quantum_instance=Aer.get_backend('qasm_simulator'), shots=100)

conf_int = np.array(result['confidence_interval'])
print('Exact value:        \t%.4f' % exact_value)
print('Estimated value:    \t%.4f' % (result['estimation']))
print('Confidence interval:\t[%.4f, %.4f]' % tuple(conf_int))

Exact value:            0.1623
Estimated value:        0.1708
Confidence interval:    [0.1656, 0.1759]

Avaliar o Delta

O Delta é um pouco mais simples de avaliar do que o pagamento esperado. Da mesma forma que o pagamento esperado, usamos um circuito de comparador e um qubit ancila para identificar os casos onde \(S_T > K\). No entanto, uma vez que só estamos interessados em que seja verdade a probabilidade dessa condição ser verdadeira, podemos usar diretamente este ancila qubit como o qubit objetivo em estimativa de amplitude sem qualquer aproximação adicional.

from qiskit.finance.applications import EuropeanCallDelta

european_call_delta = EuropeanCallDelta(num_uncertainty_qubits, strike_price, bounds=(low, high))

european_call_delta.decompose().draw()

state_0: ───────■─────────────────────────────■──
                │                             │
state_1: ───────┼────■───────────────────■────┼──
         ┌───┐  │    │            ┌───┐  │    │
state_2: ┤ X ├──┼────┼─────────■──┤ X ├──┼────┼──
         ├───┤  │    │       ┌─┴─┐└───┘  │    │
state_3: ┤ X ├──┼────┼───────┤ X ├───────┼────┼──
         └───┘┌─┴─┐  │       └─┬─┘       │  ┌─┴─┐
 work_0: ─────┤ X ├──■─────────┼─────────■──┤ X ├
              └───┘┌─┴─┐┌───┐  │  ┌───┐┌─┴─┐└───┘
 work_1: ──────────┤ X ├┤ X ├──■──┤ X ├┤ X ├─────
                   └───┘└───┘     └───┘└───┘     

state_preparation = QuantumCircuit(european_call_delta.num_qubits)
state_preparation.append(uncertainty_model, range(uncertainty_model.num_qubits))
state_preparation.append(european_call_delta, range(european_call_delta.num_qubits))
state_preparation.draw()

     ┌───────┐┌──────┐
q_0: ┤0      ├┤0     ├
     │       ││      │
q_1: ┤1 P(X) ├┤1     ├
     │       ││      │
q_2: ┤2      ├┤2     ├
     └───────┘│  ECD │
q_3: ─────────┤3     ├
              │      │
q_4: ─────────┤4     ├
              │      │
q_5: ─────────┤5     ├
              └──────┘

# set target precision and confidence level
epsilon = 0.01
alpha = 0.05

# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha,
                                        state_preparation=state_preparation,
                                        objective_qubits=[num_uncertainty_qubits])

result_delta = ae_delta.run(quantum_instance=Aer.get_backend('qasm_simulator'), shots=100)

conf_int = np.array(result_delta['confidence_interval'])
print('Exact delta:    \t%.4f' % exact_delta)
print('Esimated value: \t%.4f' % result_delta['estimation'])
print('Confidence interval: \t[%.4f, %.4f]' % tuple(conf_int))

Exact delta:            0.8098
Esimated value:         0.8068
Confidence interval:    [0.8013, 0.8123]

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	None
Terra	0.17.0.dev0+4ada179
Aer	0.6.1
Ignis	0.5.0.dev0+470d8cc
Aqua	0.9.0.dev0+5a88b59
IBM Q Provider	0.8.0
System information
Python	3.7.7 (default, May 6 2020, 04:59:01) [Clang 4.0.1 (tags/RELEASE_401/final)]
OS	Darwin
CPUs	2
Memory (Gb)	16.0
Tue Oct 20 10:57:12 2020 CEST

This code is a part of Qiskit

© Copyright IBM 2017, 2020.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.