Nota

Esta página foi gerada, a partir de tutorials/finance/05_bull_spread_pricing.ipynb.

Execute interativamente no IBM Quantum lab.

Precificando Bull Spreads

Introdução

Suponha uma bull spread com preços de exercício \(K_1 < K_2\) e um ativo subjacente, cujo preço, à vista, no vencimento \(S_T\), segue uma dada distribuição aleatória. A função payoff correspondente é definida como:

\[\min\{\max\{S_T - K_1, 0\}, K_2 - K_1\}\]

A seguir, um algoritmo quântico baseado em estimativa de amplitude é usado para estimar o payoff esperado, ou seja, o preço justo, antes de descontar para a opção:

\[\mathbb{E}\left [\min\ {\max\ {S_T-K_1, 0 \}, K_2-K_1\} \right]\]

assim como o \(\Delta\) correspondente, ou seja, a derivada do preço da opção com relação ao preço à vista, definido como:

\[\Delta = \mathbb{P}\left [K_1 \leq S \leq K_2\right]\]

A aproximação da função objetivo e uma introdução geral sobre precificação de opções e análise de risco em computadores quânticos são dadas nos seguintes artigos:

• Análise de Risco Quântico. 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
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\) denotam 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 circuit factory for uncertainty model
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 Payoff

A função payoff é igual a zero, enquanto o preço à vista no vencimento \(S_T\) é menor do que o preço de exercício \(K_1\), então aumenta linearmente, e é limitada por \(K_2\). A implementação usa dois comparadores, que invertem um qubit auxiliar cada de \(\big|0\rangle\) para \(\big|1\rangle\) se \(S_T \geq K_1\) e \(S_T \leq K_2\), e estes auxiliares são usados para controlar a parte linear da função 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\]

para \(c_\text{approx}\) pequeno.

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.

For more details on the approximation, we refer to: 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 = 1.438
strike_price_2 = 2.584

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

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

# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
bull_spread = bull_spread_objective.compose(uncertainty_model, front=True)

# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.minimum(np.maximum(0, x - strike_price_1), strike_price_2 - strike_price_1)
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[np.logical_and(x >= strike_price_1, x <= strike_price_2)])
print('exact expected value:\t%.4f' % exact_value)
print('exact delta value:   \t%.4f' % exact_delta)

exact expected value:   0.5695
exact delta value:      0.9291

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=bull_spread,
                                  objective_qubits=[num_uncertainty_qubits],
                                  post_processing=bull_spread_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.5695
Estimated value:        0.5694
Confidence interval:    [0.5639, 0.5750]

Avaliando o Delta

O Delta é um pouco mais simples de avaliar, do que o payoff esperado. De forma semelhante ao payoff esperado, utilizamos circuitos comparadores e qubits auxiliares para identificar os casos em que \(K_1 \leq S_T \leq K_2\). No entanto, uma vez que estamos apenas interessados na probabilidade desta condição ser verdadeira, podemos utilizar diretamente um qubit auxiliar como o qubit objetivo na estimativa de amplitude sem qualquer aproximação posterior.

# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price_1, strike_price_2]
slopes = [0, 0, 0]
offsets = [0, 1, 0]
f_min = 0
f_max = 1

bull_spread_delta_objective = LinearAmplitudeFunction(
    num_uncertainty_qubits,
    slopes,
    offsets,
    domain=(low, high),
    image=(f_min, f_max),
    breakpoints=breakpoints,
)  # no approximation necessary, hence no rescaling factor

# construct the A operator by stacking the uncertainty model and payoff function together
bull_spread_delta = bull_spread_delta_objective.compose(uncertainty_model, front=True)

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

# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha,
                                        state_preparation=bull_spread_delta,
                                        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('Estimated value:\t%.4f' % result_delta['estimation'])
print('Confidence interval: \t[%.4f, %.4f]' % tuple(conf_int))

Exact delta:            0.9291
Estimated value:        0.9290
Confidence interval:    [0.9264, 0.9316]

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	None
Terra	0.16.0.dev0+28d8c6a
Aer	0.6.1
Ignis	0.5.0.dev0+470d8cc
Aqua	0.8.0.dev0+ce81016
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
Fri Oct 16 11:03:18 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.