Quantum Generative Adversarial Networks for Learning and Loading Random Distributions

TL;DR

This paper introduces a hybrid quantum-classical approach using quantum GANs to efficiently load and learn probability distributions into quantum states, enabling more practical quantum algorithms for data-driven tasks.

Contribution

It presents a novel method combining quantum GANs with classical neural networks for approximate, efficient quantum state loading of distributions, reducing complexity from exponential to polynomial.

Findings

qGANs successfully learn distributions from data samples

The method reduces state loading complexity to polynomial gates

Demonstrated application in quantum finance simulations

Abstract

Quantum algorithms have the potential to outperform their classical counterparts in a variety of tasks. The realization of the advantage often requires the ability to load classical data efficiently into quantum states. However, the best known methods require $\mathcal{O}\left(2^n\right)$ gates to load an exact representation of a generic data structure into an $n$-qubit state. This scaling can easily predominate the complexity of a quantum algorithm and, thereby, impair potential quantum advantage. Our work presents a hybrid quantum-classical algorithm for efficient, approximate quantum state loading. More precisely, we use quantum Generative Adversarial Networks (qGANs) to facilitate efficient learning and loading of generic probability distributions -- implicitly given by data samples -- into quantum states. Through the interplay of a quantum channel, such as a variational quantum circuit, and a classical neural network, the qGAN can learn a representation of the probability distribution underlying the data samples and load it into a quantum state. The loading requires $\mathcal{O}\left(poly\left(n\right)\right)$ gates and can, thus, enable the use of potentially advantageous quantum algorithms, such as Quantum Amplitude Estimation. We implement the qGAN distribution learning and loading method with Qiskit and test it using a quantum simulation as well as actual quantum processors provided by the IBM Q Experience. Furthermore, we employ quantum simulation to demonstrate the use of the trained quantum channel in a quantum finance application.

Tables

Table 1. Table 1 : Benchmarking the qGAN training for log-normal, triangular and bimodal target distributions, uniform, normal and random initializations, and variational circuits with depth 1 , 2 1 2 1,2 and 3 3 3 . The tests were repeated 10 10 10 times using quantum simulation. The table shows the mean ( μ ) 𝜇 \left(\mu\right) and the standard deviation ( σ ) 𝜎 \left(\sigma\right) of the Kolmogorov-Smirnov statistic ( K ​ S ) 𝐾 𝑆 \left(KS\right) as well as of the relative entropy ( R ​ E ) 𝑅 𝐸 \left(RE\right) between the generator output and the corresponding target distribution. Furthermore, the table shows the number of runs accepted according to the Kolmogorov Smirnov statistic ( n ≤ b ) subscript 𝑛 absent 𝑏 \left(n_{\leq b}\right) with confidence level 95 % percent 95 95\% , i.e., with acceptance bound b = 0.0859 𝑏 0.0859 b=0.0859 .

data	init	$k$	${\mu }_{KS}$	${\sigma }_{KS}$	$n_{\le b}$	${\mu }_{RE}$	${\sigma }_{RE}$
log-normal	uniform	1	0.0522	0.0214	9	0.0454	0.0856
		2	0.0699	0.0204	7	0.0739	0.0510
		3	0.0576	0.0206	9	0.0309	0.0206
	normal	1	0.1301	0.1016	5	0.1379	0.1449
		2	0.1380	0.0347	1	0.1283	0.0716
		3	0.0810	0.0491	7	0.0435	0.0560
	random	1	0.0821	0.0466	7	0.0916	0.0678
		2	0.0780	0.0337	6	0.0639	0.0463
		3	0.0541	0.0174	10	0.0436	0.0456
triangular	uniform	1	0.0880	0.0632	6	0.0624	0.0535
		2	0.0336	0.0174	10	0.0091	0.0042
		3	0.0695	0.1028	9	0.0760	0.1929
	normal	1	0.0288	0.0106	10	0.0038	0.0048
		2	0.0484	0.0424	9	0.0210	0.0315
		3	0.0251	0.0067	10	0.0033	0.0038
	random	1	0.0843	0.0635	7	0.1050	0.1387
		2	0.0538	0.0294	9	0.0387	0.0486
		3	0.0438	0.0163	10	0.0201	0.0194
bimodal	uniform	1	0.1288	0.0259	0	0.3254	0.0146
		2	0.0358	0.0206	10	0.0192	0.0252
		3	0.0278	0.0172	10	0.0127	0.0040
	normal	1	0.0509	0.0162	9	0.3417	0.0031
		2	0.0406	0.0135	10	0.0114	0.0094
		3	0.0374	0.0067	10	0.0018	0.0041
	random	1	0.2432	0.0537	0	0.5813	0.2541
		2	0.0279	0.0078	10	0.0088	0.0060
		3	0.0318	0.0133	10	0.0070	0.0069

Table 2. Table 2 : Kolmogorov-Smirnov statistic for randomly chosen samples from | g θ ⟩ ket subscript 𝑔 𝜃 \ket{g_{\theta}} and from the discretized, truncated log-normal distribution X 𝑋 {X} .

initialization	$D_{KS}$	Accept/Reject
uniform	$0.0369$	Accept
normal	$0.0320$	Accept
random	$0.0560$	Accept

Table 3. Table 3 : Kolmogorov-Smirnov statistic for randomly chosen samples of | g θ ⟩ ket subscript 𝑔 𝜃 \ket{g_{\theta}} trained with a noisy quantum simulation and using the IBM Q Boeblingen device.

initialization	backend	$D_{KS}$	Accept/Reject
random	simulation	$0.0420$	Accept
random	quantum computer	$0.0224$	Accept

Table 4. Table 4 : This table presents a comparison of different approaches to evaluate 𝔼 ⁡ [ max ⁡ { S T − K , 0 } ] 𝔼 subscript 𝑆 𝑇 𝐾 0 \operatorname{\mathbb{E}}\left[\max\{S_{T}-K,0\}\right] : an analytic evaluation of the log-normal model, a Monte Carlo simulation drawing samples from IBM Q Boeblingen, and a classically simulated QAE. Furthermore, the estimates’ 95 % percent 95 95\% confidence intervals are shown.

Approach	Distribution	Payoff ($)	#Samples	CI ($)
Analytic	Log-normal	1.0602	-	-
MC + QC	$|g_{\theta }⟩$	0.9740	1024	$\pm 0.0848$
QAE	$|g_{\theta }⟩$	1.1391	256	$\pm 0.0710$

Equations

$$\begin{array}{r}{L}_G\left(\varphi ,\theta \right)=-{\mathbb{E}}_{z\sim p_{\text{prior}}}\left[\log \left(D_{\varphi }\left(G_{\theta }\left(z\right)\right)\right)\right]\end{array}$$

$$\begin{array}{rl}& L_D\left(\varphi ,\theta \right)=\\ & {\mathbb{E}}_{x\sim p_{\text{real}}}\left[\log D_{\varphi }\left(x\right)\right]+{\mathbb{E}}_{z\sim p_{\text{prior}}}\left[\log \left(1-D_{\varphi }\left(G_{\theta }\left(z\right)\right)\right)\right]\end{array}$$

$$\begin{array}{r}{L}_G\left(\varphi ,\theta \right)=-\frac{1}{m}\sum _{l=1}^m\left[\log \left(D_{\varphi }\left(G_{\theta }\left(z^l\right)\right)\right)\right]\text{, and}\end{array}$$

$$\begin{array}{rl}& L_D\left(D_{\varphi },G_{\theta }\right)=\\ & \frac{1}{m}\sum _{l=1}^m[\log D_{\varphi }\left(x^l\right)+\log \left(1-D_{\varphi }\left(G_{\theta }\left(z^l\right)\right)\right)],\end{array}$$

$$\underset{\theta }{\max }$$

$$\underset{\varphi }{\max }$$

$$G_{\theta }|{\psi }_{\text{in}}⟩=|g_{\theta }⟩=\sum _{j=0}^{2^n-1}\sqrt{p_{\theta }^j}|j⟩,$$

$$\begin{array}{r}{L}_G\left(\varphi ,\theta \right)=-\frac{1}{m}\sum _{l=1}^m\left[\log D_{\varphi }\left(g^l\right)\right],\end{array}$$

$$\begin{array}{rl}& L_D\left(\varphi ,\theta \right)=\\ & \frac{1}{m}\sum _{l=1}^m[\log D_{\varphi }\left(x^l\right)+\log \left(1-D_{\varphi }\left(g^l\right)\right)],\end{array}$$

$$\underset{\zeta }{\min }\sum _i{\Vert p_{\zeta }^i-q^i\Vert }^2.$$

$${\theta }_{\text{lognormal}}=\left[0.3580,1.0903,1.5255,1.3651,1.4932,-0.9092\right],$$

$$\begin{array}{r}{\theta }_{\text{triangular}}=\left[1.5343,1.6183,0.8559,-0.4041,0.4953,1.2238\right]\end{array}$$

$${\theta }_{\text{bimodal}}=\left[0.4683,0.8200,1.4512,1.1875,1.3883,-0.8418\right]$$

$$\begin{array}{rl}|g_{\theta }⟩& =G_{\theta }|{\psi }_{\text{in}}⟩\\ & =\prod _{p=1}^k\left(\underset{q=1}{\overset{n}{⨂}}\left(R_Y\left({\theta }^{q,p}\right)\right)U_{\text{ent}}\right)\underset{q=1}{\overset{n}{⨂}}\left(R_Y\left({\theta }^{q,0}\right)\right)|{\psi }_{\text{in}}⟩\\ & =\sum _{j=0}^{2^n-1}\sqrt{p_{\theta }^j}|j⟩.\end{array}$$

$$\begin{array}{r}{L}_G\left(\varphi ,\theta \right)=-\frac{1}{m}\sum _{l=1}^m\log \left(D_{\varphi }\left(g^l\right)\right),\end{array}$$

$$\begin{array}{r}{L}_G\left(\varphi ,\theta \right)=-\sum _{j=0}^{2^n-1}{p}_{\theta }^j\log \left(D_{\varphi }\left(g^j\right)\right),\end{array}$$

$$p_{\theta }^j=|⟨j⟩g_{\theta }{|}^2.$$

$$\begin{array}{rl}\frac{\partial L_G\left(\varphi ,\theta \right)}{\partial {\theta }^{i,l}}& =-\sum _{j=1}^m\frac{\partial p_{\theta }^j}{\partial {\theta }^{i,l}}\log \left(D_{\varphi }\left(g^j\right)\right).\end{array}$$

$$\begin{array}{r}\frac{\partial p_{\theta }^j}{\partial {\theta }^{i,l}}=\frac{1}{2}\left(p_{{\theta }_{+}^{i,l}}^j-p_{{\theta }_{-}^{i,l}}^j\right),\end{array}$$

$$D_{KS}\left(P||Q\right)=\text{underaccent}x\in Xsup|P\left(X\le x\right)-Q\left(X\le x\right)|.$$

$$D_{KS}\left(P\Vert Q\right)\le \sqrt{\frac{\ln \frac{2}{\alpha }}{s}}=\mathrm{0.0859.}$$

$$D_{RE}\left(P||Q\right)=\sum _{x\in X}P\left(x\right)\log \left(\frac{P\left(x\right)}{Q\left(x\right)}\right).$$

$$\mathcal{A}{|0⟩}^{\otimes n+1}=\sqrt{1-a}|{\psi }_0⟩|0⟩+\sqrt{a}|{\psi }_1⟩|1⟩,$$

$$|i⟩|0⟩\mapsto \{\begin{array}{ll}|i⟩|0⟩& \text{, if}i\le K\\ |i⟩|1⟩& \text{, if}i>K,\end{array}$$

$$\sum _{i=0}^K\sqrt{p_i}|i⟩|0⟩+\sum _{i=K+1}^{2^n-1}\sqrt{p_i}|i⟩|1⟩$$

$$\begin{array}{r}\mathcal{A}{|0⟩}^{\otimes n+1}=\sum _{i=0}^K\sqrt{p_i}|i⟩|0⟩|0⟩+\\ \sum _{i=K+1}^{2^n-1}\sqrt{p_i}|i⟩|1⟩\left(\sqrt{1-f(i)}|0⟩+\sqrt{f(i)}|1⟩\right),\end{array}$$

$$\mathbb{P}[|1⟩]$$

$$=$$

Full text

Our work presents a hybrid quantum-classical algorithm for efficient, approximate quantum state loading. More precisely, we use quantum Generative Adversarial Networks (qGANs) to facilitate efficient learning and loading of generic probability distributions – implicitly given by data samples – into quantum states. Through the interplay of a quantum channel, such as a variational quantum circuit, and a classical neural network, the qGAN can learn a representation of the probability distribution underlying the data samples and load it into a quantum state.

The loading requires $\mathcal{O}\left(poly\left(n\right)\right)$ gates and can, thus, enable the use of potentially advantageous quantum algorithms, such as Quantum Amplitude Estimation.

We implement the qGAN distribution learning and loading method with Qiskit and test it using a quantum simulation as well as actual quantum processors provided by the IBM Q Experience. Furthermore, we employ quantum simulation to demonstrate the use of the trained quantum channel in a quantum finance application.

I Introduction

The realization of many promising quantum algorithms is impeded by the assumption that data can be efficiently loaded into a quantum state Harrow et al. (2009); Lloyd et al. (2013); Nielsen and Chuang (2010); Brassard et al. (2002). However, this may only be achieved for particular but not for generic data structures. In fact, data loading can easily dominate the overall complexity of an otherwise advantageous quantum algorithm Aaronson (2015). In general, data loading relies on the availability of a quantum state preparing channel. But, the exact preparation of a generic state in $n$ qubits requires $\mathcal{O}\left(2^{n}\right)$ gates Grover (2000); Sanders et al. (2019); Plesch and Brukner (2010); Shende et al. (2005). In many cases, this complexity diminishes a potential quantum advantage.

This work discusses the training of an approximate, efficient data loading channel with Quantum Machine Learning for particular data structures. More specifically, we present a feasible learning and loading scheme for generic probability distributions based on a generative model. The scheme utilizes a hybrid quantum-classical implementation of a Generative Adversarial Network (GAN) Goodfellow et al. (2014); Kurach et al. (2018) to train a quantum channel such that it reflects a probability distribution implicitly given by data samples.

In classical machine learning, GANs have proven useful for generative modeling. These algorithms employ two competing neural networks - a generator and a discriminator - which are trained alternately. Replacing either the generator, the discriminator, or both with quantum systems translates the framework to the quantum computing context Lloyd and Weedbrook (2018).

The first theoretic discussion of quantum GANs (qGANs) was followed by demonstrations of qGAN implementations. Some focus on quantum state estimation Paris and Rehacek (2010), i.e. finding a quantum channel whose output is an estimate to a given quantum state Dallaire-Demers and Killoran (2018); Benedetti et al. (2019); Hu et al. (2019). Others exploit qGANs to generate classical data samples in accordance with the training data’s underlying distribution Situ et al. (2018); Romero and Aspuru-Guzik (2019); Zeng et al. (2019).

In contrast, our qGAN implementation learns and loads probability distributions into quantum states. More specificially, the aim of the qGAN is not to produce classical samples in accordance with given classical training data but to train the quantum generator to create a quantum state which represents the data’s underlying probability distribution. The resulting quantum channel, given by the quantum generator, enables efficient loading of an approximated probability distribution into a quantum state. It can be easily prepared and reused as often as needed. Now, applying this qGAN scheme for data loading can facilitate quantum advantage in combination with other algorithms such as Quantum Amplitude Estimation (QAE) Brassard et al. (2002) or the HHL-algorithm Harrow et al. (2009). Notably, QAE and HHL – given a well-conditioned matrix and a suitable classical right-hand-side Aaronson (2015) – are both compatible with approximate state preparation as these algorithms are stable to small errors in the input state, i.e. small deviations in the input only lead to small deviations in the result.

The remainder of this paper is structured as follows. Sec. II explains classical GANs. Then, the qGAN-based distribution learning and loading scheme is introduced and analyzed on different test cases in Sec. III. In Sec. IV, we discuss the exploitation of qGANs to facilitate quantum advantage in financial derivative pricing: First, we discuss the training of the qGAN with data samples drawn from a log-normal distribution and present the results obtained with a quantum simulator and the IBM Q Boeblingen superconducting quantum computer with 20 qubits, both accessible via the IBM Q Experience ibm . Then, the resulting quantum channel is used in combination with QAE to price a European call option. Finally, Sec. V presents the conclusions and a discussion on open questions and additional possible applications of the presented scheme.

II Generative Adversarial Networks

The generative models considered in this work, GANs Goodfellow et al. (2014); Kurach et al. (2018), employ two neural networks - a generator and a discriminator - to learn random distributions that are implicitly given by training data samples.

Originally, GANs have been used in the context of image generation and modification. In contrast to previously used generative models, such as Variational Auto Encoders (VAEs) Kingma and Welling (2014); Burda et al. (2015), GANs managed to generate sharp images and consequently gained popularity in the machine learning community Dumoulin et al. (2017). VAEs and other generative models relying on log-likelihood optimization are prone to generating blurry images. Particularly for multi-modal data, log-likelihood optimization tends to spread the mass of a learned distribution over all modes. GANs, on the other hand, tend to focus the mass on each mode Goodfellow et al. (2014); Metz et al. (2017).

Suppose a classical training data set $X=\set{x^{0},\ldots,x^{s-1}}\subset\mathbb{R}^{k_{out}}$ sampled from an unknown probability distribution $p_{\text{real}}$. Let $G_{\theta}:\mathbb{R}^{k_{in}}\rightarrow\mathbb{R}^{k_{out}}$ and $D_{\phi}:\mathbb{R}^{k_{out}}\rightarrow\{0,1\}$ denote the generator and the discriminator networks, respectively. The corresponding network parameters are given by $\theta\in\mathbb{R}^{k_{g}}$ and $\phi\in\mathbb{R}^{k_{d}}$. The generator $G_{\theta}$ translates samples from a fixed prior distribution $p_{\text{prior}}$ in $\mathbb{R}^{k_{in}}$ into samples which shall be indistinguishable from samples of the real distribution $p_{\text{real}}$ in $\mathbb{R}^{k_{out}}$. The discriminator $D_{\phi}$, on the other hand, tries to distinguish between data from the generator and from training set. The training process is illustrated in Fig. 1.

The optimization objective of classical GANs may be defined in various ways. In this work, we consider the non-saturating loss Fedus et al. (2018) which is also used in the code of the original GAN paper Goodfellow et al. (2014). The generator’s loss function

[TABLE]

aims at maximizing the likelihood that the generator creates samples that are labeled as real data samples. On the other hand, the discriminator’s loss function

[TABLE]

aims at maximizing the likelihood that the discriminator labels training data samples as training data samples and generated data samples as generated data samples.

In practice, the expected values are approximated by batches of size $m$

[TABLE]

[TABLE]

for $x^{l}\in X$ and $z^{l}\sim p_{\text{prior}}$.

Training the GAN is equivalent to searching for a Nash-equilibrium of a two-player game:

[TABLE]

Typically, the optimization of Eq. (5) and Eq. (6) employs alternating update steps for the generator and the discriminator. These alternating steps lead to non-stationary objective functions, i.e. an update of the generator’s (discriminator’s) network parameters also changes the discriminator’s (generator’s) loss function. Common choices to perform the update steps are ADAM Kingma and Ba (2014) and AMSGRAD Reddi et al. (2018), which are adaptive-learning-rate, gradient-based optimizers that use an exponentially decaying average of previous gradients, and are well suited for solving non-stationary objective functions Kingma and Ba (2014).

III qGAN Distribution Learning

Our qGAN implementation uses a quantum generator and a classical discriminator to capture the probability distribution of classical training samples.

Notably, the aim of this approach is to train a data loading quantum channel for generic probability distributions. As discussed in Sec. II, GAN-based learning is explicitly suitable to capture not only uni-modal but also multi-modal distributions, as we will also demonstrate later in this section.

In this setting, a parametrized quantum channel, i.e. the quantum generator, is trained to transform a given $n$-qubit input state $\ket{\psi_{\text{in}}}$ to an $n$-qubit output state

[TABLE]

where $p_{\theta}^{j}$ describe the resulting occurrence probabilities of the basis states $\ket{j}$.

For simplicity, we now assume that the domain of $X$ is $\{0,...,2^{n}-1\}$ and, thus, the existence of a natural mapping between the sample space of the training data and the states that can be represented by the generator. This assumption can be easily relaxed, for instance, by introducing an affine mapping between $\{0,...,2^{n}-1\}$ and an equidistant grid suitable for $X$. In this case, it might be necessary to map points in $X$ to the closest grid point to allow for an efficient training. The number of qubits $n$ determines the distribution loading scheme’s resolution, i.e. the number of discrete values $2^{n}$ that can be represented. During the training, this affine mapping can be applied classically after measuring the quantum state. However, when the resulting quantum channel is used within another quantum algorithm the mapping must be executed as part of the quantum circuit. As was discussed in Woerner and J. Egger (2019), such an affine mapping can be implemented in a gate-based quantum circuit with linearly many gates.

The quantum generator is implemented by a variational form Mcclean et al. (2015), i.e. a parametrized quantum circuit. We consider variational forms consisting of alternating layers of parametrized single-qubit rotations, here Pauli-Y-rotations $\left(R_{Y}\right)$ Nielsen and Chuang (2010), and blocks of two-qubit gates, here controlled-$Z$-gates $\left(CZ\right)$ Nielsen and Chuang (2010), called entanglement blocks $U_{\text{ent}}$. The circuit consists of a first layer of $R_{Y}$ gates, and then $k$ alternating repetitions of $U_{\text{ent}}$ and further layers of $R_{Y}$ gates. The rotation acting on the $i^{\text{th}}$ qubit in the $j^{\text{th}}$ layer is parametrized by $\theta^{i,j}$. Moreover, the parameter $k$ is called the depth of the variational circuit. If such a variational circuit acts on $n$ qubits it uses in total $(k+1)n$ parametrized single-qubit gates and $kn$ two-qubit gates, see Fig. 2 for an illustration. Similarly to increasing the number of layers in deep neural networks Goodfellow et al. (2016), increasing the depth $k$ enables the circuit to represent more complex structures and increases the number of parameters. Another possibility to increase the quantum generator’s ability to represent complex correlations is adding ancilla qubits as this facilitates an isometric instead of a unitary mapping Nielsen and Chuang (2010), see Appendix A for more details.

The rationale behind choosing a variational form with $R_{Y}$ and $CZ$ gates, e.g. in contrast to other Pauli rotations and two-qubit gates, is that for $\theta^{i,j}=0$ the variational form does not have any effect on the state amplitudes but only flips the phases. These phase flips do not perturb the modeled probability distribution which solely depends on the state amplitudes. Thus, if a suitable $\ket{\psi_{\text{in}}}$ can be loaded efficiently, the variational form allows its exploitation.

To train the qGAN, samples are drawn by measuring the output state $\ket{g_{\theta}}$ in the computational basis, where the set of possible measurement outcomes is $\ket{j},\>j\in\set{0,\ldots,2^{n}-1}$. Unlike in the classical case, the sampling does not require a stochastic input but is based on the inherent stochasticity of quantum measurements. Notably, the measurements return classical information, i.e. $p_{j}$ being defined as the measurement frequency of $\ket{j}$.

The scheme can be easily extended to $d$-dimensional distributions by choosing $d$ qubit registers with $n_{i}$ qubits each, for $i=1,\ldots,d$, and constructing a multi-dimensional grid, see Appendix B for an explicit example of a qGAN trained on multivariate data.

A carefully chosen input state $\ket{\psi_{\text{in}}}$ can help to reduce the complexity of the quantum generator and the number of training epochs as well as to avoid local optima in the quantum circuit training. Since the preparation of $\ket{\psi_{\text{in}}}$ should not dominate the overall gate complexity, the input state must be loadable with $\mathcal{O}\left(poly\left(n\right)\right)$ gates. This is feasible, e.g. for efficiently integrable probability distributions, such as log-concave distributions Grover and Rudolph (2002). In practice, statistical analysis of the training data can guide the choice for a suitable $\ket{\psi_{\text{in}}}$ from the family of efficiently loadable distributions, e.g. by matching expected value and variance.

In Sec. III.1, we present a broad simulation study that analyzes the impact of $\ket{\psi_{\text{in}}}$ as well as the circuit depth $k$.

The classical discriminator, a standard neural network consisting of several layers that apply non-linear activation functions, processes the data samples and labels them either as being real or generated.

Notably, the topology of the networks, i.e. number of nodes and layers, needs to be carefully chosen to ensure that the discriminator does not overpower the generator and vice versa.

Given $m$ data samples $g^{l}$ from the quantum generator and $m$ randomly chosen training data samples $x^{l}$, where $l=1,\ldots,m$, the loss functions of the qGAN are

[TABLE]

for the generator, and

[TABLE]

for the discriminator, respectively.

As in the classical case, see Eq. (5) and (6), the loss functions are optimized alternately with respect to the generator’s parameters $\theta$ and the discriminator’s parameters $\phi$.

III.1 Simulation Study

Next, we present the results of a broad simulation study on training qGANs with different settings for different target distributions.

The quantum generator is implemented with Qiskit Abraham et al. (2019) which enables the circuit execution with quantum simulators as well as quantum hardware provided by the IBM Q Experience ibm .

We consider a quantum generator acting on $n=3$ qubits, which can represent $2^{3}=8$ values, namely $\{0,1,\ldots,7\}$. We applied the method for $20,000$ samples of, first, a log-normal distribution with $\mu=1$ and $\sigma=1$, second, a triangular distribution with lower limit $l=0$, upper limit $u=7$ and mode $m=2$, and last, a bimodal distribution consisting of two superimposed Gaussian distributions with $\mu_{1}=0.5$, $\sigma_{1}=1$ and $\mu_{2}=3.5$, $\sigma_{2}=0.5$, respectively. All distributions were truncated to $\left[0,7\right]$ and the samples were rounded to integer values.

The generator’s input state $\ket{\psi_{\text{in}}}$ is prepared according to a discrete uniform distribution, a truncated and discretized normal distribution with $\mu$ and $\sigma$ being empirical estimates of mean and standard deviation of the training data samples, or a randomly chosen initial distribution.

Preparing a uniform distribution on $3$ qubits requires the application of $3$ Hadamard gates, i.e. one per qubit Nielsen and Chuang (2010). Loading a normal distribution involves more advanced techniques, see Appendix C for further details. For both cases, we sample the generator parameters from a uniform distribution on $[-\delta,+\delta]$, for $\delta=10^{-1}$. By construction of the variational form, the resulting distribution will be close to $\ket{\psi_{\text{in}}}$ but slightly perturbed. Adding small random perturbations helps to break symmetries and can, thus, help to improve the training performance Lehtokangas and Saarinen (1998); Thimm and Fiesler (1997); Chen et al. (2019). To create a randomly chosen distribution, we set $\ket{\psi_{\text{in}}}=\ket{0}^{\otimes 3}$ and initialize the parameters of the variational form following a uniform distribution on $[-\pi,\pi]$.

From now on, we refer to these three cases as uniform, normal, and random initialization. . Furthermore, we tested quantum generators with depths $k\in\set{1,2,3}$.

The discriminator, a classical neural network, is implemented with PyTorch pyt . The neural network consists of a $50$-node input layer, a $20$-node hidden-layer and a single-node output layer. First, the input and the hidden layer apply linear transformations followed by Leaky ReLU functions Goodfellow et al. (2014); Pedamonti (2018); He et al. (2015). Then, the output layer implements another linear transformation and applies a sigmoid function. The network should neither be too weak nor too powerful to ensure that neither the generator nor the discriminator overpowers the other network during the training. The used discriminator topology has been chosen based on empirical tests.

The qGAN is trained using AMSGRAD Reddi et al. (2018) with the initial learning rate being $10^{-4}$. Due to the utilization of first and second momentum terms, this is a robust optimization technique for non-stationary objective functions as well as for noisy gradients Kingma and Ba (2014), which makes it particularly suitable for running the algorithm on real quantum hardware. Methods for the analytic computation of the quantum generator loss function’s gradients are discussed in Appendix D. The training stability is improved further by applying a gradient penalty on the discriminator’s loss function Kodali et al. (2017); Roth et al. (2017).

In each training epoch, the training data is shuffled and split into batches of size $2,000$. The generated data samples are created by preparing and measuring the quantum generator $2,000$ times. Then, the batches are used to update the parameters of the discriminator and the generator in an alternating fashion. After the updates are completed for all batches, a new epoch starts.

According to the classical GAN literature, the loss functions do not neccessarily reflect whether the method converges Grnarova et al. (2018). In the context of training a quantum representation of some training data’s underlying random distribution, the Kolmogorov-Smirnov statistic as well as the relative entropy represent suitable measures to evaluate the training performance. Given the null-hypothesis that the probability distribution from $\ket{g_{\theta}}$ is equivalent to the probability distribution underlying $X$, the Kolmogorov-Smirnov statistic $D_{KS}$ determines whether the null-hypothesis is accepted or rejected with a certain confidence level, here set to $95\%$. The relative entropy quantifies the difference between two probability distributions. In the following, we analyze the results using these two statistical measures, which are formally introduced in Appendix E.

For each setting, we repeat the training $10$ times to get a better understanding of the robustness of the results. Table 1 shows aggregated results over all 10 runs and presents the mean $\mu_{KS}$, the standard deviation $\sigma_{KS}$ and the number of accepted runs $n_{\leq b}$ according to the Kolmogorov-Smirnov statistic as well as the mean $\mu_{RE}$ and standard deviation $\sigma_{RE}$ of the relative entropy outcomes between the generator output and the corresponding target distribution. The data shows that increasing the quantum generator depth $k$ usually improves the training outcomes. Furthermore, the table illustrates that a carefully chosen initialization can have favorable effects, as can be seen especially well for the bimodal target distribution with normal initialization. Since the standard deviations are relatively small and the number of accepted results is usually close to 10, at least for depth $k\geq 2$, we conclude that the presented approach is quite robust and applicable also to more complicated distributions. Fig. 3 illustrates the results for one example of each target distributions.

IV Application in Quantum Finance

Now, we demonstrate that training a data loading unitary with qGANs can facilitate financial derivative pricing. More precisely, we employ qGANs to learn and load a model for the spot price of an asset underlying a European call option. We perform the training for different initial states with a quantum simulator, and also execute the learning and loading method for a random initialization on an actual quantum computer, the IBM Q Boeblingen 20 qubit chip. Then, the fair price of the option is estimated by sampling from the resulting distribution, as well as with a QAE algorithm Brassard et al. (2002); Woerner and J. Egger (2019) that uses the quantum generator trained with IBM Q Boeblingen for data loading. A detailed description of the QAE algorithm is given in Appendix F.

The owner of a European call option is permitted, but not obliged, to buy an underlying asset for a given strike price $K$ at a predefined future maturity date $T$, where the asset’s spot price at maturity $S_{T}$ is assumed to be uncertain. If $S_{T}\leq K$, i.e. the spot price is below the strike price, it is unreasonable to exercise the option and there is no payoff. However, if $S_{T}>K$, exercising the option to buy the asset for price $K$ and immediately selling it again for $S_{T}$ can realize a payoff $S_{T}-K$. Thus, the payoff of the option is defined as $\max\{S_{T}-K,0\}$. Now, the goal is to evaluate the expected payoff $\operatorname{\mathbb{E}}\left[\max\{S_{T}-K,0\}\right]$, whereby $S_{T}$ is assumed to follow a particular random distribution. This corresponds to the fair option price before discounting Black and Scholes (1973). Here, the discounting is neglected to simplify the problem.

To demonstrate and verify the applicability of the suggested training method, we implement a small illustrative example that is based on the analytically computable standard model for European option pricing, the Black-Scholes model Black and Scholes (1973). The qGAN algorithm is used to train a corresponding data loading unitary which enables the evaluation of characteristics of this model, such as the expected payoff, with QAE.

It should be noted that the Black-Scholes model often over-simplifies the real circumstances. In more realistic and complex cases, where the spot price follows a more generic stochastic process or where the payoff function has a more complicated structure, options are usually evaluated with Monte Carlo simulations Glasserman (2003). A Monte Carlo simulation uses $N$ random samples drawn from the respective distribution to evaluate an estimate for a characteristic of the distribution, e.g. the expected payoff. The estimation error of this technique behaves like $\epsilon=\mathcal{O}(1/\sqrt{N})$. When using $n$ evaluation qubits to run a QAE, this induces the evaluation of $N=2^{n}$ quantum samples to estimate the respective distribution charactersitic. Now, this quantum algorithm achieves a Grover-type error scaling for option pricing, i.e. $\epsilon=\mathcal{O}(1/N)$ Brassard et al. (2002); Woerner and J. Egger (2019); Rebentrost et al. (2018). To evaluate an option’s expected payoff with QAE, the problem must be encoded into a quantum operator that loads the respective probability distribution and implements the payoff function.

In this work, we demonstrate that this distribution can be loaded approximately by training a qGAN algorithm.

In the remainder of this section, we first illustrate the training of a qGAN using classical quantum simulation. Then, the results from running a qGAN training on actual quantum hardware are presented Finally, we employ the generator trained with a real quantum computer to conduct QAE-based option pricing.

IV.1 QGAN Training

According to the Black-Scholes model Black and Scholes (1973), the spot price at maturity $S_{T}$ for a European call option is log-normally distributed. Thus, we assume that $p_{\text{real}}$, which is typically unknown, is given by a log-normal distribution and generate the training data $X$ by randomly sampling from a log-normal distribution.

As in Sec. III.1, the training data set $X$ is constructed by drawing $20,000$ samples from a log-normal distribution with mean $\mu=1$ and standard deviation $\sigma=1$ truncated to $\left[0,7\right]$, and then, rounding the sampled values to integers, i.e. to the grid that can be natively represented by the generator. We discuss a detailed analysis of training a model for this distribution with a depth $k=1$ quantum generator, which is sufficient for this small example, with different initializations, namely uniform, normal and random. The discriminator and generator network architectures as well as the optimization method are chosen equivalently to the ones described in Sec. III.1.

First, we present results from running the qGAN training with a quantum simulator. The training procedure involves $2,000$ epochs. Fig. 4 shows the progress of the loss functions $L_{D}\left(\phi,\theta\right)$ and $L_{G}\left(\phi,\theta\right)$, as well as, the probability density function (PDF) corresponding to the trained $\ket{g_{\theta}}$ and the target PDF. The PDFs visualize that both uniform and normal initialization perform better than the random initialization.

Fig. 5 shows the progress of the relative entropy and, thereby, illustrates how the generated distributions converge towards the training data’s underlying distribution. This figure also shows that the generator model which is initialized randomly performs worst. Notably, the initial relative entropy for the normal distribution is already small. We conclude that a carefully chosen initialization clearly improves the training, although all three approaches eventually lead to reasonable results.

Table 2 presents the Kolmogorov-Smirnov statistics of the experiments. The results also confirm that initialization impacts the training performance. The statistics for the normal initialization are better than for the uniform initialization, which itself outperforms random initialization. It should be noted that the null-hypothesis is accepted for all settings.

Next, we present the results of the qGAN training run on an actual quantum processor, more precisely, the IBM Q Boeblingen chip ibm . We use the same training data, quantum generator and discriminator as before. To improve the robustness of the training against the noise introduced by the quantum hardware, we set the optimizer’s learning rate to $10^{-3}$. The initialization is chosen according to the random setting because it requires the least gates. Due to the increased learning rate, it is sufficient to run the training for $200$ optimization epochs. For more details on efficient implementation of the generator on IBM Q Boeblingen, see Appendix G.

Equivalent to the simulation, in each epoch, the training data is shuffled and split into batches of size $2,000$. The generated data samples are created by preparing and measuring the quantum generator $2,000$ times. To compute the analytic gradients for the update of $\theta$, we use $8,000$ measurement to achieve suitably accurate gradients.

Fig. 6 presents the PDF corresponding to $\ket{g_{\theta}}$ trained with IBM Q Boeblingen respectively with a classical quantum simulation that models the quantum chip’s noise. To evaluate the training performance, we evaluate again the relative entropy and the Kolmogorov-Smirnov statistic. A comparison of the progress of the loss functions and the relative entropy for a training run with the IBM Q Boeblingen chip and with the noisy quantum simulation is shown in Fig. 7. The plot illustrates that the relative entropy for both, the simulation and the real quantum hardware, converge to values close to zero and, thus, that in both cases $\ket{g_{\theta}}$ evolves towards the random distribution underlying the training data samples.

Again, the Kolmogorov-Smirnov statistic $D_{KS}$ determines whether the null-hypothesis is accepted or rejected with a confidence level of $95\%$. The results presented in Table 3 confirm that we were able to train an appropriate model on the actual quantum hardware.

Notably, some of the more prominent fluctuations might be due to the fact that the IBM Q Boeblingen chip is recalibrated on a daily basis which is, due to the queuing, circuit preparation, and network communication overhead, shorter than the overall training time of the qGAN.

IV.2 European Option Pricing

In the following, we demonstrate that the qGAN based data loading scheme enables the exploitation of potential quantum advantage of algorithms such as QAE by using a generator trained with actual quantum hardware to facilitate European call option pricing. The resulting quantum generator loads a random distribution that approximates the spot price at maturity $S_{T}$. More specifically, we integrate the distribution loading quantum channel into a quantum algorithm based on QAE to evaluate the expected payoff $\operatorname{\mathbb{E}}\left[\max\left\{S_{T}-K,0\right\}\right]$ for K=\2$, illustrated in Fig. 8. Given this efficient, approximate data loading, the algorithm can achieve a quadratic improvement in the error scaling compared to classical Monte Carlo simulation. We refer to Woerner and J. Egger (2019) and to Appendix F for a detailed discussion of derivative pricing with QAE.

The results for estimating $\operatorname{\mathbb{E}}\left[\max\left\{S_{T}-K,0\right\}\right]$ are given in Tab. 4, where we compare

• •

an analytic evaluation with the exact (truncated and discretized) log-normal distribution $p_{\text{real}}$,

• •

a Monte Carlo simulation utilizing $\ket{g_{\theta}}$ trained and generated with the quantum hardware (IBM Q Boeblingen), i.e. $1,024$ random samples of $S_{T}$ are drawn by measuring $\ket{g_{\theta}}$ and used to estimate the expected payoff, and

• •

a classically simulated QAE-based evaluation using $m=8$ evaluation qubits, i.e. $2^{8}=256$ quantum samples, where the probability distribution $\ket{g_{\theta}}$ was trained with IBM Q Boeblingen chip.

The resulting confidence intervals (CI) are shown for a confidence level of $95\%$ for the Monte Carlo simulation as well as the QAE. The CIs are of comparable size, although, because of better scaling, QAE requires only a fourth of the samples. Since the distribution is approximated, both CIs are close to the exact value but do not actually contain it.

Note that the estimates and the CIs of the MC and the QAE evaluation are not subject to the same level of noise effects. This is due to the fact, that the QAE evaluation uses the generator parameters trained with IBM Q Boeblingen but is run with a quantum simulator, whereas the Monte Carlo simulation is solely run on actual quantum hardware. To be able to run QAE on a quantum computer, further improvements are required, e.g. longer coherence times and higher gate fidelities.

V Conclusion and Outlook

We demonstrated the application of an efficient, approximate probability distribution learning and loading scheme based on qGANs that requires $\mathcal{O}\left(poly\left(n\right)\right)$ many gates. In contrast to this, current state-of-the-art techniques for exact loading of generic random distributions into an $n$-qubit state necessitate $\mathcal{O}\left(2^{n}\right)$ gates which can easily predominate a quantum algorithm’s complexity.

The respective quantum channel is implemented by a gate-based quantum algorithm and can, therefore, be directly integrated into other gate-based quantum algorithms. This is explicitly shown by the learning and loading of a model for European call option pricing which is evaluated with a QAE-based algorithm that can achieve a quadratic improvement compared to classical Monte Carlo simulation. Flexibility is given because the model can be fitted to the complexity of the underlying data and the loading scheme’s resolution can be traded off against the complexity of the training data by varying the number of used qubits $n$ and the circuit depth $k$. Moreover, qGANs are compatible with online or incremental learning, i.e. the model can be updated if new training data samples become available. This can lead to a significant reduction of the training time in real-world learning scenarios.

Some questions remain open and may be subject to future research, for example, an analysis of optimal quantum generator and discriminator structures as well as training strategies. Like in classical machine learning, it is neither apriori clear what model structure is the most suitable for a given problem nor what training strategy may achieve the best results.

Furthermore, although barren plateaus McClean et al. (2018) were not observed in our experiments, the possible occurrence of this effect, as well as, counteracting methods should be investigated. Classical ML already offers a large variety of potential solutions, e.g.  the inclusion of noise and momentum terms in the optimization procedure, the simplification of the function landscape by increase of the model size Stanford et al. (2000) or the computation of higher order gradients. Moreover, schemes that were developed in the context of VQE algorithms, such as adaptive initialization Grimsley et al. (2019), could help to circumvent this issue.

Another interesting topic worth investigating considers the representation capabilities of qGANs with other data types. Encoding data into qubit basis states naturally induces a discrete and equidistantly distributed set of represented data values. However, it might be interesting to look into the compatibility of qGANs with continuous or non-equidistantly distributed values.

VI Acknowledgments

We would like to thank Giovanni Mariani for sharing his knowledge and engaging in very helpful discussions.

IBM and IBM Q are trademarks of International Business Machines Corporation, registered in many jurisdictions worldwide. Other product or service names may be trademarks or service marks of IBM or other companies.

VII Code Availability

The code for the qGAN algorithm is publicly available as part of Qiskit Abraham et al. (2019). The algorithm can be found in https://github.com/Qiskit/qiskit-aqua. Tutorials explaining the training and the application in the context of QAE are located at https://github.com/Qiskit/qiskit-iqx-tutorials.

Appendix A Isometric Quantum Generator

Closed quantum systems follow a unitary evolution. The evolution of an open quantum system, i.e. a quantum system that interacts with an environment, evolves according to an isometry instead of a unitary Nielsen and Chuang (2010).

In general, every isometry can be described by a unitary that acts on a larger system. In other words, an isometry is given by a partial trace of a unitary quantum state evolution. The dynamics of an open quantum systems, and, thus, also a quantum generator acting as an isometry, can be implemented with additional ancilla qubits. Depending on the setting, the use of an isometric quantum generator can be advantageous to learn random distributions, as mentioned in Sec. III.

Appendix B Multivariate Historical Data for Portfolio Optimization

The qGAN scheme can also be used to learn and load multivariate random distributions. Here, we present the learning and loading of a distribution underlying the first two principle components of multivariate, constant maturity treasury rates of US government bonds. Note that the trained quantum channel can be used within the discussed QAE algorithm to evaluate, for instance, the fair price of a portfolio of government bonds, see Woerner and J. Egger (2019).

The following results are computed with a quantum simulation. The training data set $X$ consists of more than $5,000$ samples, whereby data samples smaller than the $5\%-$percentile and bigger than the $95\%-$percentile have been discarded to reduce the number of required qubits for a reasonable representation of the distribution. The optimization scheme uses data batches of size $1,200$ and is run for $20,000$ training epochs.

Furthermore, we use depth $k\in\set{2,3,6}$, unitary quantum generators that act on $n=6$ qubits, i.e. $3$ qubits per dimension (principle component). The input state $\ket{\psi_{\text{in}}}$ is prepared as a multivariate uniform distribution and the generator parameters $\theta$ are initialized with random draws from a uniform distribution on the interval $[-\delta,+\delta]$ with $\delta=10^{-1}$.

Here, the classical discriminator is composed of a $512-$ node input layer, a $256-$ node hidden-layer, and a single-node output layer. Equivalently to the discriminator described in Sec. III.1, the hidden layers apply linear transformations followed by Leaky ReLU functions Pedamonti (2018) and the output layer employs a linear transformation followed by a sigmoid function. The evolution of the relative entropy between the generated and the real probability distribution is shown Fig. 9.

Appendix C Practical Initialization of a Normal Distribution

As proven in Grover and Rudolph (2002), a normal distribution can be efficiently loaded into a quantum state. However, the suggested loading method requires the use of involved quantum arithmetic techniques. Considering the illustrative examples from Sec. III.1 and Sec. IV.1, it is sufficient to load an approximate normal distribution as initialization state. This can be achieved by fitting the parameters of a $3$-qubit variational quantum circuit with depth $1$ with a least squares loss function. More specifically, we minimize the distance between the measurement probabilities $p_{\zeta}^{i}$ of the circuit output and the probability density function of a discretized normal distribution $q^{i}$

[TABLE]

The circuit used for training is depicted in Fig. 10. Note that this approach does not scale, particularly not for higher-dimensional distributions. The sole purpose of this approach is to generate shallow testing circuits.

The circuit’s parameters were trained to approximate normal distributions with the mean and the standard deviation of the data samples drawn from each a log-normal distribution with $\mu=1$ and $\sigma=1$,

[TABLE]

a triangular distribution with lower limit $l=0$, upper limit $u=7$ and $\mu=2$,

[TABLE]

and a bimodal distribution consisting of two superimposed Gaussian distributions with $\mu_{1}=0.5$, $\sigma_{1}=1$ respectively $\mu_{2}=3.5$, $\sigma_{2}=0.5$,

[TABLE]

, whereby the least square errors are of the order $10^{-4}$.

Appendix D Analytic Gradients of a Variational Quantum Circuit

Compared to gradient-free optimization, gradient-based optimization methods have the potential to improve convergence rates, e.g. in a convex vicinity of local optima Harrow and Napp (2019). We now discuss a method to calculate analytic gradients Farhi and Neven (2018); Schuld et al. (2018); Mitarai et al. (2018); Zeng et al. (2019); Liu and Wang (2018) for the variational circuit illustrated in Fig. 2.

Applying our $n-$qubit generator to the input state gives

[TABLE]

We measure $\ket{g_{\theta}}\quad m$ times to obtain data samples $g^{l},\>l\in\set{1,\ldots,m}$ which can take $2^{n}$ different values. The generator loss function for a data batch of size $m$ reads

[TABLE]

or equivalently,

[TABLE]

with

[TABLE]

Updating the parameters $\theta$ with gradient based methods requires the evaluation of

[TABLE]

According to Mitarai et al. (2018) Eq. (15) can be evaluated by

[TABLE]

with $\theta_{\pm}^{i,l}=\theta^{i,l}\pm\frac{\pi}{2}e_{i,l}$ and $e_{i,l}$ denoting the $(i,l)$-unit vector of the respective parameter space.

Appendix E Statistical Measures

Two different statistical measures are utilized to evaluate the performance of the qGAN. Both measures are defined as a distance of two (empirical) probability distributions $P$ and $Q$.

The Kolmogorov-Smirnov statistic Chakravarti et al. (1967); Justel et al. (1997) is based on the (empirical) cumulative distribution functions $P\left(X\leq x\right)$ and $Q\left(X\leq x\right)$ and is given by

[TABLE]

The statistic can be used as a goodness-of-fit test. Given the null-hypothesis $P\left(x\right)=Q\left(x\right)$, we draw $s=500$ samples from both distributions and choose a confidence level $(1-\alpha)$ with $\alpha=0.05$. The null-hypothesis is accepted if

[TABLE]

Another measure that can be used to characterize the closeness of (empirical) discrete probability distributions $P\left(x\right)$ and $Q\left(x\right)$ is the relative entropy, also called Kullback-Leibler divergence Nielsen and Chuang (2010); Kullback and Leibler (1951). This entropy-related measure is given by

[TABLE]

The relative entropy represents a non-negative quantity, i.e. $D_{RE}\left(P||Q\right)\geq 0$, where $D_{RE}\left(P||Q\right)=0$ holds if $P\left(x\right)=Q\left(x\right),$ for all values $x$.

Appendix F Quantum Amplitude Estimation

Given a quantum channel

[TABLE]

where $\ket{\psi_{0}}$, $\ket{\psi_{1}}$ denote $n$-qubit states, the QAE algorithm Brassard et al. (2002), illustrated in Fig. 11, enables the efficient evaluation of the amplitude $a$. The algorithm requires $m$ additional evaluation qubits that control the applications of an operator $\mathcal{Q}=-\mathcal{A}\mathcal{S}_{0}\mathcal{A}^{\dagger}\mathcal{S}_{\psi_{0}}$ where $\mathcal{S}_{0}=\mathbb{I}^{\otimes n+1}-2\ket{0}\bra{0}^{\otimes n+1}$ and $\mathcal{S}_{\psi_{0}}=\mathbb{I}^{\otimes n+1}-2\ket{\psi_{0}}\bra{\psi_{0}}\otimes\ket{0}\bra{0}$.

The error in the outcome - ignoring higher terms - can be bounded by $\frac{\pi}{2^{m}}$. Considering that $2^{m}$ is the number of quantum samples used for the estimate evaluation, this error scaling is quadratically better than the classical Monte Carlo simulation.

To use QAE for the pricing of European options, we need to construct and implement a suitable oracle $\mathcal{A}$. First, we load the uncertainty distribution that represents the spot price $S_{T}$ of the underlying asset at the option’s maturity $T$ into a quantum state $\sum_{i=0}^{2^{n}-1}\sqrt{p_{i}}\ket{i}$. It should be noted that small errors in this state preparation only lead to small errors in the final result. Then, we add an ancilla qubit $\ket{0}$ and use a comparator circuit which applies an $X$ gate to the ancilla if $i>K$, i.e.

[TABLE]

where $K$ denotes the strike price. Now, the state reads

[TABLE]

Finally, we control the mapping of the payoff function to the amplitude of another ancilla qubit $\ket{0}$ with the comparison ancilla. This construction implements channel $\mathcal{A}$ and approximates the quantum state

[TABLE]

with $f(i)=\frac{i-K}{2^{n}-K-1}$. For practical reasons, we avoid the involved implementation of the exact linear objective rotation given in Eq. (23) by applying the approximation scheme introduced in Woerner and J. Egger (2019).

Eventually, the probability of measuring $\ket{1}$ in the last ancilla is equal to

[TABLE]

We can see from comparing Eq. (20) and Eq. (23) that $\mathbb{P}[\ket{1}]=a$. It follows that we can use QAE to efficiently evaluate $\mathbb{E}[\max\{0,S_{T}-K\}]=\mathbb{P}[\ket{1}](2^{n}-K-1)$.

Appendix G Hardware Efficient Circuit Implementation

Due to the connectivity layout of the IBM Q Boeblingen chip, shown in Fig. 12, any subset of three qubits - we use qubits 0, 1, 2 - has linear connectivity only. Thus, the implementation of the entanglement block presented in Fig. 2 requires the use of SWAP gates, as shown in Fig. 13(a). The implementation of $CZ\circ SWAP$ with the gate set currently available for IBM Q backends requires the use of $4\;CX$ gates, i.e. $3$ for the $SWAP$ and $1$ for the $CZ$. However, we can reduce the number of required $CX$ gates, see Fig. 13(b). As shown in Vatan and Williams (2004), the action of circuit (a) is equivalent to the action of circuit (b), which only utilizes $2\;CX$ gates. During the training, circuit (b) maps the measurement of $\text{q}_{1}$ ($\text{q}_{2}$) on bit $\text{c}_{2}$ ($\text{c}_{1}$) to compensate for the second $SWAP$ in circuit (a). However, when using the generator circuit for data loading in another algorithm, such as QAE, an actual $SWAP$ gate must be implemented.