Potential Applications of Quantum Computing for the

Insurance Industry
Michael Adam∗
AXA Konzern AG†
arXiv:2210.06172v1 [quant-ph] 10 Oct 2022

October 10, 2022

Abstract
This paper is the documentation of a pre-study performed by AXA Konzern AG in collabo-
ration with Fraunhofer ITWM to assess the relevance of quantum computing for the insurance
industry. Beside a general overview of the status quo of quantum computing technologies, we
investigate its applicability for the valuation of insurance contracts as a concrete use case. This
valuation is a computationally intensive problem because the lack of closed pricing formulas
requires the use of Monte Carlo methods. Therefore current technical capabilities force insurers
to apply approximation methods for many subsequent tasks like economic capital calculation or
optimization of strategic asset allocations. The business-criticality of these tasks combined with
the existence of a quantum algorithm called Amplitude Estimation which promises a quadratic
speed-up of Monte Carlo simulation makes this use case obvious. We provide a detailed explana-
tion of Amplitude Estimation and present two quantum circuits which describe insurance-related
payoff features in a quantum circuit model. An exemplary circuit that encodes dynamic lapse
is evaluated both on a simulator and on real quantum hardware.

∗
michael.adam@axa.de
†
in collaboration with Fraunhofer ITWM

1
CONTENTS

Contents
1 Introduction 3

2 Quantum Computing Basics 5

2.1 A Quantum Bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Evolution of a Quantum System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Measurement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Composite Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Building Blocks of Payoff Valuation on a Quantum Computer 10

3.1 Distribution Loading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.2 Payoff Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Calculation of the Expected Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Amplitude Estimation 14
4.1 Amplitude Estimation based on Phase Estimation . . . . . . . . . . . . . . . . . . . 14
4.2 Amplitude Estimation without Phase Estimation . . . . . . . . . . . . . . . . . . . . 26
4.3 Excursus: Grover’s Quantum Search Algorithm . . . . . . . . . . . . . . . . . . . . . 26

5 Insurance-related Payoffs 27
5.1 General Payoff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.2 Specifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

6 Insurance-related Quantum Circuits 29

6.1 Whole life insurance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.2 Dynamic Lapse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

7 Quantum Hardware Results 33

7.1 Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
7.2 Real Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

8 An Overview of current Quantum Computing Technology 38

8.1 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
8.2 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

9 Conclusion 41

2
1 INTRODUCTION

1 Introduction
Quantum computers work fundamentally different than classical computers. By leveraging the
laws of quantum mechanics, they promise significant speed-ups for certain problems. The areas of
potential applications are versatile and include i.a. cryptography, machine learning and simulation.
This opens up several possibilities for the insurance industry to benefit from the new technology.

Broadly speaking, quantum computers can help solving computationally intensive problems. When
asking an actuary for a common task with high computational requirements, the valuation of in-
surance contracts is an obvious answer. The most expensive simulation concerns the liabilities of
life and health companies with very long time horizons (40 years and beyond), complex contractual
and legal frameworks, sophisticated customer behavior and interactions with assets (e.g. through
profit participation). Due to the complexity of these ”instruments”, closed-form valuation is not
available and hence Monte Carlo (MC) methods are widely used. But the fact is, that the valuation
of liabilities is essential for many subsequent tasks like calculation of economic capital, stress test
exercises or optimization of strategic asset allocations. Unfortunately, in many cases the current
technical capabilities do not allow full nested simulations. If we for example consider economic
capital, the full probability distribution of profits and losses is needed and hence MC simulations
”within” MC simulations are necessary. Actually that often means that at least 10’000 so called
outer scenarios and additionally not less than 1’000 inner scenarios for each outer are needed. Hence
we easily reach millions of simulations with long time horizons.

In practice there are different approaches to reduce the total number of inner scenarios, in particular
replicating portfolios [2] and least square Monte Carlo [1]. In both approaches a reduced number
of simulations is processes and an ”easy-to-valuate-proxy” is fit to the calculated information. The
obvious drawbacks are (1) potential inaccuracies especially in extreme scenarios (which are often
the most interesting ones), (2) additional work to generate the proxy and (3) additional effort to
analyze the discrepancies. If quantum computing would speed-up the simulation of inner scenarios
so that these proxies become obsolete, the impact on life and health insurers would be enormous:
Besides reducing the effort due to the above-mentioned drawbacks, increasing calculation frequency
could open the door to much more dynamic steering strategies. Import indicators like the Solvency
2 coverage ratio are for example currently calculated only a few times a year and consequently it
is hard to use it for dynamic hedging or optimization purposes.

Recently published quantum algorithms promise a quadratic speed-up for Monte Carlo valuations
of plain vanilla European options [21], basket options [23] as well as path-depended
√ options like
Asian [21] or Barrier options [23]. I.e. the convergence rate increases from 1/ M to 1/M where
M is the number of samples. The underlying idea is Amplitude Estimation [3], where the target
quantity is first encoded to a quantum circuit which is then manipulated so that a subsequent
measurement delivers the desired result with high probability. Despite these promising results,
the implementation of a realistic insurance model on a real hardware quantum computer cannot
be expected in the upcoming years. Both hardware and software development are still in their
infancy and many theoretical results can only be executed in their most basic version. On the
other hand the development progresses and with the launch of IBM’s Q System One in Germany
another milestone was reached in June 2021.

In this documentation, we concentrate on quantum software development in a circuit model. In

particular we implement a payoff representing a whole life insurance and a second one simulating

3
1 INTRODUCTION

stochastic customer behavior linked to interest rates. This is a contribution to the growing library of
quantum circuits that can be used to model financial instruments or specifically insurance contracts.
Before we start the description of the insurance-related circuits, we give a brief introduction to
quantum computing in section 2 followed by a general description of the building blocks needed for
calculating expected values in section 3. Since amplitude estimation (AE) leads to the quadratic
speed-up which is the main motivation for our work, we dedicate an own section to the derivation
of AE (section 4). Then, after a mathematical formulation of the considered payoffs in section 5
we describe the new insurance-related quantum circuits in section 6. In section 7 we show results
from running parts of the dynamics lapse circuit on a simulator and on real quantum hardware.
The paper finishes with a short overview of current quantum computing technology, both for hard-
and software in section 8.

Notation
|ψi , |ϕi , |ρi , |χi , |υi Qubit register in arbitrary superposition
m, n, r, s Size of qubit registers. Corresponding number of basis states is denoted
by capital letter, e.g. M = 2m
|ψim Index outside ket gives size of the qubit register in number of qubits.
If size is 1 or not relevant in the current context, the index is usually
omitted.
|ψi i Index inside ket indicates ith qubit in register |ψim . If omitted entire
register is meant.
|ψi imi Index in- and outside ket indicates that |ψim should be interpreted
P as
register of registers, i.e. |ψim = |ψ1 im1 ⊗ · · · ⊗ |ψn imn with mi = m.
Then |ψi imi denotes ith qubit register of |ψim .
|kim , |lim Qubit in k th or lth basis state. k, l ∈ {0, . . . , 2m−1 }
√
αk , ak Qubit Amplitudes
i, ti Usually used as time associated iterators
A, B, . . . Linear operators
H, H ⊗m Single and m-qubit Hadamard operator
ϑ, θ, φ, γ Angles
H(χ, φ) Hyperplane spanned by |χi and its orthogonal space χ⊥ with φ denot-
ing the rotation angle in the complex dimension
λk Eigenvalues
MC Monte Carlo
PE, AE, AA Phase Estimation, Amplitude Estimation, Amplitude Amplification
QF T, QF T −1 Quantum Fourier Transformation and its inverse
V Hilbert Space
PV Present Value
⊕, ∧ xor, and

4
2 QUANTUM COMPUTING BASICS

2 Quantum Computing Basics

We will use the Quantum Circuit Model of Computation. The model is described in a finite-
dimensional complex Hilbert space V . A quantum circuit defines a sequence of operations which is
applied to qubit registers that are initialized to a certain state. A qubit register (also called qubit
system) is a list of qubits.

Before getting in the basics of quantum computing we introduce the useful Dirac Notation. Vectors
are written inside a ”ket” |ki, their dual is denoted with a ”bra” hk|. The scalar product of two
vectors |ki and |li is written as hl|ki. This is why the notation is also called ”bra-ket notation”.
Since the Hilbert space is finite-dimensional, we can choose a fixed basis and enumerate the basis
vectors instead of writing potentially large column vectors. The fixed basis is called computational
basis and can usually be associated with the canonical basis. Let for example C4 be our vector
space V . The computational basis may then be defined as
       

 1 0 0 0 
       
0 , 1 , 0 , 0 .

 0 0 1 0
 
0 0 0 1
 

In Dirac notation we would enumerate the basis vectors, either in decimal or in binary notation,
i.e.
{|0i , |1i , |2i , |3i} or {|00i , |01i , |10i , |11i},
which saves us a lot of writing in case of higher dimensions. The binary notation has the advantage,
that the vectors can also be interpreted as tensor products, for example
 
0
1
|01i = |0i ⊗ |1i = 
0 .


We will often use a subscript to indicate the vector’s size in terms of binary digits, i.e. the dimen-
sion of the vector space spanned by |kim , k = 0, . . . , 2m − 1, is 2m .

In the following sub-sections, we will briefly describe the four postulates of quantum mechanics:
(2.1) The state space postulate, (2.2) the evolution postulate, (2.3) the measurement postulate and
(2.4) the composite systems postulate. We closely follow chapter 3 of [16].

2.1 A Quantum Bit

State Space Postulate
The state of a qubit system is described by a unit vector in a Hilbert space V .
As the smallest unit of computation, the Quantum Bit or Qubit is the quantum analogue of a
bit on a classical computer. While the classical bit always is either in state 0 or 1, the qubit can
be both at the same time. Mathematically, a qubit is a 2-dimensional Hilbert space and all unit
vectors in this space are potential states of the qubit. The state of a qubit |ψi can hence be written
as linear combination of the basis vectors, i.e.

|ψi = α0 |0i + α1 |1i ,

5
2 QUANTUM COMPUTING BASICS

where α0 , α1 ∈ C with |α0 |2 + |α1 |2 = 1 and {|0i , |1i} is an orthonormal basis. These linear combi-
nations are called superpositions. We can already see that the memory capacity of a qubit is much
larger than of a classical bit: To represent the state of qubit we need to store two complex figures
requiring each for example 1 byte = 8 bits, while a classical bit obviously needs 1 bit.

If we can write eiφ |ψi for some φ ∈ R, then φ is called global phase of the qubit. Global phases are
statistically irrelevant, so we can say that eiφ |ψi and |ψi represent the same state.

A convenient and popular illustration of a qubit is the Bloch sphere shown in figure 1. All possible
so called pure states of a single qubit are located on its surface (see section 2.4 for the definition of
pure vs. mixed states). The Bloch sphere representation of a qubit is based on polar coordinates:
   
θ iφ θ
|ψi = cos |0i + e sin |1i .
2 2

For θ = π we arrive at eiφ |1i ≡ |1i and for a whole circle (θ = 2π) we get − |0i ≡ |0i. Hence
dividing θ by 2 is necessary to ensure that 2π corresponds to one full circle. Finally note that the
equally weighted superpositions of the basis states are located on the equator of the Bloch sphere.
z
|0i

|ψi

θ
y
|0i−i|1i φ |0i+i|1i
√ √
2 2

|0i+|1i
√
x 2

|1i

Figure 1: The Bloch sphere is a geometrical illustration of one qubit. All possible pure states of a qubit are
located on its surface. The antipodal points correspond to the orthonormal basis and the equator represents
the equally weighted superpositons between the basis vectors.

2.2 Evolution of a Quantum System

Evolution Postulate
Every evolution of a closed quantum system can be described by a unitary transformation. That
means that given an initial state |ψ0 i and a following state |ψ1 i, there exists a linear operator
U : V → V with UU † = I such that
|ψ1 i = U |ψ0 i .

6
2 QUANTUM COMPUTING BASICS

A linear operator is a linear transformation of a vector space to itself. The dagger (†) denotes
the Hermitian adjoint and I is the identity matrix. Qubits in a closed system do not interact
with qubits outside this system. In a circuit model, the operators are also called gates. Note that
the unitarity of quantum evolution implies that all quantum circuits are reversible. Thus it is not
possible to lose information during a quantum circuit since we can always ”go back” to retrieve a
previous state. Notable examples of quantum gates are:

• Pauli gates are single qubit gates and perform a rotation by π around the x- (Pauli-X), y-
(Pauli-Y) or z-axis (Pauli-Z) of the Bloch sphere. For example Pauli-X is a logical not.

• Square root gates are ”halved” Pauli gates, i.e. they do a quarter-turn in the Bloch sphere.
Common names are S-gate for a rotation around the z-axis and SX-gate for the X-rotation,
while the Y-rotation is rarely used. The square root notation is motivated
√ √ from the fact that
two successive applications deliver the repective Pauli gate, e.g. Z Z |ψi = Z |ψi.

• The Hadamard gate X moves the basis vectors |0i and |1i to the equator of the Bloch sphere:
1
H |0i = √ (|0i + |1i)
2
1
H |1i = √ (|0i − |1i)
2
Hadamard gates play an important role in many quantum algorithms, for example in the
amplitude estimation described below.

• Controlled gates are multi-qubit gates. A controlled U or cU applies the operator U to a

target register if the control qubit is in state |1i and does nothing otherwise:
(
|0i |lim , |ki = |0i
cU |ki |lim =
|1i U |lim , |ki = |1i .

Controlled gates usually entangle the control and the target qubits. The controlled not or
cnot gate is probably the most important example, see section 2.4.

• Multi-controlled gates have more than one control qubit. A multi-controlled operator is
applied to a target register if all control qubits are in state |1i and does nothing otherwise:
(
n |kin |lim , |kin 6= |1 . . . 1in
c U |kin |lim =
|1 . . . 1in U |lim , else.

An important example is the double-controlled not gate, also called ccnot or Toffoli gate.

• The rotation operators Rx (θ), Ry (θ) and Rz (θ) rotate around the Bloch axes x, y and z. They
are generalizations of the Pauli gates.

Note that a linear operator is fully characterized by its action on a basis. Hence it suffices to define
or analyze the operator on the basis states. The general case for an arbitrary superposition then
follows from linearity. Furthermore the matrix representation of an operator is often not needed
explicitly, since the case-by-case definition on the basis vectors is more convenient.

7
2 QUANTUM COMPUTING BASICS

2.3 Measurement
Measurement Postulate
For a given orthonormal basis B = {|ϕk i} and an arbitrary state
X
|ψi = αk |ϕk i , (1)
k

it is possible to perform a measurement with respect to B which outputs label k with probability
|αk |2 and leaves the system in state |ϕk i.
Thus, a superposition only exists until we perform a measurement. After a measurement, a qubit
system is always in a basis state. Let for example |ψi be in an equally weighted superposition of
|0i and |1i. We could say that that the qubit system represents a coin flip with unbiased coin.
Before measurement, the coin is rotating and the state is |0i and |1i. After measurement the state
is |0i or |1i, but we don’t have much information about the probabilities. If we are interested in
the probabilities, we could repeat the experiment several times and use an statistical estimator.

Furthermore note that we get αk = hϕk |ψi by applying the linear transformation hϕk | to both sides
of equation (1) and using the orthonormality. Hence the probability for obtaining result k is the
same given state |ψi or eiφ |ψi, which shows that the global phase eiφ is statistically irrelevant:

|αk |2 = hψ|ϕk i hϕk |ψi . (2)

This equation also shows a connection between projectors and measurement. An operator P is
called projector if P 2 = P. For example P = |ϕk i hϕk | projects a vector to the subspace spanned
by |ϕk i and according to equation (2) it ”extracts” the probability for output k from |ψi. This
statement can be generalized thanks to the Spectral Theorem, which ensures the existence of the
following decomposition for every normal operator U:
X
U= λk |ϕk i hϕk | ,
k

where {|ϕk i} is an orthonormal basis consisting of eigenvectors and {λk } are the corresponding
eigenvalues. Normality (P † P = PP † ) follows from unitarity. Hence the measurement postulate
ensures that the following expression can be evaluated:
X X
hψ| U |ψi = λk hψ|ϕk i hϕk |ψi = λk |αk |2 . (3)
k k

hψ| U |ψi is the expected value of U’s eigenvalues given state |ψi. Finally, this leads us to the
definition of observables: An operator U is called observable, if it is Hermitian (U = U † ). In this
case all eigenvalues of U are real and hence the expected value (3) is real as well. We could say,
that given a qubit system |ψi in a certain state, the observable determines which quantities are
measured.

8
2 QUANTUM COMPUTING BASICS

2.4 Composite Systems

Composite System Postulate
If two qubit systems are combined, the state space of the composite system is the tensor product
of the two corresponding Hilbert spaces. Given a state |ψ0 i from the first and a state |ψ1 i from
the second system, the state in the composite system is

|ψ0 i ⊗ |ψ1 i .
As seen during the introduction of Dirac notation, like for usual products, we often omit the
⊗ symbol and write |ψ0 i |ψ1 i or |ψ0 ψ1 i. When we assemble quantum circuits, we will often add
qubit systems to an existing system. The composite system postulate tells us, that we can extend
existing circuits and that the extended vector spaces are built by tensor products. Operators can
be extended accordingly. If for example, we want to apply an operator U to the first system and
do nothing on the second, we would write:

(U ⊗ I)(|ψ0 i ⊗ |ψ1 i) = U |ψ0 i ⊗ |ψ1 i .

Note that we won’t omit the ⊗ between operators, because UI(|ψ0 i ⊗ |ψ1 i) would suggest that U
and I work each on the composite system.

Beside the ability of having two states at the same time, being entangled with others is the second
important feature of qubits. If two qubits are entangled, they interact with each other. Mathemat-
ically two qubits are entangled, if their state cannot be written as a product. Let for example |ψi2
be in state:
1 1
|ψi2 = cnot(H |0i |0i) = √ |0i |0i + √ |1i |1i , (4)
2 2
where H is a Hadamard gate. Then the state of the first qubit is always equal to the second one.
Hence it suffices to measure the state of one qubit to know the state of the entire system. If we
actually measure the second qubit, the first qubit will be in state |0i or |1i with probability 1/2 each.
Note that this is not a superposition. We have statistical information about the state and repeated
measuring leads to the same result than measuring a qubit in the ”corresponding” superposition.
However, proceeding the circuit is different. Let for example |ψi be in the entangled superposition
(4). If we then measure the second qubit, we denote the state of the first qubit as:
   
1 1
|ψi = |0i , , |1i , . (5)
2 2
Applying a Y-rotation Ry by π/2 the resulting state is
   
1 1
|ψi = H |0i , , H |1i , , (6)
2 2
i.e. the resulting state is H |0i or H |1i and measuring still outputs the same result (probability for
|0i and |1i is 1/2 each). On the other hand, if we apply Ry (π/2) to H |0i (which is statistically equal
to (5)), the result is |1i. We call (5) a mixed state opposed to pure states. Mixed states consist
of one or more pure states. In the Bloch sphere visualization, mixed states are located within the
sphere, while pure states lie on the surface. The mixed state (5) represents the center of the Bloch
sphere and hence rotations have no effect. We will use the technique of measuring parts of a system
and proceeding with the rest in a mixed state during the amplitude estimation described in section
4.

9
3 BUILDING BLOCKS OF PAYOFF VALUATION ON A QUANTUM COMPUTER

3 Building Blocks of Payoff Valuation on a Quantum Computer

The valuation of a payoff essentially is the calculation of an expected value E(Z) where Z is the
random variable representing the payoff behavior. The building blocks needed for modeling the
valuation in a quantum circuit are (1) loading the market model, (2) implementing the payoff and
(3) calculating the expected value. I.e. we start with loading the distribution of an underlying and
proceed with encoding the payoff distribution based on this underlying. Given the payoff distribu-
tion, the expected value can finally be derived. Figure 2 illustrates the general assembling. The
crucial step for improving the Monte Carlo convergence is the calculation of the expected value.
Doing this straightforward by measuring √ has no advantage over classical Monte Carlo, because the
Monte Carlo error only decreases with M where M is the number of shots (executions of the cir-
cuit including measurement). The technique to achieve the quadratic speed-up is called Amplitude
Estimation (AE). To apply AE, we split the expected value calculation into two sub-steps: (3a)
the encoding of the expected value to a single qubit’s amplitude and (3b+4) the AE itself. As the
main motivation for our work is the Monte Carlo speed-up via AE, we dedicate an own section to
an ”AE deep dive” after the building blocks (1)-(3) have been described.

|ρim : H E2

|ψir : A
 B 
 |ϕis : 
|υis+1 E1 E2  |χis+1
|·i :


1 2 3a 3b 4
Figure 2: General illustration of the building block assembling. The distribution loading (1) is followed
by the payoff encoding (2). After that, the calculation of the expected value (3) is split into two sub-
steps: E1 encodes the expected value to a single qubits amplitude (3a) and E2 followed by a measurement
represents the amplitude estimation itself (3b+4). The intermediate state |χis+1 plays an important role in
the implementation of AE (see section 4). The gate H represents the initialization of the so called query
register |ρim , which is needed for the amplitude estimation. Note that |χis+1 denotes a certain state while
|υis+1 is the name of the qubit register. We will see that after step 3a, the register |υis+1 is in state |χis+1 .

For the general description of the building blocks, it suffices to consider Z as univariate random
variable, discretized with resolution 2r . The stochastic process interpretation will be introduced in
connection with the insurance-related quantum circuits in section 6.

3.1 Distribution Loading

Let Z be a random variable and assume that we have a discretization of its range [zmin , zmax ] to
2r points {z0 , . . . , z2r −1 }. The corresponding probabilities are ak := P(Z = zk ), k = 0, . . . , 2r − 1.
We need a quantum algorithm A that prepares the state:
r −1
2X
√
|ψir = A |0ir := ak |kir , (7)
k=0

where the integer k denotes the k th basis vector of the qubit system |ψir . Furthermore we define
a mapping k → zk as affine transformation:
zmax − zmin
k → zmin + k. (8)
2r − 1

10
3 BUILDING BLOCKS OF PAYOFF VALUATION ON A QUANTUM COMPUTER

In other words the algorithm A maps an r-qubit register from state |0ir to the entangled superpo-
sition |ψir where each basis state |kir corresponds to a discretization point of Z. Hence we can use
A as notation for the random variable Z in quantum terms. See [11] for a specific algorithm and
[14] for a generic approach. Zoufal et al. [27] present a more efficient methodology of distribution
loading using quantum Generative Adverserial Networks (qGANs).

3.2 Payoff Implementation

In order to represent the payoff, the quantum circuit with the distribution register is extended
by a second qubit register. Given the extended circuit in state |ψir ⊗ |0is , the next task is the
construction of an algorithm B, which encodes the payoff behavior into the second register:

|ψir ⊗ |ϕis := B(A ⊗ Is ) |0ir+s .

After applying the payoff algorithm B, the superposition |ϕis represents the payoff’s probability
distribution. This is a key feature of quantum computing: Without explicit formulation of the dis-
tribution and without calculating each possible tuple of outcome z and corresponding probability
P(Z = z) one by one, the quantum circuit provides the entire payoff behavior in a single step. The
target register |ϕis contains all information about the distribution at the same time. This is also
remarkable in terms of memory: While a classical computer would need ca. 2s bytes to represent a
discrete probability distribution with 2s possible values, a quantum computer only needs s qubits.
Of course the exact amount of classical memory required depends on the desired precision of the
probabilities. We are assuming one byte (= 8 bits) per probability for this simple comparison but
the exponential difference remains no matter which granularity we need.

The formal derivation of the circuits will often assume the involved qubit registers in basis states,
e.g. |ψir = |kir in equation (7). The general case with |ψir in any superposition follows from
linearity of all operators and the fact that a linear operator is completely defined by its action on
a basis. Remember that all operators are linear according to the evolution postulate (2.2).

3.3 Calculation of the Expected Value

Now that the payoff is represented by the state |ϕis , the last step is the calculation of the expected
value. As described at the beginning of this section, this is where the main result of quantum
computing in connection with Monte Carlo methods comes into play: The quadratic speed-up via
amplitude estimation.

The first task represented by E1 in figure 2 is to encode the expected value to a single qubit’s
amplitude, i.e. the initial state for the AE itself needs to be prepared. To avoid unnecessary com-
plexity during the derivation of the AE algorithm, we assume that the payoff distribution is equal
to the underlying distribution. I.e. step 2 in figure 2 becomes needless and we can use |ψir defined
according to equation (7) as starting point for step 3a. Once AE is implemented, it can be easily
applied to arbitrary payoffs by plugging them in the circuit as algorithm B.

Now, given step 1 completed, the register |ψir contains full information about the discretized
distribution and hence i.a. the expected value:
r −1
2X
E[Z] := ak zk . (9)
k=0

11
3 BUILDING BLOCKS OF PAYOFF VALUATION ON A QUANTUM COMPUTER

The amplitude encoding is described in [26] with multi-controlled Y-rotations being the key com-
ponents. We will describe some details of the implementation because it illustrates the current
status of quantum algorithm development fairly well: Programming has to be done on low level
(qubit level) and we deal a lot with mapping between binary representations, quantum amplitudes
and real numbers.

A Y-rotation is defined as
   
ϑ ϑ
Ry (ϑ) |0i := cos |0i + sin |1i .
2 2
The action on |1i follows from Ry (ϑ) |1i = not(Ry (ϑ) |0i). Now we assume the register |ψir in a
certain basis state |kir with binary representation k = k0 . . . kr−1 and corresponding integer value
k ∈ {0, . . . , 2r −1}. The full rotation (ϑ = 2π) is then split into 2r parts and the integer k determines
how many of these parts are summed up to the realized rotation in random event k:
r−1  
2πk π X i 2π
ϑk := r = r−1 2 ki ∈ 0, 2π − r . (10)
2 2 2
i=0

Note that {ϑ0 , . . . , ϑ2r −1 } is the discretization of the random variable θ which is an affine trans-
formation of Z. Each term of the sum can be implemented as a controlled Y-rotation with the
register |ψir used as control qubits. The corresponding circuit is illustrated in figure 3.

|k0 i •
|k1 i •
.. ..
. .
|kr−1 i •
|0i Ry (ϑr ) Ry (2ϑr ) ··· Ry (2r−1 ϑr )

Figure 3: Circuit to encode an integer on an amplitude. The total rotation performed on the last qubit
depends on the binary representation of k. With ϑr = 2π/2r being the rotation granularity, the total rotation
can be uniquely mapped back to the integer value of k.

After the rotation, the value of k is encoded on the amplitude of the single ancilla qubit, i.e. we
know how to implement the algorithm E1 :
     
ϑk ϑk
E1 |kir |0i = |kir cos |0i + sin |1i .
2 2
Please note that we only need single controlled rotations in this case. The mentioned multi-
Pn−1
controlled rotations are needed if the approach is generalized to polynomials f (k) = i
i=0 ci k
instead of f (k) = k.

If we change |ψir from a certain basis state to a general superposition, we get by linearity of E1 :
r −1
2X
√
E1 |ψir |0i = ak E1 |kir |0i
k=0
r −1 (11)
2X      
√ ϑk ϑk
= ak |kir cos |0i + sin |1i .
2 2
k=0

12
3 BUILDING BLOCKS OF PAYOFF VALUATION ON A QUANTUM COMPUTER

Hence measuring the last qubit in state |1i gives us the probability:
r −1
2X  
2 ϑk
p := ak sin (12)
2
k=0

p is formally obtained by a measurement of the observable I2r ⊗ |1i h1| on the entangled state (11),
where In is the n-dimensional identity matrix. More intuitively p is the sum of the probabilities
of the combined events ”first qubit register in state |kir and second qubit in state |1i”. To get
the expected value of ϑ (and hence E[Z] by linearity of E, (8) and (10)) the following linear
approximation of sin2 is used:
 π 1 1
sin2 z + ≈z+ for |z| < .
4 2 2

Therefore we implement the affine transformation ϑ̂k /2 := (ϑk /(2π) − 1/2)capprox + π/4 with small
capprox instead of ϑk in the rotation and get
r −1
2X
! r −1
2X   
2 ϑ̂k ϑk 1 1
p̂ := ak sin ≈ ak − capprox +
2 2π 2 2
k=0 k=0

as measurement result from the circuit. That finally delivers an approximation for the transformed
expected value:
  2X r −1     
ϑ ϑk 1 1 1
E = ak ≈ π p̂ − + .
2 2 2 capprox 2
k=0

The transformations (10) and (8) finally lead us to the expected value E(Z):
  r
zmax − zmin ϑ 2
E(Z) = zmin + r
E .
2 −1 2 π

Implicitly assuming the existence of the approximation and the transformations, we will use the
following loose notation for (11), which makes the encoding of the expected value to a single qubit’s
amplitude directly visible:
r −1
2X
√ √ √

|χir+1 := E1 |ψir |0i = ak |zk ir 1 − zk |0i + zk |1i . (13)
k=0

Now we know how to encode the expected value on the amplitude of a single qubit, i.e. how to
prepare the state |χir+1 from figure 2. Actually we did not encode the expected value itself, but a
quantity p from which we can derive the expected value by a linear transformation. Note that until
now, there is no benefit compared to classical Monte Carlo. However, we prepared the ground for
amplitude estimation, which will eventually deliver the expected value with the above-mentioned
quadratic speed-up.

The amplitude estimation represented by E2 in figure 2 followed by a measurement completes the

abstract circuit. Therefore the circuit is extended by an additional qubit register |ρim , which is
called query register. We will give an in-depth description of AE in section 4 so that we are able to
assemble the concrete circuit afterwards (section 4.1.4).

13
4 AMPLITUDE ESTIMATION

4 Amplitude Estimation
The basic technique of amplitude estimation was developed by Brassard in 2002 [3] and is based
on a generalization of Grover’s search algorithm [10]. Recent publications on this topic apply the
idea to equity options [21], show concrete implementations including real hardware results [26] and
propose more efficient approaches which reduce the quantum computational effort [24]. We will first
describe the basic technique in section 4.1 and then give a short overview of recent developments.

Before we start describing the components of amplitude estimation, we clarify the vocabulary:
• Phase Estimation (PE) helps finding a phase. If a qubit register is in state (15) then the task
of PE is to find an estimation for the phase x. The Inverse Quantum Fourier Transformation
QF T −1 , introduced in section 4.1.1 is an algorithm which solves the PE problem.

• Amplitude Amplification (AA) algorithms amplify the amplitude of a sought basis state.
This can for example be implemented by Phase Kick-Back followed by PE (section 4.1.2). A
more basic example is the Grover search, where the sought answer is represented by a certain
(but unknown) basis state and AA amplifies the probability for measuring this state.

• Amplitude Estimation (AE) is a general term for circuits which deliver estimates of an
amplitude, i.e. of a probability for measuring a certain state. The most basic example is
repeated measurement. Section 4.1 presents a more sophisticated version where AA is used
to amplify the probability of a state associated with the sought amplitude. I.e., in this case,
the answer searched by AA is an amplitude itself.
To connect the terms, we can say that the amplitude estimation algorithms described in this section
are implemented via amplitude amplification. The latter can be performed with (section 4.1) or
without (section 4.2) phase estimation.

In the following sections we will always treat cases, where the final outcome is the exact searched
value. The reason why the algorithms are called phase and amplitude estimations is, that we only
get estimates in the general case. We will analyze the general case in section 4.1.5.

4.1 Amplitude Estimation based on Phase Estimation

The general idea of amplitude estimation based on phase estimation can be summarized as follows:
Given a qubit register in state (13), the probability for the event ”last qubit = |1i” is sought.
Therefore a query register |ρim is added to the circuit, whose basis states represent the possible
results. Then the amplitude of the sought basis state (i.e. the one representing the expected value)
is amplified. Thanks to the amplified amplitude, the final measurement returns the right answer
with high probability so that ideally one execution of the circuit suffices. In other words we are ex-
ploiting the fact, that the quantum computer ”knows” the answer without calculating all scenarios
one-by-one. AE ”extracts” the answer.

We will start with the formulation of the Phase Estimation (PE) problem. The solution will
naturally motivate the definition of the Quantum Fourier Transformation (QFT), whose action on
the enumerated basis states |li ∈ {|0i , |1i , . . . , 2m−1 } is:
2 −1m
1 X 2πi m l
QF T2m |li := √ e 2 k |kim . (14)
2m k=0

14
4 AMPLITUDE ESTIMATION

Being able to implement PE, we will ”kick” the expected value from the amplitude of |χir+1 to the
relative phase of a superposition |ρim on which we can eventually apply PE.

4.1.1 Quantum Phase Estimation

The main result of this subsection will be the following: Let a qubit register |ρim be in the super-
position
2m −1
1 X 2πixk
|ρim = √ e |kim (15)
2m k=0
with x ∈ [0, 1]. Then there is an efficient quantum algorithm to obtain an estimate of x.

The task of estimating x is called phase estimation problem. An algorithm is classified as efficient
if the number of required resources (e.g. quantum gates) is bounded by an polynomial, i.e. it is in
O(mn ) for a fixed n ∈ N.

l
In this section we will actually deal with the special case where x = 2m for some l ∈ {0, . . . , 2m −1},
i.e. |ρim = QF T2m |li. The general case is addressed in section 4.1.5. We denote the corresponding
arc length by θ = 2πx. Furthermore x1 , . . . , xm ∈ {0, 1} are the binary digits of x = 0.x1 . . . xm .

The solution of the PE problem has basically two ingredients: The phase rotation operator and the
Hadamard gate. The former is defined on single qubits as follows for j ∈ N:

Rj |0i := |0i
2πi (16)
Rj |1i := e 2j |1i .

Hence the inverse phase rotation operator is:

− 2πi
Rj−1 |1i := e j
2 |1i . (17)

Given this rotation we are able to ”rotate off” digits from the relative phase of the superposition
√1 (|0i + e2πix |1i). If the j th digit of x is 1 then R−1 rotates it off.
2 j

|0i + e2πi0.x1 ...xj−1 1xj+1 ...xm |1i |0i + e2πi0.x1 ...xj−1 0xj+1 ...xm |1i
   
Rj−1 √ = √ .
2 2
−1 rotates a point between 2π(k−1) and 2πk to the lower
If we focus on the last digit, the operator Rm 2m−1 2m−1
angle. Since the operator isn’t useful if xj = 0, we will actually use controlled rotation operators
when we assemble the circuit, i.e. the rotation is only applied if the corresponding digit is equal to 1.

The Hadamard gate is self-inversive, i.e. HH |xj i = |xj i. Additionally, as xj ∈ {0, 1}, it can be
written as:
|0i + (−1)xj |1i
H |xj i = √ .
2
For m = 1 and x = 0.x1 , an application of Euler’s formula shows that the state |ρi defined in

15
4 AMPLITUDE ESTIMATION

equation (14) is equal to H |x1 i:

1
1 X 2πi(0.x1 )k |0i + eπix1 |1i
|ρi = √ e |ki = √
2 k=0 2
|0i + (cos(πx1 ) + i sin(πx1 ) |1i
= √ (18)
2
|0i + (−1)x1 |1i
= √
2
= H |x1 i .

Due to the self-inversive property of H we get:

|0i + eπix1 |1i

 
H √ = HH |x1 i = x1 .
2
To see how the Hadamard gate eventually can help solving the phase estimation problem, we need
the following identity:
2m −1 m m−j
!
1 X 2πixk O |0i + e2πi(2 x) |1i
√ e |kim = √
2m k=0 j=1
2
m
! (19)
O |0i + e2πi(0.xm−j+1 xm−j+2 ... ) |1i
= √ .
j=1
2

The second equality follows from the fact that the multiplication 2m−j x shifts the first m − j dig-
its of x before the decimal separator and we can ignore full rotations because of e2πik = 1 for k ∈ N.

l
Note that if x = 2m for some integer l, the binary representation ends after m digits. I.e. the
relative phase of the first tensor factor (19) has one digit (0.xm ), the second one has two digits
(0.xm−1 xm ) and so on.

Now we are prepared to assemble the circuit for the inverse QF T . That proves the existence of an
algorithm which maps the relative phase of a superposition to a basis state representing the phase:
m
2 −1
1 X 2πi m l
QFT−1
2m :√ e 2 k |kim → |lim . (20)
2m k=0

The inverse QF T algorithm illustrated in figure 4 can be described as follows:

1. Suppose a qubit register in state (14) with x = 0.x1 x2 . . . xm where xj ∈ {0, 1} for j =
1, . . . , m, written as tensor product according to (19)

2. For j = 1, . . . m:
|0i+e2πi0.xm−j+1 |1i
 
(a) Apply Hadamard gate to the j th tensor factor: H √
2
= |xm−j+1 i
(b) For i = 1, . . . m − j:
−1
i. If xm−j+1 = 1: Apply inverse rotation operator Ri+1 to (i + 1)th tensor factor

16
4 AMPLITUDE ESTIMATION

The crucial point is that if we are at step (2a) the relative phase of the current tensor factor has
exactly one digit, because all following digits have been rotated off before. Please note that given a
fault-tolerant quantum computer we don’t run the circuit several times because the result register
|x1 . . . xm im is in a basis state and hence the measurement always returns the same result. The
size m of the qubit register determines the estimation accuracy as it corresponds to the number
of binary digits which are calculated. The total number of gates required is m Hadamard gates
plus m(m−1)2 rotation operators. Hence the resources needed for the QF T algorithm is in O(m2 ),
i.e. the algorithm is efficient. Finally note that QF T directly follows from the inverse QF T by
inverting all gates and running the circuit backwards. Moreover the order of the result register has
to be reversed which can technically be achieved by the help of swap gates.

√1 |0i + e2πi0.xm |1i

2 H • ··· • |xm i

√1 |0i + e2πi0.xm−1 xm |1i

2 R2−1 H • ··· • |xm−1 i
.. .. .. . . .. ..
. . . . . .
··· •
√1 |0i + e2πi0.x1 ...xm |1i


−1
2
−1
Rm Rm−1 · · · R2−1 H |x1 i

Figure 4: Illustration of the Inverse Quantum Fourier Transformation. The last digit xm can be immediately
determined by applying the Hadamard gate. For the other digits, in each case the higher digits have to be
rotated off before application of the Hadamard gate. Hence in total m Hadamard gates and m(m−1)
2 rotation
operators are needed which, i.e. the QFT algorithm requires a total number of O(m2 ) gates.

l
We have seen that for x = 2m for some integer l, the algorithm delivers the exact phase value.
In general, the result will be close to the exact value with high probability. We will discuss the
estimation error and the computational effort in section 4.1.5.

4.1.2 Phase Kick-Back

We have introduced controlled operators in section 2. A controlled operator is applied to a tuple
consisting of a control qubit and a target register. If the control qubit is in state |1i, the operator
is applied to the target, otherwise it has no effect. Hence it seems, that the control qubit remains
unchanged after a controlled operation. However, the control qubit can also be affected due to phase
kick-back, where eigenstates and eigenvalues play the decisive role. Let Q be a (1 + 2m )-dimensional
operator with eigenstates |ψ1 im , |ψ2 im and corresponding eigenvalues λ1 , λ2 . If we apply Q to an
eigenstate we get Q |ψi im = λi |ψi im . Hence, the controlled Q (we write cQ) has the following
effect if the target qubit is in an eigenstate:
(
|0i |ψi im , |ki = 0
cQ |ki |ψi im = (21)
|1i Q |ψi im = |1i λi |ψi im = λi |1i |ψi im , |ki = 1.
I.e. the target register in an eigenstate remains unchanged and the eigenvalue λi can be associated
with the control qubit: It is kicked-back from the target to the control qubit. If the control qubit
is in a superposition, we get by linearity:
(α1 |0i + α2 |1i)Q |ψi im = (α1 |0i + α2 λi |1i) |ψi im .
We see that the eigenvalue appears as relative phase of the control qubit. This effect will be used
during amplitude estimation to ”kick” the sought amplitude to the relative phases of control qubits

17
4 AMPLITUDE ESTIMATION

where we eventually apply phase estimation.

Finally we have a look at the general case, where the target qubit is in a superposition of eigenstates.
The controlled operator prepares an entangled state:

(α1 |0i + α2 |1i)Q(β1 |ψ1 im + β2 |ψ2 im ) = β1 (α1 |0i + α2 λ1 |1i) |ψ1 im + β2 (α1 |0i + α2 λ2 |1i) |ψ2 im )
= β1 |ϕ1 i |ψ1 im + β2 |ϕ2 i |ψ2 im ,

where |ϕi i = α1 |0i + α2 λ1 |1i. Due to the entanglement, we know that after measuring the second
qubit the first register will be in state |ϕi i with probability |βi |2 , i.e. in a mixed state (see section
2.4). This result together with the following example will be important for the implementation of
amplitude estimation.

Example: Phase Kick-back + Phase Estimation = Amplitude Amplification Let Q be

a Y-rotation by 2θ in the Bloch sphere. Then the matrix representation of Q is
 
cos θ − sin θ
Q= .
sin θ cos θ

The eigenvalues of Q are eiθ and e−iθ with the corresponding eigenstates denoted as |ψ± i. With the
control being initialized by H |0i and the target qubit in an eigenstate |ψ± i the controlled operator
cQ prepares the following state:
 
|0i + |1i ∓iθ
H |0i cQ |ψ± i = √ e |ψ± i
2
(22)
|0i + e∓iθ |1i
 
= √ |ψ± i .
2
Note that for θ = 2π0.x with x ∈ {0, 1}, we have shown in section 4.1.1 that x can be determined
by applying an Hadamard gate (i.e. performing phase estimation for m = 1) to the first qubit:

|0i + e∓2πi0.x |1i

 
H √ = |xi .
2

This is a basic example of Amplitude Amplification. The initial state of the control qubit is an
equally weighted superposition of the basis states |0i and |1i. After phase kick-back and phase
estimation, the state is |xi, i.e. either |0i or |1i depending on the rotation angle. That means that
the amplitude of |xi has been amplified from √12 to 1.

For the general case with θ = 2π0.x1 . . . xm for xj ∈ {0, 1} we are using the fact that ej±iθ are

eigenvalues of repeated rotations Qj . Hence we can prepare the state √12 |0i + e∓2πi0.xj+1 ...xm |1i
j
by applying Q2 to the target qubit. That means that given a Y-rotation we can encode the rota-
tion angle to a qubit register in a way that this qubit register is in the initial state for the phase
estimation. We eventually have built an algorithm for amplifying the amplitude of the basis state
which represents the rotation angle. The corresponding circuit is illustrated in figure 5.

18
4 AMPLITUDE ESTIMATION

|0i H • |xm i

|0i H • |xm−1 i
.. .. QF T −1
. .

|0i H • |x1 i

m−1 m−2
|ψ± i Q2 Q2 ··· Q |ψ± i

Figure 5: Illustration of an amplitude amplification circuit. The control register is initialized with equal
weights and the target qubit is initialized with an eigenstate |ψ± i of the rotation. The latter remains
unchanged. After kicking back the eigenvalues, the phase estimation algorithm QF T −1 is applied. Eventually
the amplitude of the basis state |2m xi with x = θ/2π is equal to 1 while all other amplitudes are 0.

Note that the initialization of the query register is achieved by an m-qubit Hadamard transfor-
mation H ⊗m , which results in an equally weighted superposition. As H ⊗m = QF T |0im we can
directly see that the circuit works in the most simple case: θ = 0 =⇒ Q = I =⇒ |xim =
QF T −1 QF T |0im = |0im .

For the sake of comprehensiveness, we amend

some details on the eigenstates: The eigenstates of
the Y-rotation are |ψ± i = √12 |χi ± i χ⊥ , where |χi and χ⊥ are orthonormal vectors which
span the xz-subspace in the Bloch sphere. In other words |χi and χ⊥ span the subspace which is
mapped to itself by the Y-rotation. The eigenstate property follows straightforward from applying
Q, e.g. for |ψ+ i we get:
1  E
Q |ψ+ i = √ Q |χi + iQ χ⊥
2
1 h E  Ei
=√ cos θ |χi + sin θ χ⊥ + i − sin θ |χi + cos θ χ⊥
2
1 h Ei
= √ (cos θ − i sin θ) |χi + (sin θ + i cos θ) χ⊥
2
1 h Ei
= e−iθ √ |χi + i χ⊥
2
−iθ
= e |ψ+ i .

4.1.3 Application to Expected Value Calculation

The preceding sections have shown how we can implement amplitude estimation given a rotation
operator. The remaining task is to find the ”suitable” rotation in the subspace spanned by |χir+1
and χ⊥ r+1 where |χir+1 is defined by equation (13). We will denote this subspace by H(χ, φ).
Suitable means that the rotation angle must be related to the expected value. Once we found this
rotation we can WLOG assume that |χir+1 is a linear combination of the rotation’s eigenstates,
apply amplitude estimation and eventually derive the expected value from the estimated phase. In
other words, the task is to define a rotation without knowing the angle. We will closely follow [21]
in the following derivation. To ease notation, we will omit the subscript of |χir+1

First we are looking for a function f which defines a relationship between the expected value
encoded in the amplitude of |χi and an arbitrary rotation angle in the hyperplane H(χ, φ). Let V

19
4 AMPLITUDE ESTIMATION

be a linear operator defined as follows:

V := I2r+1 − 2I2r ⊗ |1i h1| .

Note that V is a slight modification from the definition in section 3 to make it a unitary operator,
i.e. V −1 = V † . Thanks to the measurement postulate we know that we can measure the unitary V
on |χi, which delivers a linear transformation of the expected value:

hχ| V |χi = 1 − 2µ, (23)

where µ is defined according to equation (12), i.e.

r −1
2X  
2 ϑk
µ := ak sin . (24)
2
k=0

Since we know how the expected value can be derived from µ (see section 3) we can use µ as
synonym for the expected value.

As V is a unitary operator, V |χi can be written as a Bloch vector using the orthonormal basis
{|χi , χ⊥ }:    
θ θ E
V |χi = cos iφ
|χi + e sin χ⊥ .
2 2
This representation leads us to hχ| V |χi = cos (θ/2) and hence it specifies a relationship between the
expected value and an angle θ in the hyperplane H(χ, φ). The searched function f can be defined
based on the identity 1 − 2µ = cos θ/2:
  
1 θ
f (θ) := 1 − cos = µ.
2 2

The remaining task of implementing a rotation in H(χ, φ) with an unknown angle is solved by a
sequence of reflections. Thereby the unknown angle must be linked to θ defined by V. The result
will actually be a rotation by 2θ. Given an arbitrary orthonormal basis {|ϕi , ϕ⊥ }, a unitary
operator U is called reflection across ϕ⊥ if:

U |ϕi = − |ϕi
E E (25)
U ϕ⊥ = ϕ⊥ .

A reflection can be implemented by U = I − 2 |ϕi hϕ|. Note that −U reflects across |ϕi.

The concrete reflections needed for our task are:

U = I2r+1 − 2 |χi hχ|
S = I2r+1 − 2V |χi hχ| V.

Note that both U and S are defined in the hyperplane H(χ, φ).

Now suppose that |υi is an arbitrary state in the hyperplane H(χ, φ):
γ  γ  E
|υi = cos |χi + eiφ sin χ⊥ ,
2 2

20
4 AMPLITUDE ESTIMATION

where γ is an arbitrary angle. Then, reflecting |υi across V |χi leads to the intermediate state
−S |υi:
h γ  γ  Ei
−S |υi = − |υi + 2V |χi hχ| V cos |χi + hχ| Veiφ sin χ⊥
 2   2D
γ  θ γ  E
−iφ ⊥ iφ ⊥
= − |υi + 2V |χi hχ| V cos |χi + e sin χ e sin χ
2 2 2
 γ       γ 
θ θ
= − |υi + 2V |χi cos cos + sin sin
2 2 2 2
= ···
   
2θ − γ 2θ − γ E
= cos iφ
|χi + e sin χ⊥ ,
2 2

i.e. the angle of the intermediate state −S |υi in the hyperplane H(χ, φ) is 2θ − γ. This can be
seen more easily in figure 6. The formal derivation uses hχ| V = (V |χi)† in step 2 and several
trigonometric calculation rules in step 4.

z
|χi
|υi

-2θ V |υi
θ
Q |υi γ 2θ − γ −S |υi

|χi+eiφ |χi⊥
√
2

|χi⊥

Figure 6: Illustration constructing the rotation operator Q in the Bloch sphere. The orthonormal basis
⊥
vectors are |χi and |χi and the Z-rotation is fixed to an arbitrary angle φ. Starting with the initial state
|υi (red, angle=γ), a reflection across V |υi leads to −S |υi (purple, angle=γ +2(θ−γ) = 2θ−γ. The following
projection across |χi eventually leads to Q |υi (green, angle=−(2θ − γ) and hence the angle between the
initial and the final state is −(2θ − γ) + (−γ) = −2θ.

21
4 AMPLITUDE ESTIMATION

The next operation is a reflection of −S |υi across |χi, which effectively changes the sign of the
angle. The rotation is implemented by an application of −U. With Q := −U(−S) = US:
     E
2θ − γ iφ 2θ − γ ⊥
Q |υi = S |υi + 2 |χi cos |χi + e sin χ
2 2
 
2θ − γ
= S |υi + 2 cos |χi
2
   
2θ − γ 2θ − γ E
= cos − iφ
|χi + e sin − χ⊥ .
2 2

If we now look at the angle between the initial state |υi and the final state Q |υi we see that its
−(2θ − γ) + (−γ) = −2θ. As the two states are located in the same hyperplane, we found that the
composed reflections US build a rotation about −2θ. For the actual implementation, the reflections
have to be broken down so that we can work in the computational basis. With F := E1 (A ⊗ I2 )
we already have implemented an algorithm to prepare |χi:

|χi = F |0ir+1 .

Let Z be the reflection in the computational basis:

Z = I2r+1 − 2 |0ir+1 h0|r+1 .

As F is a unitary operator it holds F −1 = F † . Given that we can successively compose U, S and

finally Q by F, Z and V:
U = FZF †
S = VU V = VF ZF † V
Q = US = FZF † VF ZF † V.
The amplitude amplification algorithm E2 from figure 2 can eventually be described as follows:
 
m−1
m−j
O
E2 : H ⊗m |0im |χir+1 → QF T −1 ⊗ Ir+1  cQj2  (H ⊗m |0i |χi ),


m r+1
j=1

where the controlled rotation operator Qij uses the j th qubit of the first register as control and is
applied i times on the target register:
(
|kim Qi |χir+1 , |kj i = |1i
cQij : |kim |χir+1 →
|kim |χir+1 , else.

Now all components for implementing the quantum circuit which calculates the expected value of
a random variable are prepared and we will assemble them in the following section.

4.1.4 Assembling of the Quantum Circuit

The abstract quantum circuit for calculating the expected value of a random variable using ampli-
tude estimation is illustrated in figure 2. In the preceding section we have shown how the isolated
building blocks look like and now we can finally put everything together. The resulting amplitude
estimation circuit is illustrated in figure 7.

22
4 AMPLITUDE ESTIMATION

Amplitude Amplification E2


 |0i • |xm i




 |0i • |xm−1 i


|ρim  . H .. QF T −1

 .. .





|0i • |x1 i

 

 |0i ··· 

 .
 
···

|ψir .. 
A

|χir+1

m−1 m−2


 E1 Q2 Q2 Q
|0i ···
 





|0i ··· 

Figure 7: Illustration of the quantum circuit which calculated the expected value of a random variable by
using amplitude amplification. The query register |ρim is initialized by an m-qubit Hadamard gate and the
state |χir+1 is prepared by encoding the expected value to the amplitude of the last qubit. Afterwards E2
amplifies the amplitude of the basis state representing the expected value in the query register. The final
measurement returns an estimation value 2m x ∈ N which can be mapped to the expected value.

1. Distribution Loading (section 3.1) encodes a probability distribution to a qubit register:

r −1
2X
√
A : |0ir → ak |kir .
k=0

2. Payoff Implementation (section 3.2) transforms the probability distribution of an underlying

to the probability distribution of a payoff:
2(r+s)−1
X √
B : A |0ir ⊗ |0is → ak |kir .
k=0

While the development of specific payoffs is our main contribution (see following sections), we
omit this part of the circuit in this section in order to concentrate on the general mechanism
of amplitude estimation. In other words, we assume that the payoff is equal to the underlying.
3. Calculation of the Expected Value
(a) Encoding the Expected Value to an Amplitude (section 3.3) is achieved by controlled
rotations.
r −1
2X
√ √ √

E1 : A |0ir ⊗ |0i → ak |zk ir 1 − zk |0i + zk |1i := |χir+1 .
k=0

(b) Amplitude Amplification (section 4) is composed of the phase estimation algorithm (sec-
tion 4.1.1) and the controlled rotation operator Q (section 4.1.3).
 
m−1
m−j
O
E2 : |χir+1 ⊗ H ⊗m |0im → QF T −1 ⊗ Ir+1  cQ2j  H ⊗m |0i |χi


m r+1
j=1
m
= |χir+1 ⊗ |2 xim ,

23
4 AMPLITUDE ESTIMATION

where x can be mapped to the expected value. The initialization of the query register
is achieved by an m-qubit Hadamard transformation:
m
2 −1
⊗m 1 X
H : |0im → H |0im =√ |ki .
2m k=0

4. Measurement completes the amplitude estimation. In an ideal setup with a fault-tolerant

quantum computer and x = l/2m for some integer l the circuit has to be executed only once.
In general, the number of shot depends on the required accuracy of the estimation.

4.1.5 Computational Effort compared to Classical Monte Carlo

In order to compare Monte Carlo estimators, we need to define the comparison criteria. Suppose
that
M
1X
µ̂ = Zi
n
i=1

with Zi iid, E[Zi ] = µ and Var[Zi ] = σ 2 < ∞, is a classical Monte Carlo estimator for the expected
value. Then the central limit theorem leads to a relationship between the estimation error and the
number of samples:
σ2
 
µ − µ̂ ≈ N 0, .
M
This means that the estimation error is approximately normally distributed with variance σ2/M .
Hence the following equation gives us the confidence interval for a designated confidence level α:
 
σ
P |µ − µ̂| ≤ qα/2 √ ≈ 1 − α,
M

where qα/2 = Φ−1 (1 − α/2) and Φ is the standard normal distribution function. Hence the size of
√
the error is in O(1/ M ). In other words, if we want to increase the accuracy by a factor a, the
number of samples has to be increased by a2 [8].

As quantum computers work fundamentally different, the comparison is not straightforward. For
example in the amplitude estimation algorithm there is nothing directly comparable to the clas-
sical samples because the quantum computer simulates the entire distribution at the same time.
Therefore we are introducing the term Quantum Samples which denotes the number of possible
basis states, which is M = 2m for m qubits. Quantum samples can be seen as analogue to classical
Monte Carlo scenarios. Then we will assess the effort for running the circuit once, depending on
the number of quantum samples and finally analyze the relationship between this effort and the
estimation error.

Assessing the effort for running the circuit actually means counting operators. The complexity of
the amplitude estimation algorithm is dominated by the 2m − 1 applications of Q (remember that
QFT requires O(m2 ) gates). Hence there is a linear relationship between the computational effort
and the number of quantum samples M .

l
Concerning the estimation error, we have already seen that it is zero if x = 2m for some integer l. In
1
this case we can say that x fits the granularity 2m of the query register |ρim . If x is located between

24
4 AMPLITUDE ESTIMATION

two discretization points, i.e. 2km ≤ x ≤ k+1

2m , we can show that the phase estimation algorithm
k k+1
returns one of the two closest points √2m and √ 2m
with probability at least π82 (see below for the
proof). Hence we found a relationship between the number of qubits of the query register m and
the estimation error:  
1 8
P |x − x̂| ≤ m ≥ 2 , (26)
2 π
where x̂ ∈ [0, 1] is the outcome of the AE circuit. This is the main result of the error estimation.
We still need to translate the inaccuracy of x̂ to the inaccuracy of the expected value. Actually it
can be shown that if |x − x̂| ≤ 21m then |µ − µ̂| ≤ O( 21m ) and hence with M = 2m :
  
1 8
P |µ − µ̂| ≤ O ≥ 2,
M π

where the definition of µ̂ is based on (23):

!
1 θ̂
µ̂ = 1 − cos
2 2

and θ̂ = 2πx̂ is the transformed output from AE. In other words, the convergence rate improves
from √1M for classical Monte Carlo to M
1
for amplitude estimation, which is a quadratic speed-up.
We refer to [3] for the details.

We conclude this paragraph with the proof of equation (26). Let x ∈ [0, 1] be some fixed number.
Then in the AE circuit, after application of the controlled rotations Qj , we have the following state
in the query register:
2m −1
1 X 2πixk
|ρim = √ e |kim .
2m k=0
1
Since |x − x̂| ≤ 2m we can decompose x in binary notation (xi ∈ {0, 1}):

x = x̂ + εx = 0.x1 . . . xm + 0.0 . . . 0xm+1 . . . (27)

1
with εx < 2m . The following inverse QFT leads us to:

2 −1 m 2 −1 m
1 X 2πixk 1 X −2πi km l
QF T2−1
m |ρim =√ e √ e 2 |lim
2m k=0 2m l=0
m
2 −1 2 −1 m
1 X X 2πixk −2πi km l
= m e e 2 |lim
2
k=0 l=0
m −1 2m −1
2X
1 X k
= e2πi(x̂+εx )k e−2πi 2m l |lim
2m
l=0 k=0
m −1 2m −1
2X 2m x̂−l
 
1 X 2πik 2m
+εx
= m e |lim
2
l=0 k=0
m −1
2X
1
=: αx,m (l) |lim
2m
l=0

25
4 AMPLITUDE ESTIMATION

Hence computing the geometric sum delivers the amplitude of the state |lim = |2m x̂im :
2m −1 m
1 1 − eπiεx 2

m 1 X 2πikεx
αx,m (2 x̂) = m e = m ,
2 2 1 − eπiεx
k=0

which leads us to the corresponding probability:

m 2 2
m 2 1 1 − eπiεx 2 1 sin2 (M πεx )
P(x̂) = |αx (2 x̂)| = = 2 ,
22m 1 − eπiεx M sin2 (πεx )

where the last step follows from |1 − ei2θ | = |e−iθ − eiθ | = 2| sin θ|. For |πεx | ≤ π/2 (which is ensured
by (27)) and for M > 1, one can show that P(x̂) ≥ 4/π2 and since this is true for both neighbors of
x, the probability for |x − x̂| ≤ 1/2m is at least 2P(x̂) = 8/π2 .

4.2 Amplitude Estimation without Phase Estimation

The conventional approach for amplitude estimation described in the previous section is difficult to
implement on near-term quantum computers. A measure for the near-term implementability is the
number of controlled operators, or on lowest level the number of cnot gates. Suzuki et al. proposed
the Maximum Likelihood Amplitude Estimation [24], Grinko et al. introduced Iterative Amplitude
Estimation [9]. Both variants do not rely on phase estimation and are hence less expensive in terms
of cnots. We won’t analyze these approaches further in this work, but would like to emphasize
that there are ongoing developments which bring us closer to the practical application of quantum
computers.

4.3 Excursus: Grover’s Quantum Search Algorithm

At the beginning of section 4 we stated that the amplitude estimation is based on a generalization
of Grover’s search algorithm. To close the loop we will give a brief description of the connection
between these algorithms. The search problem solved by Grover’s algorithm is defined as follows:
Given a black box Uf for computing an unknown function f : {0, 1}m → {0, 1}, find an input
{0, 1}m such that f (x) = 1. Thus it is easy to check if a solution is correct (one evaluation of Uf ),
but it is hard to find it (2m possible solutions). Grover eventually finds an operator, which amplifies
the amplitude of the solution in an query register. Similar to the amplitude estimation described
above, the query register starts in an equally weighted superposition and then successively moves
towards the amplified state. In particular, after k applications of the operator G called Grover
iterate, the query register is in state:
   
k ⊗m (2k + 1)θ (2k + 1)θ E
G H |0im = cos |ϕim + sin ϕ⊥ ,
2 2 m

√
where ϕ⊥ m is the searched solution and θ is defined by sin θ/2 = 1/ 2m . Hence if (2k + 1)θ ap-
proaches π the amplitude of the searched solution approaches 1. In other words, the Grover iterate
needs to be applied approximately π/2θ − 1/2 times to get ϕ⊥ m with maximal probability.

Within the amplitude estimation algorithm the operator Q takes the role of the Grover iterate. In

26
5 INSURANCE-RELATED PAYOFFS

fact equation (11) can be written as the following superposition:

r −1
2X      
√ θk θk
E1 |ψir |0i = ak |kir cos |0i + sin |1i
2 2
k=0
   
θ θ
= cos |ψ0 ir |0i + sin |ψ1 ir |1i
2 2
   
θ θ E
= cos |ϕir+1 + sin ϕ⊥
2 2 r+1

with |ϕir+1 and ϕ⊥ r+1

located in the hyperplane H(χ, φ). Since Q is a rotation about 2θ we get:
   
(2k + 1)θ (2k + 1)θ E
k
Q E1 |ψir |0i = cos |ϕir+1 + sin ϕ⊥ . (28)
2 2 r+1

This shows the connection between Grover’s search and the amplitude estimation algorithm. Fur-
thermore equation (28) is used in the maximum likelihood amplitude estimation [24] by measuring
Qk E1 for k = 20 , . . . , 2m−1 to get an estimate for θ.

A detailed analysis of the Grover search is given in [16], section 8.1.

5 Insurance-related Payoffs
We will strongly abstract some general features of insurance contracts in this section. Our target
is to motivate the further research on modeling such features to accelerate the growth of quantum
circuit libraries. The ultimate goal is to enable actuaries to assemble their simulations from a
toolkit of encapsulated quantum gates. This is obviously a long-term target. In the context of the
IBM road map [6], actuaries should be put in the position to work as model developers and we want
to contribute to the necessary basis of algorithms. Several contributions have already been made
in the recent years, i.e. we don’t start from zero. For example Stamatopoulos et al. [23] present
a weighted adder, which we utilize and illustrate in section 6.1. They also propose a circuit which
encodes the payoff of a barrier option. Therefore comparator circuits are introduced to check for
barrier crossing in every time step.

5.1 General Payoff

Let Z = (Zti , i = 1, . . . , n) be a discrete-time stochastic process and τ a stopping time (w.r.t. the
filtration generated by Z). We will investigate different specifications of the random variable
n
X
Zτ := 1{τ =ti } Zti (29)
i=1

and calculate the corresponding expected values P V := E[Zτ ].

In this work we will always interpret Zti as zero coupon bond prices, i.e. as discount factors. Hence
Z represents the stochastic process of interest rates. For the sake of simplicity we additionally
assume all potential payments to be equal to 1 so that these amounts do not explicitly appear
in the formulas. For example the expected value of the present value of a certain payment (of 1
unit) after three time steps would be E[Zt3 ]. The random variable Zτ should be interpreted as the

27
5 INSURANCE-RELATED PAYOFFS

present value of a payment of 1 unit at a uncertain time given stochastic discount factors. The
uncertainty of the payment times is modeled via the stopping time τ .

To model the quantum algorithms we furthermore assume discretized random variables Zti :
Zti : Ω → Rti , Rti := {zti ,0 , . . . , zti ,2rti −1 } ⊆ R, rti ∈ N,
where we call rti the resolutions of the discretizations. In order to ease notation equal resolutions
are assumed for all Zti and we set rti ≡ r̂. With Rn := Rt1 × · · · × Rtn and z = (zt1 , . . . , ztn ) ∈ Rn ,
the expected value can eventually be written as
" n #
X
PV = E 1{τ =ti } Zti
i=1
n X
X
= P ({τ = ti } ∩ {Z = z}) · zti (30)
i=1 z∈Rn
Xn X
= P ({τ = ti }|{Z = z}) · P(Z = z) · zti .
i=1 z∈Rn

In the following section we will specify different characteristics of the stopping time τ .

5.2 Specifications
5.2.1 Whole life insurance
The whole life insurance (or death-benefit insurance) pays a certain amount (1 unit in our case)
in the event of death. With Zti interpreted as discount factors with duration ti and τ as residual
lifetime, equation (30) denotes the expected cash outflow of the insurance company. As the residual
life time does not depend on interest rates, the stopping probabilities simplify to
P ({τ = ti }|{Z = z}) = P ({Tx = ti }) = ti −1 px · ti qx =: wtxi
where we use the usual actuarial notation:
τ := Tx residual lifetime of an x-year-old
qx := P(Tx = 1) 1-year mortality rate of an x-year-old
px := 1 − qx 1-year survival rate of an x-year-old (31)
ti qx := P(Tx ≤ ti ) ti -year mortality rate of an x-year-old
ti px := 1 − ti qx ti -year survival rate of an x-year-old.
The expected value P V simplifies to the expected value of a weighted sum of random variables,
where the weights are the probabilities of a residual life time equal to ti and the corresponding
random variables are discount factors with duration ti :
n
X X
PV = wtxi P({Z = z}) · zti
i=1 z∈Rn
Xn
= wtxi E [Zti ] (32)
i=1
" n #
X
=E wtxi Zti .
i=1

28
6 INSURANCE-RELATED QUANTUM CIRCUITS

Instead of calculating n expected values of Zti one by one, the weighted sum can be implemented
directly in a quantum circuit (see 6.1).

5.2.2 Dynamic Lapse

In usual life insurance contracts the policy holder has the right to cancel his contract and get a
predefined payment. If the lapse rate depends on an underlying (e.g. on interest rates) this is
called dynamic lapse. With the predefined payment set to 1 and Z again interpreted as discount
factors, the random variable (29) describes the corresponding model. Therefore the stopping time
τ is composed as follows:

pti : Rti → [0, 1] , i = 1, . . . , n lapse rates at time ti

p(Z) = (pti (Zti ), i = 1, . . . , n) stochastic process of lapse rates
L = (Lti , i = 1, . . . , n), Lti ∼ Bernoulli(pti (Zti )) marginal lapse events (33)

τ := min {Lti = 1} stopping time.

i=1,...,n

To ensure a payment in case of no lapse event before tn we set ptn = 1. Given that, the lapse
probabilities modeled by the described stopping time are:
i−1
Y

P ({τ = ti }|{Z = z}) = 1 − ptj (ztj ) · pti (zti ).
j=1

I.e. the probability for contract cancellation at ti corresponds to the probability of surviving time
steps t1 until ti−1 times the marginal lapse probability of time step ti . This implies path dependency
and ensures that a contract can only be canceled once.

6 Insurance-related Quantum Circuits

As insurance contracts are often modeled over more than one period, we start this section with
the introduction of stochastic processes. Section 3.1 describes the distribution loading for a general
random variable Z. This random variable can also be interpreted as stochastic process (Zti , i =
1, . . . , n). In this case, every basis state
Pn of the register represents a trajectory of the process. We
define a partition rt1 , . . . , rtn with i=1 rti = r of the qubit register and interpret each part i as
marginal distribution of Zti . To ease up notation we assume identical resolutions r̂ in every time
step and omit the sub-index i. Then we can write
X √
|ψir := ak1 ,...,kn |k1 ir̂ ⊗ · · · ⊗ |kn ir̂
k1 ,...,kn

with ak1 ,...,kn being the probability of the corresponding trajectory.

6.1 Whole life insurance

According to section 5.2.1 a whole life insurance payoff is a weighted sum of discount factors, where
the weights are deterministic. A quantum implementation of a general weighted sum operator
is demonstrated in [23], where it is used to price Asian options. Given the constant weights
w0 , . . . , wr−1 and a r-qubit register |ψir in a basis state |kir = |k0 · · · kr−1 i there is an operator B

29
6 INSURANCE-RELATED QUANTUM CIRCUITS

which maps:
r−1
+
X
B |kir |0is = |kir wj k j . (34)
j=0
s
This is a weighted sum of 1-bit integers k0 , . . . , kr−1 . If we want to implement the payoff from
equation (32) the sum of r̂-bit integers is needed. The solution is also given in [23]: The weights
wtxi have to be adjusted to fit the digits:

wxti := (20 · wtxi , . . . , 2r̂−1 · wtxi ), i = 1, . . . , n.

Hence all components of the payoff circuit are prepared. Let the marginal distributions of the
discount factors Zti be represented by the ith part of the r-qubit register |ψir :

|ψir = |kt1 ir̂ ⊗ · · · ⊗ |ktn ir̂ = |kt1 ,0 . . . kt1 ,r̂−1 . . . ktn ,0 . . . kt1 ,r̂−1 i , (35)

where kti are r̂-bit integers. With binary vector kti = (kti ,0 , . . . , kti ,r̂−1 ) we finally get
n
+
X
x


B(A ⊗ Is ) |0ir+s = |kir wti , kti , (36)
i=1 s

where the choice of s must ensure the representability of the weighted sum. The quantum circuit
is illustrated in figure 8.
ψt1 |0ir̂ •
ψt2 |0ir̂ •
ψt3 |0ir̂ A •
..
.
ψtn |0ir̂ •

| ni=1 (wxi , ki )is

P
ϕ |0is

Figure 8: The quantum circuit for the whole life insurance with distribution loading A on the upper wires
and the weighted sum B from equation (36) in the last register.

6.2 Dynamic Lapse

The components needed to implement the dynamic lapse payoff with specifications (33) are lin-
ear amplitude functions [26] for the Bernoulli-behavior with stochastic parameter (marginal lapse
events) and multi-controlled versions of linear amplitude functions for the path-dependency of the
stopping time (the process can only stop once). Additionally we use a sequence of Toffoli gates
to sum up the discounted payments from the different time steps. Toffoli gates are also known as
ccnot gates. Figure 9 illustrates the corresponding quantum circuit.

We start with loading the distribution of the discount factors (Zti , i = 1, . . . , n) to the register |ψir
partitioned like in (35). Later in the circuit we will use the first basis state |0ir̂ of each time step ti

30
6 INSURANCE-RELATED QUANTUM CIRCUITS

for the share of contracts which are not canceled until ti (i.e. for P(τ > ti )), so we exclude it from
the initial marginal distributions and the summations start with k = 1:
r̂ −1
2X
√
|ψti ir̂ : |0ir̂ → ak |kir̂ . (37)
k=1

To ease notation, we assume identical probabilities ak for all ti , but this can easily be implemented
differently. Now we encode the stopping time. Therefore we add an n-qubit register |ϕin to the
circuit, i.e. one qubit for each time step. This register will finally be in a superposition of basis
states { 20 n , . . . 2n−1 n }, meaning that only n out of 2n available basis states are possible. The
possible basis states are characterized by exactly one qubit being bin state |1i. The position of
this qubit indicates the time of contract cancellation. As described in section 3.1, we follow the
convention that the first digit is the least significant one.

The first time step can be implemented by a linear amplitude function Pt1 :
p p 
P1 |kt1 ir̂ |0i = |kt1 ir̂ 1 − pt1 (kt1 ) |0i + pt1 (kt1 ) |1i .

The last qubit |ϕt1 i in state |1i is interpreted as lapse event, i.e. the probability of cancellation at t1
is pt1 (kt1 ). Note that the lapse probability function pti must be defined on the domain {1, . . . , 2r̂ −1}
instead of R. Therefore we are implicitly assuming the mapping defined in (8) with [zmin , zmax ]
being the ranges of Zti . For the following time steps, multi-controlled linear amplitude functions
are needed because a lapse event can only occur if it hasn’t already occurred:
( p p 
|kt i
i r̂ |li i−1 1 − p t (kt ) |0i + p t (k t ) |1i , |lii−1 = |0ii−1
ci−1 Pti |kti ir̂ |lii−1 |0i = i i i i
(38)
|kti ir̂ |lii−1 |0i , else.

At time step ti , the i − 1 precedent qubits |ϕii−1 serve as control qubits. In the given interpretation
(|1i corresponds to lapse event) the control has to be negated, i.e. Pti is applied if and only if all
control qubits are in state |0i (”control-on-zero”). This can technically be achieved by applying
not gates to all controls in front of the controlled function and reverting this afterwards. We are
using ci in our notation for a i-times control-on-zero.

Starting with |ϕin = |0in , then applying Pt1 in the first step and ci−1 Pti with i = 2, . . . , n − 1 in
the following n − 2 steps, the single qubits |ϕti i are successively entangled:
p p
|ϕt1 i = 1 − pt1 (kt1 ) |0i + pt1 (kt1 ) |1i
p p p p p
|ϕt1 ϕt2 i = pt1 (kt1 ) |10i + 1 − pt1 (kt1 ) pt2 (kt2 ) |01i + 1 − pt1 (kt1 ) 1 − pt2 (kt2 ) |00i
···
p p p
ϕt1 . . . ϕtn−1 = pt1 (kt1 ) 20 n−1 + 1 − pt1 (kt1 ) pt2 (kt2 ) 21 n−1
p p p
+ 1 − pt1 (kt1 ) 1 − pt2 (kt2 ) pt3 (kt3 ) 22 n−1 + . . .
p q q
+ 1 − pt1 (kt1 ) . . . 1 − ptn−2 (ktn−2 ) ptn−1 (ktn−1 ) 2n−2 n−1
p q
+ 1 − pt1 (kt1 ) . . . 1 − ptn−1 (ktn−1 ) |0in−1
(39)
The last step in this entangling sequence is a multi-controlled-on-zero not gate, which eventually
appends |1i to the register |ϕin−1 if none of the qubits in |ϕin−1 is in state |1i:

31
6 INSURANCE-RELATED QUANTUM CIRCUITS

(
n−1 2n−1 n , |lin−1 = |0in−1
c not |lin−1 |0i =
|lin−1 |0i , else.
Hence we finally have the lapse distribution encoded in a n-qubit register:
n p
X
|ϕin = |ϕt1 . . . ϕtn i = P({τ = ti }) 2i−1 . (40)
i=1

I.e. |ϕin is in the desired state as a superposition of only n out of 2n basis states, with the position
of the single one indicating the time of contract cancellation.

In the final step of the payoff modeling we must calculate the sum of the marginal distributions
according to the stopping time. We start with an additional r̂-qubit register |υir̂ = |0ir̂ . Then we
are using the fact, that all basis states |lin of |ϕin with probability greater than zero have exactly
one qubit in state |1i. Hence we don’t need a real sum, but rather a ”select case”: If |lt1 i = |1i
then transmit |ψt1 ir̂ to |υir̂ , else if |lt2 i = |1i then transmit |ψt2 ir̂ and so on. This transmission
is done via a sequence of n × r̂ Toffoli gates. For every time step t1 , . . . , tn there are r̂ Toffolis
with one control qubit bound to the stopping qubit |ϕti i and one each to the distribution qubits
|ψti ,j i , j = 0, . . . , r̂ − 1.

We write ccnoti for a ccnot gate with second control qubit bound to the ith qubit of the second
register:
ccnoti |ψti ,j i |ϕin |υj i = |ψti ,j i |ϕin |υj ⊕ (ψti ,j ∧ ϕti )i ,
where ⊕ denotes a xor and ∧ is a logical and.

To see how the target register |υis evolves, we successively split the stopping time register into two
parts with the first one including the basis state with the relevant control qubit is equal to one and
the second one contains the rest. This split is only used for the formulas and has no impact on the
circuit itself. q E Xq
|ϕin = pτtk 2k−1 + pτti 2i−1 ,
i6=k

where pτti
:= P({τ = ti }). When applying the first set of ccnots, the target qubits are in state |0i
and we get for j = 0, . . . , r̂ − 1:
n q
X
p τ 0
ccnot1 |ψt1 ,j i |ϕin |0i = |ψt1 ,j i p1 2 |ψt1 ,j i + |ψt1 ,j i pτti 2i−1 |0i . (41)
i=2

After the first step, the target register |υir̂ is in state |0ir̂ if and only if the contract is not canceled
at the first time step. The ”and only if” part follows from equation (37) because we didn’t use
the basis state |0ir̂ for the distribution, i.e. |ψti ir̂ 6= |0ir̂ . For the next set of ccnots we split the
second part of (41) and so on. Finally the target register represents the distribution of the random
variable defined in equation (29) with stopping time τ defined in section 5.2.2:
n q
X
|υis = pτti |ψti ir̂ .
i=1

The size s of the target register |υis must be chosen such that the resolutions of all marginal distri-
butions can be represented. In our case with equal resolutions for all ti , the target register simply

32
7 QUANTUM HARDWARE RESULTS

needs the same resolution. Otherwise s = max rti would be required. Given the payoff distribution
encoded in the target register, we can eventually calculate the expected value as described in sec-
tion 3.3. We can also calculate other properties of the distribution, e.g. risk measures like VaR or
CVaR [26].

ψt1 |0ir̂ Pt1 •

ψt2 |0ir̂ Pt2 •

ψt3 |0ir̂ A Pt3 •

.. .. ..
. . .
ψn |0irr̂ •

ϕt1 |0i Pt1 •

ϕt2 |0i Pt2 •

ϕt3 |0i Pt3 •

.. .. ..
. . .
ϕtn |0i X •

υ |0is X X X X
| {z } | {z } | {z } |{z}
1 2.1 ... 2.n 3.1 ... 3.n 4
Figure 9: The quantum circuit for the dynamic lapse payoff with (1) Distribution loading (2.i) Multi-
controlled linear amplitude function to model the lapse dynamics (3.i) Transmission of marginal distributions
according to lapse events and (4) Measuring the expected value. Note that the open bullets indicate a control-
on-zero while the filled bullets represent usual controls.

7 Quantum Hardware Results

We focus on investigating the dynamic lapse circuit described in the previous section, illustrated
in figure 9. The used payoff parametrization is shown in figure 10: The probability distribution
registers |ψti ir̂ , consisting of two qubits each, are initialized with uniform distributions. We pro-
ceed from the simplifying assumption that the zero coupon bond prices Zi are independent and
identically distributed (iid), which in particular simplifies the distribution loading and makes the
results easier to understand. Note that according to equation (37) only three out of four available
basis states are used and hence the probabilities are 1/3 for each state. The ”used” basis states
correspond to the zero coupon prices {0.9, 1.0, 1.1}. The lapse probabilities p are a linear function
of the zero coupon bond prices with p(0.9) = 90%, p(1.0) = 50% and p(1.1) = 10%, i.e. the higher
the interest rate the higher the lapse probability. We don’t use time dependent lapse behavior
and hence omit the subscript of p. As the contract terminates in ti = 3, lapse probabilities are
not needed here. Considering three time steps include all important cases for the desired lapse
modeling: Unconditional lapse on the full portfolio at ti = 1, conditional and still interest rate

33
7 QUANTUM HARDWARE RESULTS

Figure 10: Parametrization of the dynamic lapse circuit. Three time steps with two qubits each are provided
for the probability distribution. The corresponding random variables Zi are assumed independent and
uniformly distributed, considering that the basis states |00i are not used for the distribution. The dynamic
lapse functions p are linear and reflect that cancellation by customers is more likely in case of higher interest
rates.

dependent lapse for the remaining contracts at step two and eventually the incorporation of the
survivors.

As a proof of concept we start this section by running the circuit on a simulator. Parts of the
circuit are executed on real quantum hardware in the second part.

7.1 Simulator
The following results are generated by a simulator, i.e. the figures have been calculated on a clas-
sical computer using Qiskit’s quantum circuit simulator backend (”Aer Simulator”) in its default
configuration [13].

In figure 12 we show measurement results of the lapse register |ϕin . The measurement has been
performed at different steps of the circuit, which can be interpreted as different times ti = 0, ..., 3
of the stochastic process. Using the notation from the circuit illustration (figure 10), the state of
the lapse register has been measured before 2.1 (i.e. after initialization, we say ti = 0), before 2.2
(ti = 1) and so on. We see that the share of active contracts (state |000i) decreases by 50% in
each time step until the remaining part is shifted to |001i at ti = 3. Note that eventually there are
only three possible basis states, i.e. a contract can only be canceled once like formally shown in
equation (40).

Figure 12 shows the evolution of the result register |υis , again measured at different steps: Before
3.1 (ti = 0), before 3.2 (ti = 1) and finally at step 4. The state |00i represents the share of active
contracts and hence corresponds to the state |000i of the lapse register. The other states show

34
7 QUANTUM HARDWARE RESULTS

Figure 11: Time-evolution of the lapse register |ϕin . The first basis state |000i represents the amount of active
contracts and the time-evolution shows the successive transfer to the respective lapse dates ti = 1, . . . , 3: At
each time step 50% of the remaining contracts are canceled. The interest rate dependency is not visible in
these states.

Figure 12: Time-evolution of the result register |υis . Like in figure 11 the first basis state |00i represents
the share of active contracts. The remaining states correspond to the zero coupon bond prices showing that
cancellation is more likely in case of lower prices.

35
7 QUANTUM HARDWARE RESULTS

the distribution of the canceled contracts to the different zero coupon bond prices. If for example
the zero coupon price at ti = 1 is 0.9, the corresponding lapse probability is p(0.9) = 90% and
hence 90% of the contracts are canceled. As the probability for a zero coupon bond price Z1 = 0.9
amounts to 1/3, the share of contracts which are canceled in ti = 1 in case of Z1 = 0.9 amounts to
P(Z1 = 0.9) · p(0.9) ≈ 30%. After the first cancellation process there are 50% of active contracts
left. As the bond price distribution does not change (due to iid property), the cancellation works
equivalently to first time step, but only for the remaining contracts. Hence the probabilities for the
basis states k = 1, . . . , 3 are each increased by 50% · P(Z2 = k) · p(k). In the last step, the contracts
terminate as scheduled and hence there is no interest rate dependency. The remaining 25% of
active contracts (which is equal to the probability of ”surviving” time steps 1 and 2) are uniformly
distributed to the bond price basis states, i.e. each probability is increased by ca. 8%. Eventually
the customer behavior lowers the final payoff in this basic example: While the expected value would
be 1 for a uniform distribution, the interest rate dependent lapse shifts weight to lower bond prices
leading to the distribution shown in figure 12. For the given parametrization the expected value
amounts to ca. 0.96 after dynamic lapse.

7.2 Real Hardware

The simulator results from the previous section show that the exemplary dynamic lapse circuit
would deliver the expected payoff distribution on a sufficiently large fault-tolerant quantum com-
puter. In this section we show the results from running the circuit on the IBM Q System One in
Ehningen. Its processor type is Falcon r5.11 with 27 qubits. A quantum processor is also called
QPU (quantum processing unit).

Before we start, we briefly introduce the concept of universality. For details see [16], sections
4.3 and 4.4. A set of quantum gates is called universal if any operator can be ”replicated” by a
quantum circuit assembled from this set. Replicated in this context means that the original gate
can be approximated with arbitrary accuracy. One can show that (1) universal sets exist and (2)
the replication of any gate can be done efficiently if the universal set satisfies certain conditions.
In practice, every QPU has a universal set of gates which it can actually execute. These gates
are called basis gates of the processor. Hence, to run a circuit on a certain QPU, it needs to be
transpiled to the basis gates, i.e. each gate of the original circuit must√be replicated by the basis
gates. The basis gates of the Falcon QPU are: cnot, Identity, Rz (θ), not, not. Hence the set
consists of one 2-qubit gate and four 1-qubit gates. The transpiling is usually done by a compiler
and in high level programming, the coder usually does not care about the details. However, given
the early stage of quantum computing, this step may influence the results and is hence itself a
research topic. For this work, we did not concentrate on compiling and simply used the Qiskit
standards.

When we investigate the suitability of a quantum circuit to be run on real hardware, there are
basically two crucial properties: The width and the depth of the circuit. The circuit’s width deter-
mines how many qubits are needed (”vertical size”) and the depth is defined as the longest path
through the circuit (”horizontal size”). As QPUs allow for real parallelism, the depth presumes a
fully parallelized circuit.

Given a concrete quantum processor, the number of qubits must be greater or equal to the width
of a circuit. Otherwise the circuit cannot be run at all so that this can be regarded as the neces-
sary condition for executing a circuit on a certain QPU. This property is also referred to as the

36
7 QUANTUM HARDWARE RESULTS

QPU’s scale. Whether the processor is capable of the circuit’s depth depends on the quality of the
qubits. There are different ways for measuring the quality, but the attributes coherence time and
gate fidelity always play an important role. Coherence time tells us how long a qubit retains its
information. A perfectly isolated system maintains coherence indefinitely but since the heart of
quantum computing is the manipulation of qubits, they must interact with the environment which
in turn causes decoherence. If decoherence progresses, the state of the system can move away from
the encoded state and hence get less and less meaningful. The gate fidelity tells us something about
the precision of a gate. The higher the gate fidelity, the higher the confidence that a gate prepares
the theoretically expected state. Obviously the deeper the circuit the higher the requirements on
the QPU quality, i.e. on coherence time and gate fidelity. If the QPU quality is not sufficient for
a given circuit, the circuit can still be executed but the result will be meaningless. Hence we can
call the QPU quality the sufficient condition for running a circuit.

Wack et al [25] classify the scale, the quality and the speed to be the key attributes for measuring
performance of near-term quantum computers. In addition to the scale and the quality mentioned
above, the speed is defined as the time needed for executing a circuit. Of course the speed is also
important for getting a quantum advantage.

Now we will examine the necessary and the sufficient condition for executing the exemplary dynamic
lapse circuit described in the previous section on the Falcon r5.11 processor.

7.2.1 Necessary Condition

To assess the necessary condition we need to compare the circuits width with the QPU’s scale. The
exemplary dynamic lapse circuit requires 17 qubits: 3x2 qubits for the underlying distribution, 3
for the stopping time, 2 for the payoff distribution and 6 ancillas for the linear amplitude functions.
Hence the necessary condition is fulfilled and it can be executed on the Falcon processor with
27 qubits. Note that this is the most simplified but still meaningful case. Also note that the
actual width of the circuit is 19, because we additionally need two classical bits for storing the
measurement outcome of the result register.

7.2.2 Sufficient Condition

To assess the sufficient condition we need to compare the circuits depth with the QPU’s quality.
The depth of a circuit can be considered on different levels. For example, counting the operations
in figure 9 leads to a high level depth of 10: 1 gate for distribution loading (A), 3 gates for the
stopping time (Pti ) and 3x2 gates for the the sum of time steps (ccnot). Obviously this figure is
not very useful, because the high level gates have varying costs. The costs of a gate are a measure
for the quality requirements. To get a comparable figure we first transpile the circuit to the basis
gates of the processor and then assign a cost to each basis gate. The latter is important, because
even the basis gates have different costs. Lee et. al [17] define the cost of a quantum gate as the
number of basic physical operations needed for its implementation. Table 1 shows the costs they
propose for Falcon’s basis gates. Note that the 2-qubit gate not is much more expensive than the
single qubit rotations.

To get an idea of how expensive the different operations of the dynamic lapse circuit are, we show
the depth and the costs at each step in the table 2. The table also shows the number of the re-
spective basis gates along the longest path always assuming maximum parallelization. The figures

37
8 AN OVERVIEW OF CURRENT QUANTUM COMPUTING TECHNOLOGY

are cumulative, e.g. step 3.1 represents the entire circuit until and including this step. While the
implementation of the uniform distribution is relatively cheap, we see immediately that the linear
amplitude function in step 2.1 and particularly its controlled version in step 2.2 is very expensive.
The summation in step 3 does not increase the costs a lot, because large parts can be done in
parallel to step 2.

The results shown in figure 13 lead to an assessment of the QPU quality. Measuring after step 2.1
delivers results which are close the simulator (see the state of lapse register at t1 ). That shows that
the QPU quality is at least sufficient for circuits with costs around 300. The sharply increased costs
at step 2.2 leads to more or less meaningless results at step 2.2 (lapse register at t2 ). Since the state
of the qubit system is already meaningless at this step, we don’t show the measurement results for
step 3. Note that we did not concentrate on result improvements by circuit optimization. Potential
next steps for improving the results could be the application of error mitigation techniques and
searching for alternative implementations of the stopping time.

Basis gate Cost

cnot 5
Identity 1
Rz (θ)
√ 1
not 1
not 1

Table 1: The costs of Falcon’s basis gates according to [17], where the cost of a quantum gate is defined
as the number of basic physical operations needed for its implementation. Obviously the number of cnots
drives the total cost. The higher the cost the higher the requirements on the QPU’s quality.

8 An Overview of current Quantum Computing Technology

We are in the era of Noisy Intermediate-Scale Quantum (NISQ) technology. The term was in-
troduced by John Preskill in 2018 [20] and should emphasize that currently available quantum
computers are neither fault-tolerant nor do they have a large number of qubits. His main message
is that ”we may feel confident that quantum technology will have a substantial impact on society in
the decades ahead, but we cannot be nearly so confident about the commercial potential of quantum
technology in the near term, say the next five to ten years.” He concludes that fault-tolerance must
be the essential longer-term goal and that the necessary efforts to reach this goal are worth it. The

√
Step cnot Rz (θ) not not Depth Cost
1 1 4 4 0 9 13
2.1 47 47 26 2 122 310
2.2 485 467 133 1 1086 3026
2.3 488 471 134 1 1094 3046
3.1 490 470 133 1 1094 3054
3.2 494 475 134 1 1104 3080
3.3 498 480 135 1 1114 3106

Table 2: Cumulative counts and costs for the longest path until and including step N . We can see that the
distribution loading is relatively cheap while the stopping time is the most expensive part.

38
8 AN OVERVIEW OF CURRENT QUANTUM COMPUTING TECHNOLOGY

Figure 13: Comparison of simulator and real hardware results for the lapse register. We can see that the
first lapse event delivers results which are close to the theoretical expectation. After a tenfold increase of
the costs by the controlled linear amplitude function at step 2.2, the QPU returns more or less meaningless
results.

recently updated IBM development road map [6] covers the period until 2025. During this period
they predict an increasing number of qubits from currently less than 100 up to 4K+ accompanied
by error mitigation and growing software development frameworks. Actual error correction and
scaling to 10K-100K qubits is targeted ”beyond 2026”.

8.1 Software
Several quantum computing developments libraries are available. The probably most popular ones
are IBM’s Qiskit [13], Google’s Cirq [7] and Microsoft’s Quantum Development Kit [19]. All of
them are open-source. While Qiskit and Cirq are based in Python, Microsoft introduces a dedicated
quantum programming language called Q#. We won’t analyze the details and differences of these
frameworks but want to demonstrate the general idea of how they work. In particular we want
to emphasize that everyone can start implementing quantum algorithms right away and thanks to
cloud quantum computers, even the technical barriers to running it on real hardware are rather
small. Although programming level is still low (meaning that we are operating on qubit level), the
mentioned frameworks provide toolkits which allow for comfortable circuit assembling based on a
growing library of generic circuits.

The following code example shows that Qiskit literally works like a kit: We gather the needed
building blocks, assemble them as we like and finally execute the circuit on a provided backend. In
this case we are using a simulator, i.e. the quantum computer is simulated on a classical one. To
run the circuit on real hardware, we only need to get another backend, i.e. just one line of code
needs to be adjusted.
from qiskit import Aer, QuantumRegister, ClassicalRegister, QuantumCircuit, execute
from qiskit.circuit.library import WeightedAdder

# initialize adder
weighted_adder = WeightedAdder(num_state_qubits=2, weights=[1, 1])

# build empty quantum circuit with proper number of qubits

qreg = QuantumRegister(size=weighted_adder.num_qubits)

39
8 AN OVERVIEW OF CURRENT QUANTUM COMPUTING TECHNOLOGY

creg = ClassicalRegister(size=weighted_adder.num_sum_qubits)
circuit = QuantumCircuit(qreg, creg)

# assemble circuit from available gates/circuits

circuit.h(qreg[0])
circuit.h(qreg[1])
circuit.append(weighted_adder, qreg)

# add a measurement to the adder’s sum qubits

circuit.measure(qreg[weighted_adder.num_state_qubits:
weighted_adder.num_state_qubits
+weighted_adder.num_sum_qubits], creg)

# get simulator and run the circuit 1000 times

simulator = Aer.get_backend(’aer_simulator’)
job = execute(circuit, simulator, shots=1000)
result = job.result()

# print the result statistics

print(result.get_counts(circuit))
# output: {’10’: 502, ’00’: 231, ’01’: 267}

For the sake of completeness: We are adding two qubits in state H(|0i) = √12 (|0i+|1i) each weighted
with 1, where H denotes the Hadamard gate. Hence the possible results are 0 + 0, 1 + 0, 0 + 1, 1 + 1,
each with probability 1/4. The circuit is illustrated in figure 14. Please note that the weighted
adder is an example of available generic circuits. Under the hood, it is actually a sequence of
nots, cnots and ccnots. The components of the dynamic lapse circuit from figure 9 can also be
encapsulated to contribute three generic circuits to the library: (1) The multivariate distribution,
(2) the stopping time and (3) the stopped process.

|0i H √1 (|0i + |1i)

2

|0i H adder √1 (|0i + |1i)

2

|00i √1 |00i + √1 |10i + √1 |01i

4 2 4

Figure 14: Circuit illustration of the code fragment including the generic adder gate, which encapsulates a
sequence of (controlled) nots.

Finally note that although there are existing and growing frameworks the status quo of quantum
software development is still very basic. For example there are no data structures like lists or
dictionaries and there are only very few quantum algorithms available.

8.2 Hardware
In our work we focus on gate-based quantum computers. The underlying principle is the descrip-
tion of interactions between qubits and gates in a quantum circuit model. This is closely related to
classical computers with of course different kind of memory units (qubits vs bits) and different kind
operating units (quantum vs. classical gates). Many of the well-known quantum algorithms like
Shor’s factoring algorithm [22] or Grover’s search algorithm [10] are expressed in a circuit model.
IBM’s Q System One is a gate-based quantum computer with 27 qubits using heavy-hexagon ar-

40
9 CONCLUSION

chitecture [4], illustrated in figure 15.

6 17

0 1 4 7 10 12 15 18 21 23

2 13 24

3 5 8 11 14 16 19 22 25 26

9 20

Figure 15: Heavy-hexagon architecture of the IBM Q System One with 27 qubits, which was used for the
experiments in section 7. The processor type is Falcon r5.11. According to IBM, this topology reduces error
rates and should help reaching the ultimate goal of demonstrating fault-tolerance [4].

In contrast to gate-based devices, Quantum Annealing requires a problem to be formulated as

quadratic unconstrained binary optimization problem (QUBO). This is less generic than the gate-
based approach, but currently available hardware is further advanced. For example, D-Wave Sys-
tems claims to provide the most powerful quantum computer in the world with 5K qubits. We
won’t dig deeper into the quantum annealing and refer to [15] for the theoretical foundation and
to D-Wave’s documentation [5] for an application manual.

We only gave a very short overview of the current status of quantum technology. The main points
we want to emphasize is that (1) both soft- and hardware are in their infancies (2) there is a lot
of activity in both areas and (3) the best solutions are still to be found. It is not clear whether a
universal gate-based computer is needed or if a quantum annealer better solves practical problems.
Likewise we don’t know if millions of qubits are necessary or if a small number of high quality would
be more beneficial. Also hybrid approaches with QPUs, GPUs and CPUs (quantum, graphical and
central processing units) are promising, where each unit is doing what it is best suited for.

9 Conclusion
Quantum computing is still in its infancy. The basis of quantum mechanics have been developed in
the first half of the 20th century and the first approaches to quantum computing date back to the
80s. In the following decades several promising but from the lack of hardware, mostly theoretical
results have been achieved, e.g. Shor’s prime factoring algorithm. However in recent years activi-
ties have increased and some milestones have been reached. Amongst these the introduction of the
first circuit-based commercial quantum computer in 2019, IBM’s Q System One. In 2021 a unit
of this system has been deployed in Germany, being the first quantum computer in Europe. IBM
updated their ambitious quantum road map in May 2022 showing a combined path of soft- and
hardware development until 2025 and beyond. Other big players like Google (”Google Quantum
AI”) or Microsoft increase their efforts and are already providing quantum software development
kits. McKinsey [18] counts a total amount of $31 billion of funding for quantum technologies since
2001 and expect the impact on financial industry ”incremental” until 2030 but ”significant” until

41
REFERENCES

2035. It is common sense that the question is less whether, but when quantum computing becomes
a game changer in many areas.

There are different aspects to be considered for the insurance industry. In this paper we focused
on the quadratic speed-up of Monte Carlo simulations and how this could be applied to valuate
life insurance contracts. We see a lot of work ahead of us, but some quantum circuits which model
”insurance-relevant” behavior like general optionality or dynamic lapse are already available. Hence
we consider the goal of being able to dynamically valuate an insurance balance sheet achievable.
Of course this is subject to the invention of a fault-tolerant quantum computer. We think that
soft- and hardware research should ideally progress jointly so that they mutually fulfill their needs.
Aside from direct application for simulation or optimization, insurance companies will benefit from
developing quantum computing know-how. As insurance services affect many areas of life, most
future impacts of quantum computing will somehow also affect insurance business. This could be
topics like cyber security, medical products or logistics. At the current status we finally conclude
that a moderate investment in quantum computing is profitable for insurance companies. To be
able to benefit from future inventions, building up know-how and tracking ongoing developments
should start right now.

References
[1] Daniel Bauer, Andreas Reuss, Daniela Singer On the calculation of the solvency capital re-
quirement based on nested simulations The Journal of the International Actuarial Association
42(2), 453–499 (2012)

[2] Peter Boekel, Lotte van Delft, Takanori Hoshino, Rikiya Ino, Craig Reynolds, Henny Verheugen
Replicating Portfolios - An Introduction: Analysis and Illustrations Milliman Research Report
(2009)

[3] Gilles Brassard, Peter Høyer, Michele Mosca, Alain Tapp Quantum Amplitude Amplification
and Estimation Quantum Computation and Quantum Information, Samuel J. Lomonaco, Jr.
(editor), AMS Contemporary Mathematics, 305:53-74 (2002)

[4] Andrew Cross, Paul Nation, Zaira Nazario, Hanhee Paik The IBM Quantum heavy hex lattice
https://research.ibm.com/blog/heavy-hex-lattice Accessed August 2, 2022 (2021)

[5] D-Wave D-Wave System Documentation https://docs.dwavesys.com/docs/latest/ Ac-

cessed August 2, 2022 (2022)

[6] Jay Gambetta Expanding the IBM Quantum roadmap to anticipate the future of quantum-
centric supercomputing https://research.ibm.com/blog/ibm-quantum-roadmap-2025 Ac-
cessed July 26, 2022 (2022)

[7] Google Cirq Website https://quantumai.google/cirq Accessed July 29, 2022 (2022)

[8] Paul Glassermann Monte Carlo Methods in Financial Engineering Springer Verlag (2003)

[9] Dmitry Grinko, Julien Gacon, Christa Zoufal, Stefan Woerner Iterative Quantum Amplitude
Estimation, npj Quantum Inf 7, 52 (2021)

[10] Lov Grover A Fast Quantum Mechanical Algorithm for Database Search Proceedings of the
28th Annual ACM Symposium on the Theory of Computing (STOC), 212–219 (1996)

42
REFERENCES

[11] Lov Grover, Terry Rudolph Creating superpositions that correspond to efficiently integrable
probability distributions, arXiv:quant-ph/0208112 (2002)

[12] Jack D. Hidary Quantum Computing: An Applied Approach, Springer (2019)

[13] IBM Qiskit Website https://qiskit.org/ Accessed July 28, 2022 (2022)

[14] Raban Iten, Roger Colbeck, Ivan Kukuljan, Jonathan Home, Matthias Christandl Quantum
Circuits for Isometries, Phys. Rev. A 93, 032318 (2016)

[15] Tadashi Kadowaki, Hidetoshi Nishimori Quantum annealing in the transverse Ising model,
Phys. Rev. E. 58 (5): 5355 (1998)

[16] Phillip Kaye, Raymond Laflamme, Michele Mosca An Introduction to Quantum Computing,
Oxford University Press (2007)

[17] Soonchil Lee, Seong-Joo Lee, Taegon Kim1,Jae-Seung Lee, Jacob Biamonte, Marek Perkowski
The Cost of Quantum Gate Primitives Journal of Multiple-valued Logic and Soft Computing
12(5):561-573 (2006)

[18] Mateusz Masiowski, Niko Mohr, Henning Soller, and Matija Zesko Quan-
tum computing funding remains strong, but talent gap raises concern https:
//www.mckinsey.com/business-functions/mckinsey-digital/our-insights/
quantum-computing-funding-remains-strong-but-talent-gap-raises-concern Ac-
cessed July 29, 2022 (2022)

[19] Microsoft Quantum Development Kit Website https://azure.microsoft.com/de-de/

resources/development-kit/quantum-computing/ Accessed July 29, 2022 (2022)

[20] John Preskill Quantum Computing in the NISQ era and beyond, Quantum 2, 79 (2018)

[21] Patrick Rebentrost, Brajesh Gupt, Thomas R. Bromley Quantum computational finance:
Monte carlo pricing of financial derivatives, Phys. Rev. A 98, 022321 (2018)

[22] Peter Shor Algorithms for quantum computation: discrete logarithms and factoring, Proceed-
ings 35th Annual Symposium on Foundations of Computer Science. IEEE Comput. Soc. Press:
124–134 (1994)

[23] Nikitas Stamatopoulos, Daniel J. Egger, Yue Sun, Christa Zoufal, Raban Iten, Nig Shen,
Stefan Woerner Option Pricing using Quantum Computers, Quantum 4, 291 (2020)

[24] Yohichi Suzuki, Shumpei Uno, Rudy Raymond, Tomoki Tanaka, Tamiya Onodera, Naoki
Yamamoto Amplitude estimation without phase estimation, Quantum Information Processing
19, 75 (2020)

[25] Andrew Wack, Hanhee Paik, Ali Javadi-Abhari, Petar Jurcevic, Ismael Faro, Jay M. Gambetta,
Blake R. Johnson Quality, Speed, and Scale: three key attributes to measure the performance
of near-term quantum computers, arXiv:2110.14108 (2021)

[26] Stefan Woerner, Daniel J. Egger Quantum risk analysis, npj Quantum Inf 5, 15 (2019)

[27] Christa Zoufal, Aurélien Lucchi, Stefan Woerner Quantum generative adversarial networks for
learning and loading random distributions, npj Quantum Information 5, 1–9 (2019)

43