Credit Risk Analysis using Quantum Computers

TL;DR

This paper introduces a quantum algorithm for more efficient credit risk estimation, specifically calculating economic capital requirements, and analyzes its scalability and hardware requirements for practical implementation.

Contribution

It presents a novel quantum algorithm for credit risk analysis and provides detailed estimates of qubit needs, circuit depth, and runtime for realistic problem sizes.

Findings

Quantum algorithm reduces computational complexity compared to classical methods.

Estimated qubit count and circuit depth for practical quantum hardware.

Analysis indicates potential for efficient credit risk estimation on future quantum computers.

Abstract

We present and analyze a quantum algorithm to estimate credit risk more efficiently than Monte Carlo simulations can do on classical computers. More precisely, we estimate the economic capital requirement, i.e. the difference between the Value at Risk and the expected value of a given loss distribution. The economic capital requirement is an important risk metric because it summarizes the amount of capital required to remain solvent at a given confidence level. We implement this problem for a realistic loss distribution and analyze its scaling to a realistic problem size. In particular, we provide estimates of the total number of required qubits, the expected circuit depth, and how this translates into an expected runtime under reasonable assumptions on future fault-tolerant quantum hardware.

Tables

Table 1. Table 1: Problem parameters for the two-assets example.

asset number	loss given default	default prob.	sensitivity
$k$	${\lambda }_k$	$p_k^0$	${\rho }_k$
1	1	0.15	0.1
2	2	0.25	0.05

Table 2. Table 2: Bounds on circuit depth of the operators 𝒰 𝒰 \mathcal{U} , 𝒮 𝒮 \mathcal{S} , 𝒞 𝒞 \mathcal{C} in terms of CNOT and Toffoli-gates, see Appendices C , and D , E , for more details.

operator	circuit depth (T/Toffoli-gates)
$𝒰$	$26+28n_Z$
$𝒮$	${\log }_2\left(K\right)\left(\lfloor {\log }_2\left(n_S\right)\rfloor +\lfloor {\log }_2\left(n_S/3\right)\rfloor +7\right)$
$𝒞$	$2\lfloor {\log }_2\left(n_S-1\right)\rfloor +9$

Equations

$${\text{VaR}}_{\alpha }[\mathcal{L}]$$

$${\text{ECR}}_{\alpha }[\mathcal{L}]$$

$$p_k(z)$$

$$\mathcal{A}{|0⟩}_{n+1}$$

$$\mathcal{Q}$$

$$\frac{2\sqrt{a(1-a)}\pi }{M}+\frac{{\pi }^2}{M^2}$$

$$\frac{1}{5M}+\frac{{\pi }^2}{M^2}$$

$$\mathcal{U}$$

$$\mathcal{S}:$$

$$\mathcal{C}:{|i⟩}_{n_S}|0⟩\mapsto \{\begin{array}{ll}{|i⟩}_{n_S}|1⟩& \text{if i≤x},\\ {|i⟩}_{n_S}|0⟩& \text{otherwise.}\end{array}$$

$$n_S(2^{m+1}-1)N_{\text{T}}^{\mathcal{A}}.$$

$$\mathbb{E}[\mathcal{L}]$$

$$\lfloor {\log }_2(n)\rfloor +\lfloor {\log }_2(n/3)\rfloor +7,$$

$${\log }_2(K)(\lfloor {\log }_2(n_S)\rfloor +\lfloor {\log }_2(n_S/3)\rfloor +7).$$

Full text

I Introduction

Economic Capital, a key tool of risk management, is computed by financial service firms to determine the amount of risk capital that they require to remain solvant in the face of adverse yet realistic conditions Porteous et al. (2003). Financial service firms are exposed to many forms of risk Porteous (2002) such as credit risk which is the risk of a monetary loss resulting from a counterparty failing to meet a financial obligation Risk Management Group of the Basel Committee on Banking Supervision (2000); Bouteillé and Coogan-Pushner (2013). For instance, a payment may not be made in due time or at all. Risk metrics such as Value at Risk and the Economic Capital Requirement (ECR) are often calculated for many different scenarios. Monte Carlo (MC) simulations are thus the method of choice for this task.

In a MC simulation a parameter is estimated by building a distribution obtained by taking $M$ samples from the model input distributions. The error on the resulting estimation scales as $\mathcal{O}(1/\sqrt{M})$ Glasserman (2003). Evaluating credit risk with MC is a rare-event simulation problem which requires many samples thereby making MC computationally costly Glasserman and Li (2005). Importance sampling reduces the computational cost by lowering the constants but does not change the asymptotic rate of convergence.

Quantum computers process information using the laws of quantum mechanics Nielsen and Chuang (2010). This opens up novel ways of addressing various computational tasks. Problems that may benefit from quantum computing include quantum chemistry calculations Moll et al. (2018); Kandala et al. (2018), machine learning Havlicek et al. (2019), and finance Woerner and Egger (2019); Rebentrost et al. (2018); Martin et al. ; Orus et al. (2019). Recently, it has been shown how the Quantum Amplitude Estimation (QAE) algorithm can be used to analyze financial risk measures Woerner and Egger (2019) or to price financial derivatives Stamatopoulos et al. with a quadratic speedup.

In Section II, we formally define the economic capital requirement as well as the two different uncertainty models considered. In Section III, we build on previous work Woerner and Egger (2019) and discuss how to implement the quantum algorithms on a gate based quantum computer. In Section IV, we show simulation results for small instances of the considered models. Section V analyzes the scaling of the algorithm for problems of realistic size as well as the resulting quantum advantage.

II Credit Risk Analysis

ECR summarizes in a single figure the amount of capital (or own funds) required to remain solvent at a given confidence level (usually linked to the risk appetite or target solvency rating) and a time horizon (usually one year). It is a complementary metric to the regulatory capital requirements that refers to the amount of own funds required following regulatory criteria and rules Basel Committee on Banking Supervision (2010). In this paper, we consider only the ECR related to default risk, which is the loss that occurs when an obligor does not fulfill the repayment of a loan. The main components of an ECR model for a portfolio of assets are the single-asset default probabilities, the loss given default, and the correlation among the single-asset default events. In the following, we first introduce a general form of the credit risk analysis problem considered in this manuscript and then define concrete models in detail.

For a portfolio of $K$ assets the multivariate random variable $(L_{1},...,L_{K})\in\mathbb{R}_{\geq 0}^{K}$ denotes each possible loss associated to each asset. The expected value of the total loss $\mathcal{L}=\sum_{k=1}^{K}L_{k}$ is $\mathbb{E}[\mathcal{L}]=\sum_{k=1}^{K}\mathbb{E}[L_{k}]$. The Value at Risk (VaR) for a given confidence level $\alpha\in[0,1]$ is defined as the smallest total loss that still has a probability greater than or equal to $\alpha$, i.e.,

[TABLE]

The ECR at confidence level $\alpha$ is thus defined as

[TABLE]

Common values of $\alpha$ for ECR found in the finance industry are around $99.9\%$.

In a first model, we assume that all losses are independent and can be expressed as $L_{k}=\lambda_{k}X_{k}$ where $\lambda_{k}>0$ is the loss given default (LGD) and $X_{k}\in\{0,1\}$ is a corresponding Bernoulli random variable. The probability that $X_{k}=1$, i.e., a loss for asset $k$, is $p_{k}$. The expected loss of the portfolio $\mathbb{E}[\mathcal{L}]=\sum_{k=1}^{K}\lambda_{k}p_{k}$ is easier to evaluate than $\text{VaR}_{\alpha}[\mathcal{L}]$, which usually requires a Monte Carlo simulation.

We extend this simple uncertainty model to a more realistic one, where the defaults $X_{k}$ are no longer independent but follow a conditional independence scheme Rutkowski and Tarca (2015). Given a realization $z$ of a latent random variable $\mathcal{Z}$, the Bernoulli random variables $X_{k}\mid\mathcal{Z}=z$ are assumed independent, but their default probabilities $p_{k}$ depend on $z$. We follow Rutkowski and Tarca (2015) and assume that $\mathcal{Z}$ follows a standard normal distribution and that

[TABLE]

where $p_{k}^{0}$ denotes the default probability for $z=0$, $F$ is the cumulative distribution function (CDF) of the standard normal distribution, and $\rho_{k}\in[0,1)$ determines the sensitivity of $X_{k}$ to $\mathcal{Z}$. This scheme is similar to the one used for regulatory purposes in the Basel II (and following) Internal Ratings-Based (IRB) approach to credit risk Basel Committee on Banking Supervision (2006, 2009), and is called the Gaussian conditional independence model Rutkowski and Tarca (2015).

In order to scale the model to a larger number of assets, one can aggregate subsets of similar assets into random variables $L_{k}\geq 0$ that take more than two values. We briefly discuss this approach and the overall scaling of our algorithm to real world problems in Section V.

In the following sections, we show how the ECR for the presented model can be estimated on a gate-based quantum computer with QAE resulting in a quadratic speedup over classical Monte Carlo simulations.

III Quantum Algorithm

For the models introduced in Section II, the expected total loss $\mathbb{E}[\mathcal{L}]$ can be efficiently computed classically, see Appendix A. Thus, we focus on quantum algorithms to estimate $\text{VaR}_{\alpha}[\mathcal{L}]$. For more details on the estimation of expected values using QAE we refer to Woerner and Egger (2019).

To apply QAE, we map the problem of interest to a quantum operator $\mathcal{A}$ acting on $n+1$ qubits such that:

[TABLE]

where $a\in[0,1]$. The probability to measure $\ket{1}$ in the last qubit, i.e., $a$, corresponds to the (normalized) property of interest. From $\mathcal{A}$ we construct a quantum operator

[TABLE]

where $S_{0}=\mathbb{I}-2\ket{0}_{n+1}\bra{0}_{n+1}$ and $\mathcal{S}_{\psi_{0}}=\mathbb{I}-2\ket{\psi_{0}}_{n}\ket{0}\bra{\psi_{0}}_{n}\bra{0}$. Every application of $\mathcal{Q}$ corresponds to one quantum sample. QAE allows us to estimate $a$ with an estimation error that is bounded by

[TABLE]

where $M$ corresponds to the number of quantum samples Brassard et al. (2002); Woerner and Egger (2019). QAE has a success probability of $81\%$, thus, by repeating only a few times and taking the median result the algorithm succeeds almost with certainty. This leads to a quadratic speedup over classical Monte Carlo simulations, where the estimation error behaves as $\mathcal{O}(1/\sqrt{M})$, where $M$ now denotes the number of classical samples. A more detailed discussion of QAE can be found in Appendix B.

To estimate VaR, we use QAE to efficiently evaluate the CDF of the total loss, i.e., we will construct $\mathcal{A}$ such that $a=\mathbb{P}[\mathcal{L}\leq x]$ for a given $x\geq 0$, and apply a bisection search to find the smallest $x_{\alpha}\geq 0$ such that $\mathbb{P}[\mathcal{L}\leq x_{\alpha}]\geq\alpha$, which implies $x_{\alpha}=\text{VaR}_{\alpha}[\mathcal{L}]$ Woerner and Egger (2019).

Mapping the CDF of the total loss to a quantum operator $\mathcal{A}$ requires three steps. Each step corresponds to a quantum operator. First, $\mathcal{U}$ loads the uncertainty model. Second, $\mathcal{S}$ computes the total loss into a quantum register with $n_{S}$ qubits. Last, $\mathcal{C}$ flips a target qubit if the total loss is less than or equal to a given level $x$ which is used to search for $\text{VaR}_{\alpha}$. Thus, we have $\mathcal{A}=\mathcal{CSU}$ and Fig. 1 illustrates the corresponding circuit on a high level.

The estimation error given in Eq. (6) also depends on the exact result $a$. In particular, if $a$ is close to [math] or $1$ the constant in the error bound becomes very small. When computing $\text{VaR}_{\alpha}$, we want to find the minimal threshold such that the estimated probability is larger than or equal to $\alpha$. Thus, we can replace $a$ in Eq. (6) by $\alpha$ to get a better error bound. When $\alpha=99.9\%$ the error bound is approximately

[TABLE]

which is independent of the other properties of the problem. In other words, QAE is particularly good at estimating tail probabilities of distributions.

We now discuss the operators $\mathcal{U}$, $\mathcal{S}$, and $\mathcal{C}$ in more detail. When the default events $\{X_{1},...,X_{K}\}$ are uncorrelated we can encode the $X_{k}$ of each asset in the state of a corresponding qubit by applying to qubit $k$ a $Y$-rotation $R_{Y}(\theta_{p}^{k})$ Nielsen and Chuang (2010) with angle $\theta_{p}^{k}=2\arcsin(\sqrt{p_{k}})$. Therefore the loading operator is

[TABLE]

This prepares qubit $k$ in the state $\sqrt{1-p_{k}}\ket{0}+\sqrt{p_{k}}\ket{1}$ for which the probability to measure $\ket{1}$ is $p_{k}$. The $\ket{1}$ state of qubit $k$ thus corresponds to a loss for asset $k$.

To adjust $\mathcal{U}$ to include correlations between the default events, we add another register with $n_{Z}$ qubits to represent $\mathcal{Z}$. The random variable $\mathcal{Z}$ follows a standard normal distribution. We use a truncated and discretized approximation with $2^{n_{Z}}$ values, where we consider an affine mapping $z_{i}=a_{z}i+b_{z}$ from $i\in\{0,...,2^{n_{Z}}-1\}$ to the desired range of values of $\mathcal{Z}$. Any discretized and truncated log-concave distribution, such as $\mathcal{Z}$, can be efficiently represented in a quantum register by an operator $\mathcal{U}_{Z}$ built from controlled rotations Grover and Rudolph (2002). The qubit register representing $\mathcal{Z}$ is then used to control the rotation angles $\theta_{p}^{k}(z)=2\arcsin(\sqrt{p_{k}(z)})$ that prepare the qubits representing the $X_{k}$. For simplicity, we use a first order approximation of $\theta_{p}^{k}(z)$ and include the affine mapping from $z$ (a value of the normal distribution) to $i$ (an integer represented by $n_{Z}$ qubits), i.e., $\theta_{p}^{k}(z_{i})\approx a_{k}i+b_{k}$. This affine dependency of the rotation angles $\theta_{p}^{k}$ with respect to $\mathcal{Z}$ can be constructed with a controlled rotation, see Fig. 2. Higher order approximations of $\theta_{p}^{k}(z)$ can be implemented using multi-controlled rotations. Furthermore, by using quantum arithmetic one could also compute $\theta_{p}^{k}(Y)$ directly (Woerner and Egger, 2019).

The ability to efficiently construct the uncertainty model is a crucial part in QAE-based algorithms, and if not handled carefully can diminish the potential quantum advantage. The previous discussion shows that the Gaussian conditional independence model is particularly suitable for efficient loading in a quantum computer. However, the depth of the circuit implementing $\mathcal{U}$, shown in Fig. 2, scales as $\mathcal{O}(n_{z}K)$, i.e. linear in the number of assets. By adding $\mathcal{O}(K)$ ancilla qubits, the scaling of the circuit depth can be reduced to $\mathcal{O}(\log{K})$, which can lead to a potential speed-up. The additional qubits provide the compute space to perform more operations in parallel. Depending on the number of available qubits and the complexity of the rest of the algorithm, the number of ancillas can also be set to a smaller value to achieve an optimal overall performance. The efficient implementation of $\mathcal{U}$ is discussed in detail in Sec. V.

Next, we need to compute the resulting total loss for every realization of the $X_{k}$. Therefore, we use a weighted sum operator

[TABLE]

where $x_{k}\in\{0,1\}$ denote the possible realizations of $X_{k}$. We set $n_{S}=\lfloor\log_{2}(\lambda_{1}+\cdots+\lambda_{K})\rfloor+1$ to represent in the second register all possible values of the sum of the losses given default $\lambda_{k}$, assumed to be integers. An efficient implementation of $S$ is discussed in Sec. V.

Last, we need an operator that compares a particular loss realization to a given $x$ and then flips a target qubit from $\ket{0}$ to $\ket{1}$ if the loss is less than or equal to $x$. This operator is defined by

[TABLE]

An efficient implementation of $\mathcal{C}$ is discussed in Sec. V.

In the remainder of this paper we apply this algorithm to a small illustrative example using classical simulations of a quantum computer and we discuss the scaling to problems of realistic size.

IV Results

In this section, we analyze the performance of the quantum algorithm for an illustrative example with $K=2$ assets. The losses given default $\lambda_{k}$, the default probabilities $p_{k}^{0}$, and the sensitivities $\rho_{k}$ are given in Tab. 1. Within this section we set $n_{Z}=2$, and from the $\lambda_{k}$ it follows that $n_{S}=2$. Thus, $\mathcal{A}$ is operating on seven qubits that represent this problem on a quantum computer, including the objective qubit.

To simulate our algorithm we input the circuit for $\mathcal{A}$ to the QAE sub-routine implemented in Qiskit Aleksandrowicz et al. (2019) and perform the bisection search using the result to find $x_{\alpha}$. Since $n_{S}=2$, the bisection search requires at most two steps, as shown in Fig. 3. Note that QAE requires one additional ancilla qubit to implement $\mathcal{Q}$ and we use four evaluation qubits giving us 16 quantum samples. In total, this experiment requires 12 qubits that we simulate using classical computers.

V Scaling to real world problem

We analyze the scaling of the quantum algorithm for problem sizes relevant to the finance industry. In particular, we analyze the circuit depth as a function of the number of assets $K$, to estimate the expected runtime on a fault-tolerant quantum computer Shor (1996); Kitaev (2003); Fowler et al. (2012). We consider a gate decomposition into the Clifford + T gate set and mainly focus on the circuit depth in terms of T-gates, since they are the most expensive gates in a fault-tolerant quantum computer Bravyi and Haah (2012). By using ancilla qubits, Toffoli gates can be constructed with a T-depth of one Selinger (2013), thus, we treat the two as equivalent in our runtime analysis. Clifford gates, such as for instance CNOT-gates, are considered to be orders of magnitudes faster than T-gates and we mostly ignore them in the following Fowler et al. (2012); Fowler and Gidney (2018).

Our algorithm mainly consists of $\mathcal{A}$, multiple applications of (controlled) $\mathcal{Q}$, and an inverse quantum Fourier transform (QFT) at the end. The complexity of the inverse QFT scales at most quadratically with the number of evaluation qubits $m$, and is orders of magnitude smaller than the rest of the algorithm, since we assume $K\gg m$ and since the inverse QFT is only applied once. Furthermore, the inverse QFT can even be approximated using $\mathcal{O}(n\log(n))$ T-gates Nam et al. (2018), and, as discussed later in this section, it has been recently shown that Quantum Phase Estimation (QPE, includes the inverse QFT) can be omitted completely in QAE Suzuki et al. (2019). Therefore, we ignore the contribution of the inverse QFT to the overall runtime.

Since the controlled powers of $\mathcal{Q}$ will dominate the runtime, we focus on the T/Toffoli-gates in $\mathcal{Q}$. Eq. (5) implies that the controlled-$\mathcal{Q}$ operator in QAE requires controlling only the reflections $\mathcal{S}_{0}$ and $\mathcal{S}_{\psi_{0}}$. Indeed, $\mathcal{A}$ and $\mathcal{A}^{\dagger}$ are left uncontrolled and cancel each other when the control qubit of $\mathcal{Q}$ is in state $\ket{0}$, since in this case $\mathcal{S}_{0}$ is not applied.

We now argue that $\mathcal{S}_{0}$ and $\mathcal{S}_{\psi_{0}}$ do not dominate the runtime. The reflection $\mathcal{S}_{\psi_{0}}$ can be implemented using an ancilla qubit and a phase kickback: an X-gate prepares the ancilla qubit in state $\ket{1}$, then the objective qubit of $\mathcal{A}$ is used to control a Z-gate targeting the ancilla qubit, a final X-gate uncomputes the ancilla qubit. This gate sequence transforms the objective qubit of $\mathcal{A}$ from $\alpha\ket{0}+\beta\ket{1}$ to $\alpha\ket{0}-\beta\ket{1}$ Nielsen and Chuang (2010) which is equivalent to the action of $\mathcal{S}_{\psi_{0}}$. For a controlled application of $\mathcal{S}_{\psi_{0}}$ we replace the single-controlled Z-gate by a double-controlled Z-gate where the second control is an evaluation qubit. Thus, $\mathcal{S}_{\psi_{0}}$ can be ignored in the overall runtime analysis as it can be implemented using a single Toffoli-gate (within the double-controlled Z-gate, exploiting that $Z=HXH$).

We implement $\mathcal{S}_{0}$ using the same construction as for $\mathcal{S}_{\psi_{0}}$ but with the single-controlled Z-gate replaced by a multi-controlled Z-gate that only acts if all qubits $\mathcal{A}$ operates on are in state $\ket{0}$. However, if the sum-register is in state $\ket{0}_{n_{S}}$ then the $K$ qubits representing the $X_{k}$’s are also in state $\ket{0}_{K}$ and vice versa, since $\lambda_{k}>0$ for all $k$. Thus, instead of controlling the Z-gate with all state qubits, we only need to control it by the $n_{Z}$ qubits representing $\mathcal{Z}$, the $n_{S}$ qubits representing the total loss, and the objective qubit of $\mathcal{A}$. Since multi-controlled gates can be implemented with logarithmic depth and a linear number of ancillas Maslov (2016); Motzoi et al. (2017), we can also ignore the contribution of (controlled) $\mathcal{S}_{0}$ to the total runtime.

The previous discussion in this section implies that the multiple applications of $\mathcal{A}$ dominate the total runtime. For $m$ evaluation qubits, $\mathcal{A}$ is called $n_{S}(2^{m+1}-1)$ times: once for the initial state preparation, twice for each of the $2^{m}-1$ applications of $\mathcal{Q}$, and everything is repeated at most $n_{S}$ times for the bisection search to estimate VaR.

Since QAE is a probabilistic algorithm, we need to run it multiple times. However, 25 repetitions are already sufficient to achieve a success probability of $99.75\%$ when using the median result Woerner and Egger (2019). These are independent repetitions that could be parallelized on multiple separate quantum computers, thus, we do not include this additional overhead.

In the following, we analyze the circuit depth of $\mathcal{A}$. How to efficiently implement the operators $\mathcal{U}$, $\mathcal{S}$, and $\mathcal{C}$ and the assumptions made, e.g., on approximation errors, is discussed in Appendices C, D, and E, respectively. The resulting circuit depths in terms of T/Toffoli-gates is stated in Table 2.

The total number of qubits will scale like $\mathcal{O}(K)$, since we represent every asset with a single qubit and the required ancillas also scale linearly in $K$. We are mainly interested in an estimation of the overall runtime, and thus, we will not further elaborate on the exact number of required qubits.

In the remainder of this section, we consider $K=2^{20}$, i.e., a portfolio of about one million assets, and assume $n_{Z}=10$, and $n_{S}=30$. This implies that we discretize $\mathcal{Z}$ with $1,024$ different values, and that we assume the average of $\lambda_{k}$ is at most $1,024=2^{n_{S}}/K$, otherwise $n_{S}$ would be too small to represent the maximal possible sum of losses. Furthermore, we assume $m=10$, which achieves an accuracy of $0.06\%$-points for $\alpha=99.9\%$.

Inserting these numbers into the formulas in Table 2 leads to a T/Toffoli-depth for $\mathcal{A}$ of about $N_{\text{T}}^{\mathcal{A}}=600$. For the overall QAE, this implies a depth of

[TABLE]

which evaluates to a T/Toffoli-depth of approximately 37 million gates.

Up to now, we have not considered the impact of the limited connectivity of quantum processors, i.e., the fact that we need to introduce SWAP-gates to realize CNOT-gates or Toffoli-gates between qubits that are not physically connected. It has been empirically shown in Woerner and Egger (2019) for a related application that mapping comparable circuits to a realistic topology led to an increase in the number of CNOT-gates of about a factor of two. Since the runtime is dominated by the time for the T-gates, doubling the number of CNOT gates in our circuit should not significantly affect the overall runtime. We therefore ignore the impact of limited connectivity. Additionally, compiling the quantum circuits can be done in advance to produce a template circuit usable for a concrete problem. Thus, the actual compilation time and circuit-optimization time is not added in our analysis.

We now assume that error-corrected T/Toffoli-gates can be executed in $10^{-4}$ seconds Fowler and Gidney (2018). With this clock rate the 37 million gates obtained from Eq. (11) result in an estimated overall runtime of around one hour. Removing the QPE from QAE not only allows to remove the inverse QFT but also reduces the overall circuit depth by a factor of two by allowing us to parallelize on two quantum devices Suzuki et al. (2019). This results in an estimated runtime of 30 minutes to estimate the VaR for a one-million-asset portfolio.

Classical simulations of large portfolios are a big computation problem which requires significant time and hardware resources Lan et al. (2010); Desmettre et al. (2016); Stockinger et al. (2018). To reduce classical simulation times, approximations are used and similar assets are aggregated in batches described by more complex random distributions. The same methods can also be applied to our quantum algorithm and should be able to achieve similar improvements, potentially reducing the expected runtime of 30 minutes for one million assets to near real-time. Furthermore, aggregating similar assets can also help to reduce the required number of qubits.

Unlike for classical algorithms, estimating the Conditional Value at Risk (CVaR, or Expected Shortfall) can be achieved without much additional overhead, since it is just one additional (slightly more expensive) application of QAE without the bisection search Woerner and Egger (2019).

VI Conclusion

In this paper we developed and analyzed a quantum algorithm to estimate ECR with a quadratic speedup. We have demonstrated the algorithm using a simulation and analyzed the scaling and expected runtime for realistic problem sizes under reasonable assumptions on future quantum computers. Furthermore, we argued that our results also hold for more complex uncertainty models or other objectives, such as CVaR, without much additional overhead. Although there is still a long way to go in terms of hardware development, this implies a huge potential for quantum computing in credit risk analysis. Further research in algorithms can help to reduce the number of required qubits as well as the gate depth.

Within this paper, we made assumptions on the performance of future quantum hardware. We tried to make our analysis as transparent as possible to allow adjustments of our results in case of new insights on future hardware or algorithmic components. Until quantum computers of the required scale are available, a lot of research needs to take place also with focus on quantum algorithms, error correction, and circuit optimization. Thus, it would not be surprising, if our assumption will turnout to be conservative, implying an even larger potential for the technology, than outlined in the present manuscript.

Acknowledgements.

The authors want to thank Joan Francesc Vidal Villalón and Santiago Murillo Pavas from CaixaBank for the inspiring discussion on this important use cases, and James Wootton as well as Dmitri Maslov for their valuable insights on quantum error-correction and gate decomposition.

Appendix A Expected Total Loss

In the following, we show how the total loss introduced in Section II can be efficiently computed classically. For the first model in which the default events are independent the expected total loss is given by

[TABLE]

This is due to the linearity of the expected value and the independence of the random variables $X_{k}$.

For the second model, we exploit the conditional independence assumption, which allows us to compute the expected loss as

[TABLE]

where $f$ denotes the probability density function of the standard normal distribution. This term can be efficiently approximated classically using numerical integration.

Appendix B Amplitude Estimation

The advantage for credit risk analysis comes from the quantum amplitude estimation (QAE) algorithm Brassard et al. (2002), which provides a quadratic speed-up over classical Monte-Carlo simulations Abrams and Williams (1999); Montanaro (2015); Woerner and Egger (2019); Stamatopoulos et al. . Suppose a unitary operator $\mathcal{A}$ as defined in Eq. (4). QAE allows the efficient estimation of $a$, i.e., the probability of measuring $\ket{1}$ in the last qubit. This estimation is obtained with an operator $Q$, given in Eq. (5), and Quantum Phase Estimation (Kitaev, 1995). QAE requires $m$ additional evaluation qubits and $M=2^{m}-1$ applications of $Q$. The $m$ qubits, initialized to an equal superposition state by Hadamard gates, are used to control different powers of $Q$. After applying the inverse Quantum Fourier Transform, their state is measured resulting in an integer $y\in\{0,...,M-1\}$, which is classically mapped to the estimator $\tilde{a}=\sin^{2}(y\pi/M)\in[0,1]$, see the circuit in Fig. 4. The estimator $\tilde{a}$ satisfies the error bound provided in Eq. (6) with probability of at least $8/\pi^{2}$. This represents a quadratic speedup compared to the $\mathcal{O}\left(M^{-1/2}\right)$ convergence rate of classical Monte Carlo methods (Glasserman et al., 2000).

Appendix C Uncertainty Model

Every $X_{k}$-qubit needs to be prepared using an uncontrolled Y-rotation as well as $n_{Z}$ controlled Y-rotations. On an error-corrected quantum computer Y-rotations can be realized with a T-depth of about $3\log_{2}(1/\epsilon)-4$ and controlled Y-rotations with a T-depth of about $3\log_{2}(1/\epsilon)-2$, where $\epsilon>0$ is the approximation error of the resulting unitary Amy et al. (2013); Kliuchnikov et al. (2012). Throughout this section we assume $\epsilon=2^{-10}\approx 10^{-3}$, which implies a T-depth of 26 for uncontrolled Y-rotations and a T-depth of 28 for controlled Y-rotations.

A straight-forward implementation of $\mathcal{U}$ would require first $K$ uncontrolled Y-rotations followed by $n_{Z}K$ controlled Y-rotations — from the $n_{Z}$ qubits representing $\mathcal{Z}$ to all $K$ qubits representing the $X_{k}$ — with depth of $K$ controlled Y-rotations, since we can apply $n_{Z}$ rotations in parallel for $K\geq n_{Z}$. In this analysis we ignore the preparation of $\mathcal{U}_{Z}$ as it can be done efficiently Grover and Rudolph (2002) and does not depend on $K$, thus, has a negligible impact if $K\gg n_{Z}$.

A depth of $\mathcal{O}(K)$ is prohibitive for large portfolios due to the required T-gates. To implement $\mathcal{U}$ more efficiently, we duplicate the $\mathcal{Z}$-qubits $(w-1)$-times, i.e., in total we have $w$ entangled copies of the $n_{Z}$ qubits representing $\mathcal{Z}$. This requires $n_{Z}(w-1)$ ancilla qubits and $2n_{Z}w$ CNOT-gates, with a resulting CNOT-depth of $2\log_{2}(w)$, since every entangled copy can be reused to prepare more copies. The factor $2$ appears since we should uncompute this preparation at the end. Having $w$ copies of $\mathcal{Z}$ allows us to parallelize the preparation of the $X_{k}$-qubits, achieving a depth of $n_{Z}K/w$ controlled Y-rotations. To minimize the T-depth, we set $w=K$, i.e., we add $n_{Z}(K-1)$ entangled copies with a CNOT-depth of $\log_{2}(K)$, leading to a Y-rotation-depth of $n_{Z}$, independent of $K$. Combining this with the T-depth for Y-rotations leads to total T-depth for $\mathcal{U}$ of $26+28n_{Z}$.

Appendix D Weighted Sum Operator

Next, we analyze the implementation of $\mathcal{S}$. Again, we can significantly reduce the circuit depth using additional ancilla qubits. We apply a divide and conquer approach and first sum up pairs of assets, then pairs of the resulting sums and so on until we computed the total sum.

This implies that we start with a weighted-sum operator as outlined in Sec. III and also introduced and discussed in detail in Stamatopoulos et al. , and then continue with adder circuits Cuccaro et al. (2004) to iteratively combine the intermediate results.

For simplicity, we consider average values in the following analysis of the circuit depth. Since we have $K$ assets and assume the total loss can always be represented with $n_{S}$ qubits, the loss per asset can be represented using on average at most $\log_{2}(2^{n_{S}}/K)=n_{S}-\log_{2}(K)$ qubits. On average, the intermediate values at most double from one iteration to the next, i.e. we need to add at most one qubit per iteration to each intermediate result and after $\log_{2}(K)$ iterations we have computed the total loss.

Within every iteration, we assume that the individual intermediate results can be computed in parallel. For iteration $i$, $i=0,\ldots,\log_{2}(K)-1$, we assume the values are represented each by $n_{i}=(n_{S}-\log_{2}(K)+i)$ qubits. An adder circuit on $n$ qubits can be realized with a Toffoli-depth of

[TABLE]

using a linear number of ancilla qubits Draper et al. (2006). Thus, we can bound the overall Toffoli-depth by

[TABLE]

Appendix E Fixed Value Comparator

A fixed value comparator, i.e., a comparator that takes a fixed value to compare to as a classical input, can be based on adder circuits. The result reported in Table 2, i.e., a Toffoli-depth of $2\log_{2}(n_{S}-1)+9$, is taken from Draper et al. (2006) where a construction of adders and comparators is introduced and analyzed in detail. To achieve the logarithmic scaling, a linear number of ancilla qubits needs to be added.