arXiv:2502.

01146v1 [quant-ph] 3 Feb 2025

Quantum Machine Learning

A Hands-on Tutorial for Machine Learning
Practitioners and Researchers

Yuxuan Du1,∗,† Xinbiao Wang1,∗ Naixu Guo2,∗

Zhan Yu2,∗ Yang Qian1,∗ Kaining Zhang1,∗
Min-Hsiu Hsieh3,↿ Patrick Rebentrost2,⊥ Dacheng Tao1,‡

1
College of Computing and Data Science, Nanyang Technological University,
639798, Singapore
2
Centre for Quantum Technologies, National University of Singapore, 117543,
Singapore
3
Hon Hai Research Institute, Taipei, 114, Taiwan

†
duyuxuan123@[Link]
↿
[Link]@[Link]
⊥
cqtfpr@[Link]
‡
[Link]@[Link]

∗
Equal contributions
ii
Abstract

This tutorial intends to introduce readers with a background in AI to quan-

tum machine learning (QML)—a rapidly evolving field that seeks to lever-
age the power of quantum computers to reshape the landscape of machine
learning. For self-consistency, this tutorial covers foundational principles,
representative QML algorithms, their potential applications, and critical
aspects such as trainability, generalization, and computational complex-
ity. In addition, practical code demonstrations are provided in https:
//[Link]/ to illustrate real-world implementations and
facilitate hands-on learning. Together, these elements offer readers a com-
prehensive overview of the latest advancements in QML. By bridging the
gap between classical machine learning and quantum computing, this tuto-
rial serves as a valuable resource for those looking to engage with QML and
explore the forefront of AI in the quantum era.

iii
iv
Contents

Preface ix

1 Introduction 1
1.1 A First Glimpse of Quantum Machine Learning . . . . . . . . 3
1.1.1 Quantum computers . . . . . . . . . . . . . . . . . . . 3
1.1.2 Different measures of quantum advantages . . . . . . . 7
1.1.3 Explored tasks in quantum machine learning . . . . . 9
1.2 Progress of Quantum Machine Learning . . . . . . . . . . . . 11
1.2.1 Progress of quantum computers . . . . . . . . . . . . . 11
1.2.2 Progress of quantum machine learning under FTQC . 13
1.2.3 Progress of quantum machine learning under NISQ . . 15
1.2.4 A brief review of quantum machine learning . . . . . . 18
1.3 Organization of This Tutorial . . . . . . . . . . . . . . . . . . 19

2 Basics of Quantum Computing 21

2.1 From Classical Bits to Quantum Bits . . . . . . . . . . . . . . 21
2.1.1 Classical bits . . . . . . . . . . . . . . . . . . . . . . . 22
2.1.2 Quantum bits (Qubits) . . . . . . . . . . . . . . . . . 22
2.1.3 Density matrix . . . . . . . . . . . . . . . . . . . . . . 26
2.2 From Digital Logical Circuit to Quantum Circuit Model . . . 28
2.2.1 Classical digital logical circuit . . . . . . . . . . . . . . 28
2.2.2 Quantum circuit . . . . . . . . . . . . . . . . . . . . . 30
2.3 Quantum Read-in and Read-out protocols . . . . . . . . . . . 41
2.3.1 Quantum read-in protocols . . . . . . . . . . . . . . . 42
2.3.2 Quantum read-out protocols . . . . . . . . . . . . . . 46
2.4 Quantum Linear Algebra . . . . . . . . . . . . . . . . . . . . 52
2.4.1 Block encoding . . . . . . . . . . . . . . . . . . . . . . 53
2.4.2 Basic arithmetic for block encodings . . . . . . . . . . 54
2.4.3 Quantum singular value transformation . . . . . . . . 56

v
vi CONTENTS

2.5 Code Demonstration . . . . . . . . . . . . . . . . . . . . . . . 58

2.5.1 Read-in implementations . . . . . . . . . . . . . . . . 58
2.5.2 Block encoding . . . . . . . . . . . . . . . . . . . . . . 60
2.6 Bibliographic Remarks . . . . . . . . . . . . . . . . . . . . . . 61
2.6.1 Advanced quantum read-in protocols . . . . . . . . . . 61
2.6.2 Advanced quantum read-out protocols . . . . . . . . . 63
2.6.3 Advanced quantum linear algebra . . . . . . . . . . . 64

3 Quantum Kernel Methods 67

3.1 Classical Kernel Machines . . . . . . . . . . . . . . . . . . . . 68
3.1.1 Motivation of kernel methods . . . . . . . . . . . . . . 68
3.1.2 Dual representation . . . . . . . . . . . . . . . . . . . 71
3.1.3 Kernel construction . . . . . . . . . . . . . . . . . . . 73
3.2 Quantum Kernel Machines . . . . . . . . . . . . . . . . . . . 76
3.2.1 Motivations for quantum kernel machines . . . . . . . 76
3.2.2 Quantum feature maps and quantum kernel machines 77
3.2.3 Relation between quantum and classical kernel machines 80
3.2.4 Concrete examples of quantum kernels . . . . . . . . . 81
3.3 Theoretical Foundations of Quantum Kernel Machines . . . . 86
3.3.1 Expressivity of quantum kernel machines . . . . . . . 87
3.3.2 Generalization of quantum kernel machines . . . . . . 91
3.4 Code Demonstration . . . . . . . . . . . . . . . . . . . . . . . 98
3.4.1 Classification on MNIST dataset . . . . . . . . . . . . 99
3.5 Bibliographic Remarks . . . . . . . . . . . . . . . . . . . . . . 106
3.5.1 Quantum kernel design . . . . . . . . . . . . . . . . . 107
3.5.2 Theoretical studies of quantum kernels . . . . . . . . . 108
3.5.3 Applications of quantum kernels . . . . . . . . . . . . 110

4 Quantum Neural Networks 113

4.1 Classical Neural Networks . . . . . . . . . . . . . . . . . . . . 114
4.1.1 Perceptron . . . . . . . . . . . . . . . . . . . . . . . . 114
4.1.2 Multilayer perceptron . . . . . . . . . . . . . . . . . . 118
4.2 Fault-tolerant Quantum Perceptron . . . . . . . . . . . . . . . 122
4.2.1 Grover search . . . . . . . . . . . . . . . . . . . . . . . 122
4.2.2 Online quantum perceptron with quadratic speedups . 124
4.3 Near-term Quantum Neural Networks . . . . . . . . . . . . . 128
4.3.1 General framework . . . . . . . . . . . . . . . . . . . . 129
4.3.2 Discriminative learning with QNNs . . . . . . . . . . . 134
4.3.3 Generative learning with QNNs . . . . . . . . . . . . . 135
4.4 Theoretical Foundations of Quantum Neural Networks . . . . 140
CONTENTS vii

4.4.1 Expressivity and generalization of quantum neural net-

works . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
4.4.2 Trainability of quantum neural networks . . . . . . . . 150
4.5 Code Demonstration . . . . . . . . . . . . . . . . . . . . . . . 155
4.5.1 Quantum classifier . . . . . . . . . . . . . . . . . . . . 155
4.5.2 Quantum patch GAN . . . . . . . . . . . . . . . . . . 163
4.6 Bibliographic Remarks . . . . . . . . . . . . . . . . . . . . . . 171
4.6.1 Discriminative learning with QNN . . . . . . . . . . . 171
4.6.2 Generative learning with QNNs . . . . . . . . . . . . . 175

5 Quantum Transformer 179

5.1 Classical Transformer . . . . . . . . . . . . . . . . . . . . . . 180
5.1.1 Tokenization and embedding . . . . . . . . . . . . . . 180
5.1.2 Self-attention . . . . . . . . . . . . . . . . . . . . . . . 182
5.1.3 Residual connection . . . . . . . . . . . . . . . . . . . 183
5.1.4 Feed-forward network . . . . . . . . . . . . . . . . . . 184
5.1.5 Optimization and inference . . . . . . . . . . . . . . . 185
5.2 Fault-tolerant Quantum Transformer . . . . . . . . . . . . . . 186
5.2.1 Quantum self-attention . . . . . . . . . . . . . . . . . 188
5.2.2 Quantum residual connection and layer normalization 194
5.2.3 Quantum feedforward neural network . . . . . . . . . 196
5.3 Runtime Analysis with Quadratic Speedups . . . . . . . . . . 198
5.3.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . 198
5.3.2 Numerical evidence . . . . . . . . . . . . . . . . . . . . 199
5.4 Code Demonstration . . . . . . . . . . . . . . . . . . . . . . . 201
5.5 Bibliographic Remarks . . . . . . . . . . . . . . . . . . . . . . 203

6 Conclusion 205

A Notations Summary 207

B Concentration Inequality 209

C Haar Measure and Unitary t-design 213

viii CONTENTS
Preface

Quantum computers, as next-generation computational devices, harness the

quantum principles of superposition and entanglement to process informa-
tion in ways fundamentally different from classical computers. These unique
properties enable quantum computers to address many practical problems
that are intractable for classical computers. Although quantum computing
is still in its early stages, we have entered an era since 2019 where quan-
tum supremacy has been experimentally demonstrated by several research
groups and industrial organizations, underscoring the immense potential of
quantum technologies to transform various aspects of everyday life.
Machine learning (ML) is widely regarded as one of the most promising
and impactful applications of quantum computing. The ability of quan-
tum computing to accelerate advancements in foundational models, such
as generative pre-trained transformers (GPTs), and even pave the way to-
ward artificial general intelligence (AGI), is particularly compelling. Recent
progress in both theories and experiments has exhibited the power of quan-
tum machine learning (QML), where the integration of quantum computing
with machine learning may lead to novel approaches that outperform classi-
cal algorithms by offering faster runtimes, better performance, and reduced
data requirements in areas such as computer vision, natural language pro-
cessing, drug discovery, finance, and fundamental science.
As an interdisciplinary field, the development of QML requires close col-
laboration between leading scientists and engineers in both quantum com-
puting and artificial intelligence (AI). At the same time, as QML advances
alongside the continuous progress of quantum hardware, there is a grow-
ing need for expertise from the AI community to drive this emerging field
forward. However, the distinct conceptual frameworks and terminologies of
quantum and classical computing present significant barriers for researchers
and practitioners with a classical machine learning background in under-
standing the mechanisms behind QML algorithms and the benefits they
may offer. Reducing this barrier to entry remains a major challenge within

ix
x Preface

the community.
To overcome this challenge, we have written this tutorial to deliver a
comprehensive introduction to the latest developments in QML, specifically
designed for readers with expertise in machine learning. Whether you are
an AI researcher, a machine learning practitioner, or a computer science
student, this resource will equip you with a solid foundation in the principles
and techniques of QML. By bridging the gap between classical ML and
quantum computing, this tutorial could serve as a useful resource for those
looking to engage with quantum machine learning and explore the forefront
of AI in the quantum era.

The Authors
Feb, 2025
Chapter 1

Introduction

The advancement of computational power has always been a driving force

behind every major industrial revolution. The invention of the modern com-
puter, followed by the central processing unit (CPU), led to the “digital rev-
olution”, transforming industries through process automation and the rise
of information technology. More recently, the development of graphical pro-
cessing units (GPUs) has powered the era of artificial intelligence (AI) and
big data, enabling breakthroughs in areas such as intelligent transportation
systems, autonomous driving, scientific simulations, and complex data anal-
ysis. However, as we approach the physical and practical limits of Moore’s
law—the principle that the number of transistors on a chip doubles approxi-
mately every two years—traditional computing devices like CPUs and GPUs
are nearing the end of their scaling potential. The ever-growing demand for
computational power, driven by the exponential increase in data and the
complexity of modern applications, necessitates new computing paradigms.
Among the leading candidates to meet these challenges are quantum com-
puters (Feynman, 2017), which leverage the unique principles of quantum
mechanics such as superposition and entanglement to process information
in ways that classical systems cannot, with the potential to revolutionize
diverse aspects of daily life.
One of the most concrete and direct ways to understand the potential
of quantum computers is through the framework of complexity theory (Wa-
trous, 2008). Theoretical computer scientists have demonstrated that quan-
tum computers can efficiently solve problems within the BQP (Bounded-
Error Quantum Polynomial Time) complexity class, meaning these prob-
lems can be solved in polynomial time by a quantum computer. In contrast,
classical computers are limited to efficiently solving problems within the P

1
2 CHAPTER 1. INTRODUCTION

(Polynomial Time) complexity class. While it is widely believed, though not

proven, that P ⊆ BQP, this suggests that quantum computers can provide
exponential speedups for certain problems in BQP that are intractable for
classical machines.

A prominent example of such a problem is large-number factorization,

which forms the basis of RSA cryptography. Shor’s algorithm (Shor, 1999), a
quantum algorithm, can factor large numbers in polynomial time, while the
most efficient known classical factoring algorithm requires super-polynomial
time. For instance, breaking an RSA-2048 bit encryption key would take a
classical computer approximately 300 trillion years, whereas an ideal quan-
tum computer could complete the task in around 10 seconds. However,
constructing ‘ideal’ quantum computers remains a significant challenge. As
will be discussed in later chapters, based on current fabrication techniques,
this task could potentially be completed in approximately 8 hours using a
noisy quantum computer with a sufficient number of qubits—the funda-
mental units of quantum computation (Gidney and Ekerå, 2021).

The convergence of the computational power offered by quantum ma-

chines and the limitations faced by AI models has led to the rapid emergence
of the field: quantum machine learning (QML) (Biamonte et al., 2017).
In particular, the challenges in modern AI stem from the neural scaling law
(Kaplan et al., 2020), which posits that “bigger is often better.” Since 2020,
this principle has driven the development of increasingly colossal models,
featuring more complex architectures and an ever-growing number of pa-
rameters. However, this progress comes at an immense cost. For instance,
training a model like ChatGPT on a single GPU would take approximately
355 years, while the cloud computing costs for training such large models
can reach tens of thousands of dollars.

These staggering costs present a critical barrier to the future growth of

AI. Quantum computing, celebrated for its extraordinary computational ca-
pabilities, holds the potential to overcome these limitations. It offers the pos-
sibility of advancing models like generative pre-trained transformers (GPTs)
and accelerating progress toward artificial general intelligence (AGI). Quan-
tum computing, and more specifically QML, represents a paradigm shift,
moving from the classical “it from bit” framework to the quantum “it from
qubit” era, with the potential to reshape the landscape of AI and computa-
tional science.
1.1. A FIRST GLIMPSE OF QUANTUM MACHINE LEARNING 3

1.1 A First Glimpse of Quantum Machine Learn-

ing
So, what exactly is quantum machine learning (QML)? In its simplest terms,
the focus of this tutorial on QML can be summarized as follows (see Chap-
ter 1.1.3 for the systematic overview).

Quantum machine learning (informal)

QML explores learning algorithms that can be executed

on quantum computers to accomplish specified tasks with
potential advantages over classical implementations.

The three key elements in the above interpretation are: quantum proces-
sors, specified tasks, and advantages. In what follows, let us elucidate the
specific meaning of each of these terms, providing the necessary foundation
for a deeper understanding of the mechanisms and potential of QML.

1.1.1 Quantum computers

The origins of quantum computing can be traced back to 1980 when Paul
Benioff introduced the quantum Turing machine (Benioff, 1982), a quantum
analog of the classical Turing machine designed to describe computational
models through the lens of quantum theory. Since then, several models
of quantum computation have emerged, including circuit-based quantum
computation (Nielsen and Chuang, 2011), one-way quantum computation
(Raussendorf and Briegel, 2001), adiabatic quantum computation (Albash
and Lidar, 2018), and topological quantum computation (Kitaev, 2003). All
of them have been shown to be computationally equivalent to the quan-
tum Turing machine, meaning that a perfect implementation of any one of
these models can simulate the others with no more than polynomial over-
head. Given the prominence of circuit-based quantum computers in
both the research and industrial communities and their rapid advancement,
this tutorial will focus primarily on this model of quantum computing.
Quantum computing gained further momentum in the early 1980s when
physicists faced an exponential increase in computational overhead while
simulating quantum dynamics, particularly as the number of particles in
a system grew. This “curse of dimensionality” prompted Yuri Manin and
Richard Feynman to independently propose leveraging quantum phenomena
to build quantum computers, arguing that such devices would be far more
4 CHAPTER 1. INTRODUCTION

Classical Computing VS Quantum Computing

Classical Computation
Input (Algorithm) Output
7 Bits
0111001 [Digital Logic Circuits]
Input
0000000 Quantum Computation
7 Qubits 0000001 (Algorithm) Output
…. [Quantum Circuits]
1111111

Figure 1.1: The paradigm between classical and quantum comput-

ing. The mechanisms between classical and quantum computing are very
similar, where both of them involve input, computation, and output. In
classical computing, the input refers to a bit-string, the computation part
refers to the digital logic circuits, and the output also refers to a bit-string.
In quantum computing, the input is a single- or multi-qubit state. The com-
putation involves quantum circuits. And the output of quantum computers
requires quantum measurement, which aims to extract information from the
quantum world to the classical world.

efficient for simulating quantum systems than classical computers.

However, as a universal computing device, the potential of quantum
computers extends well beyond quantum simulations. In the 1990s, Shor
(1999) developed a groundbreaking quantum algorithm for large-number
factorization, posing a serious threat to widely used encryption protocols
such as RSA and Diffie–Hellman. In 1996, Grover’s algorithm demonstrated
a quadratic speedup for unstructured search problems (Grover, 1996), a task
with broad applications. Since then, the influence of quantum computing has
expanded into a wide range of fields, with new quantum algorithms being
developed to achieve runtime speedups in areas such as finance (Herman
et al., 2023), drug design (Santagati et al., 2024), optimization (Abbas et al.,
2024), and, most relevant to this tutorial, machine learning.
An intuitive way to understand why quantum computers can outperform
classical computers is by comparing their fundamental components. As illus-
trated in Figure 1.1, both types of computers consist of three fundamental
components: input, the computational process, and the output. The imple-
mentation of these three components in classical and quantum computing is
summarized in Table 1.1.
The advantages of quantum computers stem primarily from the key dis-
tinctions between classical bits and quantum bits (qubits), as well as be-
1.1. A FIRST GLIMPSE OF QUANTUM MACHINE LEARNING 5

Table 1.1: Comparison between classical and quantum computing.

Classical Quantum
Input Binary bits Quantum bits
Computation Digital logical circuits Quantum circuits
Output Retrieve solution Quantum measurements

tween digital logic circuits and quantum circuits, as outlined below:

• Bits versus Qubits. A classical bit is a binary unit that takes on a value
of either 0 or 1. In contrast, a quantum bit, or qubit, can exist in a
superposition of both 0 and 1 simultaneously, represented by a two-
dimensional vector where the entries correspond to the probabilities of
the qubit being in each state.
Furthermore, while classical bits follow the Cartesian product rule,
qubits adhere to the tensor product rule. This distinction implies that
an N -qubit system is described by a 2N -dimensional vector, allowing
quantum systems to encode information exponentially with N —far
surpassing the capacity of classical bits. Table 1.2 summarizes the
mathematical expressions of classical and quantum bits.

Table 1.2: Mathematical representations of N -(quantum) bits in

classical and quantum computers. Here the symbols ‘†’ and C denote
the transpose conjugation and complex space, respectively.
Classical Quantum
[a1 , a2 ]† ∈ C2
Single bit (N = 1) x ∈ {0, 1}
s.t. a21 + a22 = 1
N
s.t.[a1 , a2 , ..., a2N ]† ∈ C2
Multiple bits (N > 1) x ∈ {0, 1}N
s.t. a21 + a22 + ... + a22N = 1

• Digital logic circuits versus quantum circuits. Classical computers rely

on digital logic circuits composed of logic gates that perform opera-
tions on bits in a deterministic manner, as illustrated in Figure 1.1.
In contrast, quantum circuits consist of quantum gates, which act
on single or multiple qubits to modify their states—the probability
amplitudes a1 , ..., a2N , as shown in Table 1.2. Owing to the univer-
sality of quantum gates, for any given input qubit state, there always
exists a specific quantum circuit capable of transforming the input
6 CHAPTER 1. INTRODUCTION

state into one corresponding to the target solution—a particular prob-

ability distribution. For certain probability distributions, a quantum
computer can use a polynomial number of quantum gates relative to
the qubit count N to generate the distribution, whereas classical com-
puters require an exponential number of gates with N to achieve the
same result. This difference underpins the quantum advantage.

• The readout process in quantum computing differs fundamentally from

that in classical computing, as it involves quantum measurements,
which extract information from a quantum system and translate it into
a form that can be interpreted by classical systems. For problems in
quantum physics and chemistry, quantum measurements can reveal far
more useful information than classical simulations of the same systems,
enabling significant runtime speedups in obtaining the desired physical
properties.

The formal definitions of quantum computing are presented in Chapter 2.

As we will see, the power of quantum computers is primarily determined by
two factors: the number of qubits and the quantum gates, as well as their
respective qualities. The term “qualities” refers to the fact that fabricating
quantum computers is highly challenging, as both qubits and quantum gates
are prone to errors. These qualities are measured using various physical
metrics. One commonly used metric is quantum volume VQ (Cross et al.,
2019), which quantifies a quantum computer’s capabilities by accounting for
both its error rates and overall performance. Mathematically, the quantum
volume represents the maximum size of square quantum circuits that the
computer can successfully implement to achieve the heavy output generation
problem, i.e.,
log2 (VQ ) = arg max min(m, d(m)), (1.1)
m

where m ≤ N is a number of qubits selected from the given N -qubit quantum

computer, and d(m) is the number of qubits in the largest square circuits for
which we can reliably sample heavy outputs with probability greater than
2/3. The heavy output generation problem discussed here stems from pro-
posals aimed at demonstrating quantum advantage. That is, if a quantum
computer is of sufficiently high quality, we should expect to observe heavy
outputs frequently across a range of random quantum circuit families. For
illustration, Table 1.3 summarizes the progress of quantum computers as of
2024.
1.1. A FIRST GLIMPSE OF QUANTUM MACHINE LEARNING 7

Table 1.3: Progress of quantum computers up to December 2024.

Date log2 (VQ ) N Manufacturer System Name
Dec, 2024 - 105 Google Willow
Aug, 2024 21 56 Quantinuum H2-1
Jul, 2024 9 156 IBM Heron
Jun, 2023 19 20 Quantinuum H1-1
Sep, 2022 13 20 Quantinuum H1-1
Apr, 2022 12 12 Quantinuum H1-2
Jul, 2021 10 10 Honeywell H1
Nov, 2020 7 10 Honeywell H1
Aug, 2020 6 27 IBM Falcon r4

Remark
Note that quantum volume is not the unique metric for evaluating the
performance of quantum computers. There are several other metrics
that assess the power of quantum processors from different perspec-
tives. For instance, Circuit Layer Operations Per Second (CLOPS)
(Wack et al., 2021) measures the computing speed of quantum com-
puters, reflecting the feasibility of running practical calculations that
involve a large number of quantum circuits. Additionally, effective
quantum volume (Kechedzhi et al., 2024) provides a more nuanced
comparison between noisy quantum processors and classical comput-
ers, considering factors such as error rates and noise levels. These
metrics, among others, offer a more comprehensive understanding of
the strengths and limitations of quantum computers across various
applications.

1.1.2 Different measures of quantum advantages

What do we mean when we refer to quantum advantage? Broadly, quan-
tum advantage is demonstrated when quantum computers can solve a prob-
lem more efficiently than classical computers. However, the notion of “effi-
ciency” in this context is not uniquely defined.
The most common measure of efficiency is runtime complexity. By har-
nessing quantum effects, certain computations can be accelerated signifi-
cantly—sometimes even exponentially—enabling tasks that are otherwise
infeasible for classical computers. A prominent example is Shor’s algorithm,
which achieves an exponential speedup in large-number factorization rela-
tive to the best classical algorithms. In terms of runtime complexity, the
8 CHAPTER 1. INTRODUCTION

quantum advantage is achieved when the upper bound of a quantum algo-

rithm’s runtime for a given task is lower than the theoretical lower bound
of all possible classical algorithms for the same task.
In quantum learning theory (Arunachalam and De Wolf, 2017), efficiency
can also be measured by sample complexity, particularly within the Prob-
ably Approximately Correct (PAC) learning framework, which is central to
this tutorial. In this context, sample complexity is defined as the number
of interactions (e.g., quires of target quantum systems or measurements) re-
quired for a learner to achieve a desired prediction accuracy below a specified
threshold. Here, the quantum advantage is realized when the upper bound
on the sample complexity of a quantum learning algorithm for a given task
is lower than the lower bound of all classical learning algorithms. While low
sample complexity is a necessary condition for efficient learning, it does not
guarantee practical efficiency alone; for example, identifying useful training
examples within a small sample size may still require substantial computa-
tional time.

Remark
(Difference of sample complexity in classical and quantum ML). In
classical ML, sample complexity typically refers to the number of
training examples required for a model to generalize effectively, such
as the number of labeled images needed to train an image classi-
fier. In quantum ML, however, sample complexity can take on varied
meanings depending on the context, as shown below.

• Quantum state tomography (see Chapter 2.3.2). Here the sam-

ple complexity refers to the number of measurements required
to accurately reconstruct the quantum state of a system.

• Evaluation of the generalization ability of quantum neural net-

works (see Chapter 4.4). Here the sample complexity refers to
the number of input-output pairs needed to train the network
to approximate a target function, similar to classical ML.

• Quantum system learning. Here the sample complexity often

refers to the number of queries to interact with the target quan-
tum system, such as the number of times a system must be
probed to learn its Hamiltonian dynamics.

In addition to sample complexity, another commonly used measure in

1.1. A FIRST GLIMPSE OF QUANTUM MACHINE LEARNING 9

quantum learning theory is quantum query complexity, particularly within

the frameworks of quantum statistical learning and quantum exact learning.
As these frameworks are not the primary focus of this tutorial, interested
readers are referred to (Anshu and Arunachalam, 2024) for a more detailed
discussion.
Quantum advantage can be pursued through two main approaches. The
first involves identifying problems with quantum circuits that demonstrate
provable advantages over classical counterparts in the aforementioned mea-
sures (Harrow and Montanaro, 2017). Such findings deepen our under-
standing of quantum computing’s potential and expand its range of applica-
tions. However, these quantum circuits often require substantial quantum
resources, which are currently beyond the reach of near-term quantum com-
puters. Additionally, for many tasks, analytically determining the upper
bound of classical algorithm complexities is challenging.
These challenges have motivated a second approach: demonstrating that
current quantum devices can perform accurate computations on a scale that
exceeds brute-force classical simulations—a milestone known as “quantum
utility.” Quantum utility refers to quantum computations that yield reli-
able, accurate solutions to problems beyond the reach of brute-force classical
methods and otherwise accessible only through classical approximation tech-
niques (Kim et al., 2023). This approach represents a step toward practical
computational advantage with noise-limited quantum circuits. Reaching
the era of quantum utility signifies that quantum computers have attained
a level of scale and reliability enabling researchers to use them as effective
tools for scientific exploration, potentially leading to groundbreaking new
insights.

1.1.3 Explored tasks in quantum machine learning

What are the main areas of focus in QML? QML research is extensive and
can be broadly divided into four primary sectors, each defined by the nature
of the computing resources (whether the computing device is quantum (Q)
or classical (C)) and the type of data involved (whether generated by a
quantum (Q) or classical (C) system). The explanations of these four sectors
are as follows.

CC Sector. The CC sector refers to classical data processed on classi-

cal systems, representing traditional machine learning. Here, classical
ML algorithms run on classical processors (e.g., CPUs and GPUs) and
10 CHAPTER 1. INTRODUCTION

Learning task Learning paradigm

Q for C C for Q
Classifier (supervised learning) (unsupervised learning)

Discriminative Generative
learning learning Q for Q C for C (reinforcement learning)

Applications

(chemistry) (Computer vision) (Power system) (Logistic) (Finance) (Health)

Figure 1.2: Different research directions in QML. QML can be catego-

rized into four types based on the interplay of quantum (Q) and classical (C)
systems: Q for Q (quantum algorithms for quantum data), Q for C (quan-
tum algorithms for classical data), C for Q (classical algorithms for quantum
data), and C for C (classical algorithms for classical data). This tutorial pri-
marily focuses on the Q for C category. Beyond the role of the learner and
system, QML can also be classified by learning tasks (discriminative and
generative learning), learning paradigms (supervised, unsupervised, and re-
inforcement learning), and diverse applications such as chemistry, computer
vision, power systems, logistics, finance, and healthcare.

are applied to classical datasets. A typical example is using neural net-

works to classify images of cats and dogs.

CQ Sector: The CQ sector involves using classical ML algorithms on

classical processors to analyze quantum data collected from quantum
systems. Typical examples include applying classical neural networks
to classify quantum states, estimating properties of quantum systems
from measurement data, and employing classical regression models to
predict outcomes of quantum experiments.

QC Sector. The QC sector involves developing QML algorithms that

run on quantum processors (QPUs) to process classical data. In this
context, quantum computing resources are leveraged to enhance or
accelerate the analysis of classical datasets. Typical examples include
applying QML algorithms, such as quantum neural networks and quan-
tum kernels, to improve pattern recognition in image analysis.

QQ Sector. The QQ sector involves developing QML algorithms

executed on QPUs to process quantum data. In this context, quantum
computing resources are leveraged to reduce the computational cost
1.2. PROGRESS OF QUANTUM MACHINE LEARNING 11

of analyzing and understanding complex quantum systems. Typical

examples include using quantum neural networks for quantum state
classification and applying quantum-enhanced algorithms to simulate
quantum many-body systems.

The classification above is not exhaustive. As illustrated in Figure 1.2,

each sector can be further subdivided based on various learning paradigms,
such as discriminative vs. generative learning or supervised, unsupervised,
and semi-supervised learning. Additionally, each sector can be further cate-
gorized according to different application domains, such as finance, health-
care, and logistics.

Remark
The primary focus of this tutorial is on the QC and QQ sectors. For
more details on CQ, interested readers can refer to (Schuld et al.,
2015; Dunjko and Briegel, 2018; Carleo et al., 2019).

1.2 Progress of Quantum Machine Learning

Huge efforts have been made to the QC and QQ sectors to determine which
tasks and conditions allow QML to offer computational advantages over
classical machine learning. In this regard, to provide a clearer understanding
of QML’s progress, it is essential to first review recent advancements in
quantum computers, the foundational substrate for quantum algorithms.

1.2.1 Progress of quantum computers

The novelty and inherent challenges of utilizing quantum physics for compu-
tation have driven the development of various computational architectures,
giving rise to the formalized concept of circuit-based quantum computers,
as discussed in Chapter 1.1.1. In pursuit of this goal, numerous companies
and organizations are striving to establish their architecture as the leading
approach and to be the first to demonstrate practical utility or quantum
advantage on a large-scale quantum device.
Common architectures currently include superconducting qubits (em-
ployed by IBM and Google), ion-trap systems (pioneered by IonQ), and Ry-
dberg atom systems (developed by QuEra), each offering distinct advantages
(Cheng et al., 2023). Specifically, superconducting qubits excel in scalability
and fast gate operations (Huang et al., 2020a), while ion-trap systems are
12 CHAPTER 1. INTRODUCTION

2020-2025 2025-2030 2030-2040+

2023 2027 2029 2030
Super-
conducting
1121 qubits 1092 qubits + 15K gates 1M qubits 2000 qubits + 1B gates
IBM Quantum IBM Quantum error-corrected error-corrected
Condor Flamingo QC Google IBM Quantum
Blue Jay
2024 2027 2028 2029
Trapped-
ion 36 qubits 192 qubits 1024 algorithm qubits 1000+ qubits
IonQ QUANTINUUM IonQ QUANTINUUM
Forte SOL APOLLO

2023 2025 2026 2028+

Neural
atom 256 qubits 1000 qubits 100 logical qubits 128+ logical qubits + 200M gates
QuEra 10M gates > 10K physical qubits Pasqal
Pasqal QuEra Centauraus
Orion Gamma 2030+

Photon 1M qubits
PsiQuantum

Figure 1.3: Common quantum architectures and roadmaps from

different quantum companies.

known for their high coherence times, precise control over individual qubits,
and full connectivity of all qubits (Bruzewicz et al., 2019). Moreover, Ry-
dberg atom systems enable flexible qubit connectivity through highly con-
trollable interactions (Morgado and Whitlock, 2021). Besides these archi-
tectures, integrated photonic quantum computers are emerging as promising
alternatives for robust and scalable quantum computation.
Despite recent advances, today’s quantum computers remain highly sen-
sitive to environmental noise and prone to quantum decoherence, lacking
the stability needed for fault-tolerant operation. This results in qubits,
quantum gates, and quantum measurements that are inherently imperfect,
introducing errors that can lead to incorrect outputs. To capture this stage
in quantum computing, John Preskill coined the term “noisy intermediate-
scale quantum” (NISQ) era (Preskill, 2018), which describes the current
generation of quantum processors. These processors feature up to thou-
sands of qubits, but their capabilities are restricted with error-prone gates
and limited coherence times.
In the NISQ era, notable achievements have been made alongside new
challenges. Industrial and academic teams, such as those at Google and
USTC, have demonstrated quantum advantages on specific sampling tasks,
where the noisy quantum computers they fabricated outperform classical
computers in computational efficiency (Arute et al., 2019; Wu et al., 2021).
However, most quantum algorithms that theoretically offer substantial run-
time speedups depend on fault-tolerant, error-free quantum systems—capabilities
1.2. PROGRESS OF QUANTUM MACHINE LEARNING 13

that remain beyond the reach of current technology.

At this pivotal stage, the path forward in quantum computing calls for
progress on both hardware and algorithmic fronts.
On the hardware side, it is essential to continuously improve qubit count,
coherence times, gate fidelities, and the accuracy of quantum measurements
across various quantum architectures. Once the number and quality of
qubits surpass certain thresholds, quantum error correction codes can be
implemented (Nielsen and Chuang, 2011), paving the way for fault-tolerant
quantum computing (FTQC). Broadly, quantum error correction uses re-
dundancy and entanglement to detect and correct errors without directly
measuring the quantum state, thus preserving coherence. Advancements in
quantum processors will enable a progression from the NISQ era to the early
FTQC era, ultimately reaching the fully FTQC era.
On the algorithmic side, two key questions must be addressed:
(Q1) How can NISQ devices be utilized to perform meaningful computations
with practical utility?
(Q2) What types of quantum algorithms can be executed on early fault-
tolerant and fully fault-tolerant quantum computers to realize the po-
tential of quantum computing in real-world applications?
Progress on either question could have broad implications. A positive an-
swer to (Q1) would suggest that NISQ quantum computers have immediate
practical applicability, while advancements in (Q2) would expand the scope
and impact of quantum computing as more robust, fault-tolerant systems
become feasible. In the following two sections, we examine recent progress
in QML concerning these two questions.

1.2.2 Progress of quantum machine learning under FTQC

A key milestone in FTQC-based QML algorithms is the quantum linear
equations solver introduced by Harrow et al. (2009). Many machine learning
models rely on solving linear equations, a computationally intensive task
that often dominates the overall runtime due to the polynomial scaling of
complexity with matrix size. The HHL algorithm provides a breakthrough
by reducing runtime complexity to poly-logarithmic scaling with matrix size,
given that the matrix is well-conditioned and sparse. This advancement is
highly significant for AI, where datasets frequently reach sizes in the millions
or even billions.
The exponential runtime speedup achieved by the HHL algorithm has
garnered significant attention from the research community, highlighting the
14 CHAPTER 1. INTRODUCTION

potential of quantum computing in AI. Following this milestone, a body of

work has emerged that employs the quantum matrix inversion techniques
developed in HHL (or its variants) as subroutines in the design of various
FTQC-based QML algorithms, offering runtime speedups over their classi-
cal counterparts (Montanaro, 2016; Dalzell et al., 2023). Notable examples
include quantum principal component analysis (Lloyd et al., 2014) and quan-
tum support vector machines (Rebentrost et al., 2014).
Another milestone in FTQC-based QML algorithms is the quantum sin-
gular value transformation (QSVT), proposed by Gilyén et al. (2019). QSVT
enables polynomial transformations of the singular values of a linear oper-
ator embedded within a unitary matrix, offering a unifying framework for
various quantum algorithms. It has connected and enhanced a broad range
of quantum techniques, including amplitude amplification, quantum linear
system solvers, and quantum simulation methods. Compared to the HHL
algorithm for solving linear equations, QSVT provides improved scaling fac-
tors, making it a more efficient tool for addressing these problems in the
context of QML.
In addition to advancements in linear equation solving, another promis-
ing line of research in FTQC-based QML focuses on leveraging quantum
computing to enhance deep neural networks (DNNs) rather than traditional
machine learning models. This research track has two main areas of focus.
The first is the acceleration of DNN optimization, with notable examples
including the development of efficient quantum algorithms for dissipative
differential equations to expedite (stochastic) gradient descent, as well as
Quantum Langevin dynamics for optimization (Chen et al., 2023; Liu et al.,
2024a). The second area centers on advancing Transformers using quantum
computing. In Chapter 5, we will discuss in detail how quantum computing
can be employed to accelerate Transformers during the inference stage.

Remark
However, there are several critical caveats of the HHL-based QML
algorithms. First, the assumption of efficiently preparing the quan-
tum states corresponding to classical data runtime is very strong and
may be impractical in the dense setting. Second, the obtained result
x is still in the quantum form |x⟩. Note
√ that extracting one entry of
|x⟩ into the classical form requires O( N ) runtime, which collapses
the claimed exponential speedups. The above two issues amount to
the read-in and read-out bottlenecks in QML (Aaronson, 2015). The
1.2. PROGRESS OF QUANTUM MACHINE LEARNING 15

last caveat is that the employed strong quantum input model such as
quantum random access memory (QRAM) (Giovannetti et al., 2008)
leads to an inconclusive comparison. Through exploiting a classical
analog of QRAM as the input model, there exist efficient classical al-
gorithms to solve recommendation systems in poly-logarithmic time
in the size of input data.

1.2.3 Progress of quantum machine learning under NISQ

The work conducted by Havlı́ček et al. (2019) marked a pivotal moment
for QML in the NISQ era. This study demonstrated the implementation
of quantum kernel methods and quantum neural networks (QNNs) on a 5-
qubit superconducting quantum computer, highlighting potential quantum
advantages from the perspective of complexity theory. Unlike the aforemen-
tioned FTQC algorithms, quantum kernel methods and QNNs are flexible
and can be effectively adapted to the limited quantum resources available in
the NISQ era. These demonstrations, along with advancements in quantum
hardware, sparked significant interest in exploring QML applications using
NISQ quantum devices. We will delve into quantum kernel methods and
QNNs in Chapter 3 and Chapter 4, respectively.

Quantum neural networks (informal)

A quantum neural network (QNN) is a hybrid model that leverages

quantum computers to implement trainable models similar to classi-
cal neural networks, while using classical optimizers to complete the
training process.

As shown in Figure 1.4, the mechanisms of QNNs and deep neural net-
works (DNNs) are almost the same, whereas the only difference is the way
of implementing the trainable model. This difference gives the potential of
quantum learning models to solve complex problems beyond the reach of
classical neural networks, opening new frontiers in many fields. Roughly
speaking, research in QNNs and quantum kernel methods has primarily fo-
cused on three key areas: (I) quantum learning models and applications, (II)
the adaptation of advanced AI topics to QML, and (III) theoretical foun-
dations of quantum learning models. A brief overview of each category is
provided below.
(I) Quantum learning models and applications. This category
16 CHAPTER 1. INTRODUCTION

Deep neural networks Quantum neural networks

…
Data
Encoder

(dataset) (dataset)

Figure 1.4: Mechanisms of DNNs and QNNs. Both DNNs and QNNs
follow an iterative approach. At each iteration, they take input data, pro-
cess it through multiple layers, and produce an output prediction. The key
difference between DNNs and QNNs is the way of implementing their learn-
ing models.

focuses on implementing various DNNs on NISQ quantum computers to

tackle a wide range of tasks.
From a model architecture perspective, quantum analogs of popular clas-
sical machine learning models have been developed, including quantum ver-
sions of multilayer perceptrons (MLPs), autoencoders, convolutional neu-
ral networks (CNNs), recurrent neural networks (RNNs), extreme learning
machines, generative adversarial networks (GANs), diffusion models, and
Transformers. Some of these QNN structures have even been validated
on real quantum platforms, demonstrating the feasibility of applying quan-
tum algorithms to tasks traditionally dominated by classical deep learning
(Cerezo et al., 2021a; Li and Deng, 2022; Tian et al., 2023).
From an application perspective, QML models implemented on NISQ
devices have been explored across diverse fields, including fundamental sci-
ence, image classification, image generation, financial time series prediction,
combinatorial optimization, healthcare, logistics, and recommendation sys-
tems. These applications demonstrate the broad potential of QML in the
NISQ era, though achieving full quantum advantage in these areas remains
an ongoing challenge (Bharti et al., 2022; Cerezo et al., 2022).
(II) Adaptation of advanced AI topics to QML. Beyond model
design, advanced topics from AI have been extended to QML, aiming to
enhance the performance and robustness of different QML models. Exam-
ples include quantum architecture search (Du et al., 2022a) (the quantum
1.2. PROGRESS OF QUANTUM MACHINE LEARNING 17

Figure 1.5: The learnability of quantum machine learning models.

equivalent of neural architecture search), advanced optimization techniques

(Stokes et al., 2020), and pruning methods to reduce the complexity of quan-
tum models (Sim et al., 2021; Wang et al., 2023a). Other areas of active
research include adversarial learning (Lu et al., 2020), continual learning
(Jiang et al., 2022), differential privacy (Du et al., 2021a; Watkins et al.,
2023), distributed learning (Du et al., 2022b), federated learning (Ren et al.,
2023), and interpretability within the context of QML (Pira and Ferrie,
2024). These techniques have the potential to significantly improve the ef-
ficiency and effectiveness of QML models, addressing some of the current
limitations of NISQ devices.
(III) Theoretical foundations. Quantum learning theory (Banchi
et al., 2023) has garnered increasing attention, aiming to compare the capa-
bilities of different QML models and to identify the theoretical advantages
of QML over classical machine learning models. As shown in Figure 1.5, the
learnability of QML models can be evaluated across three key dimensions:
expressivity, trainability, and generalization capabilities. Below, we provide
a brief overview of each measure.

• Trainability. This area examines how the design of QNNs influences

their convergence properties, including the impact of system noise and
measurement errors on the ability to converge to local or global min-
ima.

• Expressivity. Researchers investigate how the number of parameters

and the structure of QNNs affect the size of the hypothesis space they
can represent. A central question is whether QNNs and quantum
kernels can efficiently represent functions or patterns that classical
neural networks cannot, thereby offering potential quantum advantage.
18 CHAPTER 1. INTRODUCTION

• Generalization. This focuses on understanding how the gap between

training and test error evolves with the size of the dataset, the struc-
ture of QNNs or quantum kernels, and the number of parameters. The
goal is to determine whether QML models can generalize more effec-
tively than classical models, particularly in the presence of noisy data
or when training data is limited.

The combination of advancements in model design, application domains,

and theoretical understanding is driving the progress of QML in the NISQ
era. Although the field is still in its early stages, the progress achieved thus
far provides promising insights into the potential of quantum computing to
enhance conventional AI. As quantum hardware continues to evolve, fur-
ther breakthroughs are expected, potentially unlocking new possibilities for
practical QML applications.

Remark
It is important to note that QNNs and quantum kernel methods can
also be considered FTQC algorithms when executed on fully fault-
tolerant quantum computers. The reason these algorithms are dis-
cussed in the context of NISQ devices is their flexibility and robust-
ness, making them well-suited to the limitations of current quantum
hardware.

1.2.4 A brief review of quantum machine learning

Unlike quantum hardware, where the number of qubits has rapidly scaled
from zero to thousands, the development of QML algorithms—and quan-
tum algorithms more broadly—has taken an inverse trajectory, transition-
ing from FTQC to NISQ devices. This shift reflects the move from idealized
theoretical frameworks to practical implementations. The convergence of
quantum hardware and QML algorithms, where the quantum resources re-
quired by these algorithms become attainable on real quantum computers,
enables researchers to experimentally evaluate the power and limitations of
various quantum algorithms.
Based on the minimum quantum resources required to complete learning
tasks, we distinguish between FTQC algorithms, discussed in Chapter 1.2.2,
and NISQ algorithms, including QNNs and quantum kernel methods, in
Chapter 1.2.3. FTQC-based QML algorithms necessitate error-corrected
quantum computers with tens of billions of qubits—an achievement that
remains far from realization. In contrast, QNNs and quantum kernels are
1.3. ORGANIZATION OF THIS TUTORIAL 19

more flexible and can be executed on both NISQ and FTQC devices, depend-
ing on the available resources.
As quantum hardware continues to progress, the development of QML
algorithms must evolve in tandem. A promising direction is to integrate
FTQC algorithms with QNNs and quantum kernel methods, creating new
QML algorithms that can be run on current quantum processors while of-
fering enhanced quantum advantages across various tasks.

1.3 Organization of This Tutorial

To encourage and enable computer scientists to engage with the rapidly
growing field of quantum AI, we provide this hands-on tutorial that revisits
QML algorithms from a computer science perspective. With this aim, the
tutorial is designed to balance theory, practical implementations, and ap-
plications, making it suitable for both researchers and practitioners with a
background in classical machine learning. The tutorial is divided into the
following chapters:
Chapter 2: Basics of Quantum Computing. Before delving into
QML, this chapter lays the groundwork by introducing the fundamental
concepts of quantum computing. It covers the transition from classical bits
to quantum bits, explains quantum circuit models, illustrates how quan-
tum systems interface with classical systems through quantum read-in and
read-out mechanisms, and presents some fundamental concepts of quantum
linear algebra. By the end of this chapter, you will understand that a solid
grasp of linear algebra is all you need to comprehend the basics of quantum
computing.
Chapters 3, 4 and 5: Classical ML Models Extended to Quan-
tum Frameworks. Each of these chapters follows a consistent structure,
starting with a review of the classical model and progressing to its quan-
tum extension—Quantum kernel methods in Chapter 3, Quantum neural
networks in Chapter 4, and Quantum Transformers in Chapter 5. This uni-
fied structure enables readers to clearly understand how classical machine
learning models can be translated into quantum implementations and how
quantum computers may offer computational advantages.
Appendix. The Appendix serves as a supplementary resource, providing
a summary of notations and essential mathematical tools that are omitted
from the main text for brevity. In particular, it includes basic introduction
of concentration inequalities, the Haar measure, and other foundational con-
cepts relevant to the tutorial.
20 CHAPTER 1. INTRODUCTION

To provide a clear and comprehensive learning experience, each chapter

is composed of the following parts:

1. Classical foundations and quantum model construction. Each chapter

begins with a review of the classical version of the model, ensuring
that readers are well-acquainted with the foundational concepts before
exploring their quantum adaptations. After this review, we introduce
quantum versions of the models, focusing on implementations based
on NISQ, FTQC, or both.

2. Theoretical analysis. There is nothing more practical than a good

theory. In this tutorial, each chapter provides a theoretical analysis
of the learnability of QML models, focusing on key aspects such as
expressivity, trainability, and generalization capabilities.
To ensure a balance between depth and self-consistency, this tutorial
provides proof for the most significant theoretical results, as high-
lighted by Theorems and Lemmas. For results that are less central
to the main content of this tutorial, we present them as Facts and
include appropriate references, allowing readers to easily locate the
complete proofs if desired.

3. Code implementation. “Talk is cheap, show me the code.” To provide

a practical, hands-on learning experience, each chapter includes code
implementations using real-world datasets (to be specified). This sec-
tion walks readers through the process of implementing quantum mod-
els on simulated or real quantum hardware. All numerical examples
illustrated in this tutorial are available in [Link]
[Link]/, accompanied by Jupyter Notebooks.
Instead of building everything from scratch, we leverage the well-
established PennyLane library for implementation (Bergholm et al.,
2018). This choice does not imply any specific preference. Other quan-
tum computing libraries, such as Qiskit (Javadi-Abhari et al., 2024),
Cirq (Developers, 2024), and TensorFlow Quantum (Broughton et al.,
2020), can also be used, offering similar capabilities and flexibility.

4. Frontier topics and future directions. Each chapter concludes with an

exploration of cutting-edge topics and emerging challenges in the field.
This part highlights open research problems, ongoing developments,
and potential future directions for the quantum versions of each model,
providing insights into where the field may be headed.
Chapter 2

Basics of Quantum
Computing

In this chapter, we introduce the fundamental concepts of quantum compu-

tation, such as quantum states, quantum circuits, and quantum measure-
ments, along with key topics in quantum machine learning, including quan-
tum read-in, quantum read-out, and quantum linear algebra. These foun-
dational elements are essential for understanding quantum machine learn-
ing algorithms and will be repeatedly referenced throughout the subsequent
chapters.
This chapter is organized as follows: Chapter 2.1 introduces quantum
bits and their mathematical representations; Chapter 2.2 covers quantum
circuits, including quantum gates, quantum channels, and quantum mea-
surements; Chapter 2.3 discusses how to encode classical data into quantum
systems and extract classical information from quantum states; Chapter 2.4
delves into quantum linear algebra; Chapter 2.5 provides practical coding
exercises to reinforce these concepts; and finally, Chapter 2.6 presents re-
cent advancements in efficient quantum read-in and read-out techniques for
further exploration.

2.1 From Classical Bits to Quantum Bits

In this section, we define quantum bits (qubits) and present the mathemat-
ical tools used to describe quantum states. We begin by discussing classical
bits and then transition to their quantum counterparts. We recommend
interested readers consult the textbook (Nielsen and Chuang, 2011) for the
detailed explanations.

21
22 CHAPTER 2. BASICS OF QUANTUM COMPUTING

2.1.1 Classical bits

In classical computing, a bit is the basic unit of information, which can
exist in one of two distinct states: 0 or 1. Each bit holds a definite value
at any given time. When multiple classical bits are used together, they can
represent more complex information. For instance, a set of three bits can
represent 23 = 8 distinct states, ranging from 000 to 111.

2.1.2 Quantum bits (Qubits)

Analogous to the role of ‘bit’ in classical computation, the basic element in
quantum computation is the quantum bit (qubit). We start by introducing
the representation of single-qubit states and then extend this to two-qubit
and multi-qubit states.
Single-qubit state. A single-qubit state can be represented by a two-
dimensional vector with unit length. Mathematically, a qubit state can be
written as  
a
a = 1 ∈ C2 , (2.1)
a2
where |a1 |2 + |a2 |2 = 1 satisfies the normalization constraint. Following
conventions in quantum theory, we use Dirac notation to represent vectors
(Nielsen and Chuang, 2011), i.e., a is denoted by |a⟩ (named ‘ket’) with

|a⟩ = a1 |0⟩ + a2 |1⟩ , (2.2)

   
1 0
where |0⟩ ≡ e0 ≡ and |1⟩ ≡ e1 ≡ are two computational (unit)
0 1
basis states. In this representation, the coefficients a1 and a2 are referred
to as amplitudes. The probabilities of obtaining the outcomes 0 or 1 upon
measurement of the qubit are given by |a1 |2 and |a2 |2 , respectively. The
normalization constraint ensures that these probabilities always sum to one,
as required by the probabilistic nature of quantum mechanics. In addition,
the conjugated transpose of a, i.e. a† , is denoted by ⟨a| (named ‘bra’) with

⟨a| = a∗1 ⟨0| + a∗2 ⟨1| ∈ C2 , (2.3)

where ⟨0| ≡ e⊤ ⊤
0 ≡ [1, 0], ⟨1| ≡ e1 ≡ [0, 1], and the symbol ‘⊤’ denotes the
transpose operation.
The physical interpretation of coefficients {ai } is probability amplitudes.
Namely, when we intend to extract information from the qubit state |a⟩ into
the classical form, quantum measurements are applied to this state, where
2.1. FROM CLASSICAL BITS TO QUANTUM BITS 23

the probability of sampling the basis |0⟩ (|1⟩) is |a1 |2 (|a2 |2 ). Recall that
the classical bit only permits the deterministic status with ‘0’ or ‘1’, while
the qubit state in Eqn. (2.2) is the superposition of the two status ‘|0⟩’ and
‘|1⟩’.

Remark
The quantum superposition leads to a distinct power between quan-
tum and classical computation, where the former can accomplish cer-
tain tasks with provable advantages.

Two-qubit state. The two qubits obey the tensor product rule, i.e.,
    
    y1 x1 y1
x1 y x1 y2  x1 y2 
⊗ 1 = 
  =  , (2.4)
x2 y2 y1  x2 y1 
x2
y2 y2 y2

which differs from the classical bits yielding the Cartesian product rule.
For instance, let the first qubit follow Eqn. (2.2) and the second qubit
state be |b⟩ = b1 |0⟩ + b2 |1⟩ with |b1 |2 + |b2 |2 = 1. The two-qubit state
formed by |a⟩ and |b⟩ is defined as

|a⟩ ⊗ |b⟩ = a1 b1 |0⟩ ⊗ |0⟩ + a1 b2 |0⟩ ⊗ |1⟩ + a2 b1 |1⟩ ⊗ |0⟩ + a2 b2 |1⟩ ⊗ |1⟩ ∈ C4 ,
 
1
  (2.5)
0
where the computational basis follows |0⟩⊗|0⟩ ≡ 00 , |0⟩⊗|1⟩ ≡ 10 , |1⟩⊗
0 0 0 0
P2 P2
|0⟩ ≡ 1 , |1⟩ ⊗ |1⟩ ≡ 0 , and the coefficients satisfy i=1 j=1 |ai bj |2 =
0 0
0 1
1.

Remark
For ease of notations, the state |a⟩ ⊗ |b⟩ can be simplified as |ab⟩,
|a, b⟩, or |a⟩ |b⟩. We will interchangeably use these notations through-
out the tutorial.

Example 2.1. A typical example of a two-qubit state is the Bell state,

which represents a maximally entangled quantum state of two qubits.
24 CHAPTER 2. BASICS OF QUANTUM COMPUTING

There are four types of Bell states, expressed as:

1
|ϕ+ ⟩ = √ (|00⟩ + |11⟩),
2
1
|ϕ− ⟩ = √ (|00⟩ − |11⟩),
2
1
|ψ + ⟩ = √ (|01⟩ + |10⟩),
2
1
|ψ − ⟩ = √ (|01⟩ − |10⟩). (2.6)
2
Each Bell state is a superposition of two computational basis states in
the four-dimensional Hilbert space.

Multi-qubit state. We now generalize the above two-qubit case to the

N -qubit case with N > 2. In particular, an N -qubit state |ψ⟩ is a 2N -
dimensional vector with
2N
X N
|ψ⟩ = ci |i⟩ ∈ C2 , (2.7)
i=1
PN
where the coefficients satisfy the normalization constraint 2i=1 |ci |2 = 1
and the symbol ‘i’ of the computational basis |i⟩ refers to a bit-string
with i ∈ {0, 1}N . As with the single-qubit case, the physical interpreta-
tion of coefficients {ci } is probability amplitudes, where the probability to
sample the bit-string ‘i’ is |ci |2 . When the number of nonzero entries in
c = [c1 , ..., ci , ..., c2N ]⊤ is larger than one, which implies that different bit-
strings are coexisting coherently, the state |ψ⟩ is called in superposition.

Remark
In quantum computing, a basis state |i⟩ refers to a computational
basis state in the Hilbert space of a quantum system. For an N -
qubit system, the computational basis states are represented as |i⟩ ∈
{|0 · · · 0⟩ , |0 · · · 1⟩ , ..., |1 · · · 1⟩}, where i is the binary representation
of the state index. These states form an orthonormal basis of the
2N -dimensional Hilbert space, satisfying

⟨i|j⟩ = δij , ∀i, j ∈ [2N ]. (2.8)

These basis states are fundamental for representing and analyzing

2.1. FROM CLASSICAL BITS TO QUANTUM BITS 25

quantum states, as any arbitrary quantum state can be expressed as

a linear combination of these basis states.
Moreover, the size of c exponentially scales with the number of qubits
N , attributed to the tensor product rule. This exponential depen-
dence is an indispensable factor to achieve quantum supremacy (Arute
et al., 2019), since it is extremely expensive and even intractable to
record all information of c by classical devices for the modest number
of qubits, e.g., N > 100.

Entangled multi-qubit state. A fundamental phenomenon in multi-

qubit quantum systems is entanglement, which represents a non-classical
correlation between quantum systems that cannot be explained by classical
physics. As proved by Jozsa and Linden (2003), quantum entanglement is
an indispensable component to offer an exponential speed-up over classical
computation. A representative example is Shor’s algorithm, which utilizes
entanglement to attain an exponential speed-up over any classical factoring
algorithm. In an entangled quantum state, the state of one qubit cannot
be fully described independently of the other qubits, even if they are spa-
tially separated. The formal definition of entanglement for states in Dirac
notation is as follows:

Definition 2.2. (Entanglement for States in Dirac Notation) An N -qubit

N
state |ψ⟩ ∈ C2 is entangled if it cannot be expressed as the tensor product
of states of its subsystems A and B:
NA NB
|ψ⟩ =
̸ |ψa ⟩ ⊗ |ψb ⟩ , ∀ |ψa ⟩ ∈ C2 , |ψb ⟩ ∈ C2 , NA + NB = N. (2.9)

If the state can be expressed in this form, it is referred to as seperable.

Example 2.3. (GHZ state). A typical example of an entangled N -

qubit state is the Greenberger-Horne-Zeilinger (GHZ) state (Greenberger
et al., 1989), which is a generalization of the two-qubit Bell state (see
Example 2.1) to a maximally entangled N -qubit state. The general form
of an N -qubit GHZ state is:
1  
|GHZN ⟩ = √ |0⟩⊗N + |1⟩⊗N . (2.10)
2
26 CHAPTER 2. BASICS OF QUANTUM COMPUTING

For N = 3, the GHZ state is:

1
|GHZ3 ⟩ = √ (|000⟩ + |111⟩). (2.11)
2

A key property of the entangled states (e.g., Bell states and GHZ states) is
that measuring one qubit determines the outcome of measuring the other
qubit, reflecting their strong quantum correlation.

2.1.3 Density matrix

Another description of quantum states is through density matrix or density
operators. The reason for establishing density operators instead of Dirac no-
tations arises from the imperfection of physical systems. Specifically, Dirac
notations introduced in Chapter 2.1.2 are used to describe ‘ideal’ quantum
states (i.e., pure states), where the operated qubits are isolated from the
environment. Alternatively, when the operated qubits interact with the en-
vironment unavoidably, the density operators are employed to describe the
behavior of quantum states living in this open system. As such, density
operators describe more general quantum states.
N N
Mathematically, an N -qubit density operator, denoted by ρ ∈ C2 ×2 ,
2N
Pm of m quantum pure states |ψi ⟩ ∈ C with probability
presents a mixture
pi ∈ [0, 1] and i=1 pi = 1, i.e.,
m
X
ρ= pi ρi , (2.12)
i=1

N N
where ρi = |ψi ⟩ ⟨ψi | ∈ C2 ×2 is the outer product of the pure state |ψi ⟩.
The outer product of two vectors |u⟩ , |v⟩ ∈ Cn is expressed as
   
u1 u1 v1∗ u1 v2∗ · · · u1 vn∗
 u2  
  u2 v1∗ u2 v2∗ · · · u2 vn∗ 
  ∗ ∗ ∗ 
|u⟩ ⟨v| =  .  v1 v2 · · · vn =  . .. .. .. , (2.13)
 ..   .. . . . 
un un v1∗ un v2∗ · · · un vn∗

where ui and vi∗ are the element of |u⟩ and the conjugate transpose ⟨v|,
respectively.
From the perspective of computer science, the density operator ρ is just
a positive semi-definite matrix with trace-preserving, i.e., 0 ⪯ ρ and Tr(ρ) =
1.
2.1. FROM CLASSICAL BITS TO QUANTUM BITS 27

Definition 2.4. (Positive semi-definite matrix) A matrix A ∈ Cn×n is pos-

itive semi-definite (PSD) if it satisfies the following conditions:

1. A is Hermitian: A = A†

2. For any nonzero vector |v⟩ ∈ Cn , ⟨v| A |v⟩ ≥ 0, where ⟨v| A |v⟩ repre-
sents the quadratic form of A with respect to |v⟩.

When m = 1, the density operator ρ amounts to a pure state with

ρ = |ψ1 ⟩ ⟨ψ1 |. When m > 1, the density operator ρ describes a ‘mixed’
quantum state, where the rank of ρ is larger than 1. A simple criterion to
discriminate the pure states with the mixed states is as follows: the pure
state with m = 1 yields Tr(ρn ) = Tr(ρ) = 1 for any n ∈ N+ ; the mixed
state with m > 1 satisfies Tr(ρn ) < Tr(ρ) = 1 for any n ∈ N+ \ {1}. Similar
to the Definition 2.2 for entanglement of pure states, we can define the
entanglement of mixed states.

Definition 2.5. (Entanglement for Mixed States) Let ρ be a density operator

acting on a composite Hilbert space HA ⊗ HB . The state ρ is said to be
entangled if it cannot be expressed as:
X (i) (i)
ρ= pi ρA ⊗ ρB , (2.14)
i

P (i) (i)
where pi ≥ 0, i pi = 1, and ρA and ρB are density operators on HA and
HB , respectively. If ρ can be written in this form, it is called separable.

Example 2.6. (Density matrix representations).

(i). Consider the single-qubit pure state |ψ⟩ = √12 (|0⟩ + |1⟩). The cor-
responding density operator is:
 
1 1 1
ρ = |ψ⟩ ⟨ψ| = .
2 1 1

Here, Tr(ρ2 ) = Tr(ρ) = 1, confirming that it is a pure state.

(ii). Consider the classical probabilistic mixture of |0⟩ and |1⟩, each with
equal probability p = 0.5. The density operator is:
 
1 1 0
ρ = 0.5 |0⟩ ⟨0| + 0.5 |1⟩ ⟨1| = .
2 0 1
28 CHAPTER 2. BASICS OF QUANTUM COMPUTING

In this case, Tr(ρ2 ) = 0.5 < Tr(ρ) = 1, indicating it is a mixed state.

2.2 From Digital Logical Circuit to Quantum Cir-

cuit Model
To process quantum states, we need to introduce quantum computation, a
fundamental model of which is the quantum circuit model. In this section,
we will begin with classical computation in Chapter 2.2.1 and transit to de-
tails about the quantum circuit model in Chapter 2.2.2, including quantum
gates, quantum channel, and quantum measurements.

2.2.1 Classical digital logical circuit

Digital logic circuits are the foundational building blocks of classical com-
puting systems. They process classical bits by performing logical operations
through logic gates. In this subsection, we introduce the essential compo-
nents of digital logic circuits and their functionality, followed by a discussion
of how these classical circuits relate to quantum circuits.

Logic gates

Logic gates are the basic components of a digital circuit. They take binary
inputs, represented as 0 or 1, and produce a binary output based on a
predefined logical operation. The most common logic gates include:

1. NOT Gate: This gate inverts the input bit, i.e., it produces 1 if the
input is 0, and vice versa. Its truth table is shown in Table 2.1;

Table 2.1: Input-output mapping of the NOT gate.

Input (A) Output (NOT A)
0 1
1 0

2. AND Gate: Produces an output of 1 only if both input bits are 1;

otherwise, it outputs 0. The truth table is shown in Table 2.2;

3. OR Gate: Outputs 1 if at least one input is 1. The truth table is

shown in Table 2.3;
2.2. FROM DIGITAL LOGICAL CIRCUIT TO QUANTUM CIRCUIT MODEL29

Table 2.2: Input-output mapping of the AND gate.

Input (A) Input (B) Output (A AND B)
0 0 0
0 1 0
1 0 0
1 1 1

Table 2.3: Input-output mapping of the OR gate.

Input (A) Input (B) Output (A OR B)
0 0 0
0 1 1
1 0 1
1 1 1

Table 2.4: Input-output mapping of the XOR gate.

Input (A) Input (B) Output (A XOR B)
0 0 0
0 1 1
1 0 1
1 1 0

4. XOR Gate: Produces an output of 1 if the inputs are different, and

0 otherwise. The truth table is shown in Table 2.4.

These logic gates can be combined in various configurations to build more

complex circuits capable of performing arbitrary arithmetic operations.

Circuit design and universality

A classical digital logic circuit is composed of interconnected gates designed

to perform specific tasks, such as addition or multiplication. A key property
of these circuits is universality, meaning any logical function can be imple-
mented using a finite set of gates. For example, the NAND Gate (NOT
AND) and NOR Gate (NOT OR) are universal gates. Any other logical
operation can be constructed using only NAND or NOR gates (Leach and
Malvino, 1994).
30 CHAPTER 2. BASICS OF QUANTUM COMPUTING

2.2.2 Quantum circuit

Classical digital logical circuits provide the essential framework for under-
standing computation. While classical circuits operate on bits and perform
deterministic operations, quantum circuits manipulate qubits and involve
probabilistic behavior. The concepts of logic gates, circuit design, and uni-
versality lay the groundwork for transitioning to quantum circuits intro-
duced in this subsection.

Quantum gate
Recall that the computational toolkit for classical computers is logic gates,
e.g., NOT, AND, OR, and XOR, which are applied to the single bit or mul-
tiple bits to accomplish computation. Similarly, the computational toolkit
for quantum computers (or quantum circuits) is quantum gate, which op-
erates on qubits introduced in Chapter 2.1.2 to complete the computation.
In the following, we will introduce both single-qubit and multi-qubit gates.
Single-qubit gates. Single-qubit gates control the evolution of the single-
qubit state |a⟩. Due to the law of quantum mechanics, the evolved state
should satisfy the normalization constraint. The implication of this con-
straint is that the evolution must be a unitary operation. Concretely, de-
noted U ∈ C2×2 as a linear operator and the evolved state as

|â⟩ := U |a⟩ = â1 |0⟩ + â2 |1⟩ ∈ C2 , (2.15)

the summation of coefficients |â1 |2 +|â2 |2 = ⟨â|â⟩ = ⟨a|U † U |a⟩ is equal to 1

if and only if U is unitary with U † U = U U † = I2 . The symbol ‘†’ denotes the
conjugate transpose operation. Under the density operator representation,
the evolution of |a⟩ yields
ρ̂ = U ρU † , (2.16)
where ρ̂ = |â⟩ ⟨â| and ρ = |a⟩ ⟨a|.
Several common single-qubit gates, including Pauli-X, Pauli-Y, Pauli-Z,
Hadamard, and rotational single-qubit gates about the X, Y, and Z axes
(RX, RY, RZ), are illustrated in Figure 2.1. According to Theorem 4.1 in
(Nielsen and Chuang, 2011), any unitary operation on a single qubit can be
decomposed into a sequence of rotations as:

U = RZ(α) RY(β) RZ(γ), (2.17)

where α, β, γ ∈ [0, 2π), up to a global phase shift.

2.2. FROM DIGITAL LOGICAL CIRCUIT TO QUANTUM CIRCUIT MODEL31

Quantum gate Matrix form Circuit representation

 
0 1
Pauli-X (X) X
1 0
 
0 −i
Pauli-Y (Y) Y
i 0
 
1 0
Pauli-Z (Z) Z
0 −1
 
1 1 1
Hadamard (H) √ H
1 −1
 2 
1 0 0 0
0 1 0 0 
Controlled-Z (CZ)  
0 0 1 0 
Z
 0
0 0 −1

cos θ2
− i sin
θ2
RX(θ) Rx (θ)
− i sin θ2 cos θ2



cos 2
− sin θ2

θ
RY(θ) Ry (θ)
sin θ cos θ2
 −2i θ/2 
e 0
RZ(θ) Rz (θ)
0 e i θ/2
 
1 0 0 0
0 0 1 0
SWAP  
0 1 0 0
0 0 0 1
1 0 0 0
0 1 0 0
Controlled-NOT (CNOT)  
0 0 0 1
0 0 1 0
Table 1: Comparison of selected quantum gates with quantikz circuit diagrams.
Figure 2.1: The summarization of quantum gates. The table contains
the abbreviation, the mathematical form, and the graph representation of a
set of universal quantum gates. i represents the imaginary unit.

1
 32 CHAPTER 2. BASICS OF QUANTUM COMPUTING

|ai |âi = |ai |âi

U RZ(α) RY(β) RZ(γ)
input state evolved state input state evolved state
1

Figure 2.2: The evolution of the single-qubit state decomposed into

the quantum gates.

The evolution from |a⟩ to |â⟩ can be visualized using a quantum circuit
diagram, as illustrated in Figure 2.2. The wire in the circuit represents a
qubit, which evolves from the initial state |a⟩ on the left to the final state
|â⟩ on the right. Gates are applied sequentially from left to right along the
wire.

Remark
The circuit model serves as a foundational framework for describing
quantum computation due to its intuitive and modular nature, mak-
ing it accessible for researchers and practitioners transitioning from
classical to quantum computing. First, the circuit model provides a
standardized graphical language to represent complex quantum algo-
rithms, enabling clear visualization of the computational flow and in-
teractions among qubits. Second, the modularity of the circuit model
allows quantum operations to be easily decomposed into a pre-defined
gate set, ensuring compatibility across different quantum hardware
architectures.

Multi-qubit gates. The evolution of the N -qubit quantum state can be

effectively generalized by the single-qubit case. That is, the unitary operator
N N
U ∈ C2 ×2 evolves an N -qubit state |ψ⟩ in Eqn. (2.7) as
N
b = U |ψ⟩ ∈ C2
|ψ⟩ . (2.18)
The evolution of |ψ⟩ under the density operator representation is denoted
b ⟨ψ|
by ρ̂ = U ρU † , where ρ̂ = |ψ⟩ b and ρ = |ψ⟩ ⟨ψ|.

Remark
In the view of computer science, the quantum (logic) gates in Figure
2.1 are well-designed matrices with the following properties. First,
all quantum gates are unitary (e.g., X X† = I2 ). Second, X, Y, Z,
H gates have the fixed form with size 2 × 2; CNOT, CZ, and SWAP
gates have the fixed form with size 4×4. Third, RX(θ), RY(θ), RZ(θ)
gates are matrices controlled by a single variable θ.
 2.2. FROM DIGITAL LOGICAL CIRCUIT TO QUANTUM CIRCUIT MODEL33

Figure 2.1 includes two significant multi-qubit gates: the controlled-Z

(CZ) gate and the controlled-NOT (CNOT) gate. For instance, the CNOT
gate operates on two qubits: a control qubit (top line) and a target qubit
(bottom line). If the control qubit is 0, the target qubit remains unchanged;
if the control qubit is 1, the target qubit is flipped.

Example 2.7. (State evolved by multi-qubit gates). Figure 2.3 illus-

trates the evolution of a 3-qubit state |ψ⟩ under a multi-qubit circuit con-
sisting of multi-qubit gates. Each wire represents a qubit, and the evolu-
tion occurs from left to right. Starting with the initial state |ψ⟩ = |000⟩,
a Hadamard gate is applied to the first qubit, followed by two CNOT
gates: one acting on the first and second qubits, and the other acting
on the second and third qubits. The final evolved state, shown on the
right, is the GHZ state introduced in Example 2.3, i.e., |ψ⟩ b = U |ψ⟩ =
√1 (|000⟩ + |111⟩). The entire unitary operation can be represented as:
2

U = (H ⊗I4 )(CNOT ⊗I2 )(I2 ⊗ CNOT). (2.19)

0⟩ X |1⟩
|0⟩ H
1
0⟩ X |1⟩ √ (|000⟩ + |111⟩)
|0⟩ 2

0⟩ X |1⟩ |0⟩

U
U
Figure 2.3: The decomposition of the multi-qubit circuit U in the
case of N = 3.

Remark
The CNOT gate plays a pivotal role in quantum computing due to
its unique ability to generate entangled states, such as the Bell states
and GHZ states presented in Examples 2.1&2.3. Besides, the CNOT
gate is one of the most commonly implemented gates on quantum
34 CHAPTER 2. BASICS OF QUANTUM COMPUTING

hardware. Its design and optimization directly impact the fidelity

and scalability of quantum systems.

A universal quantum gate set. While many single and multi-qubit gates
exist, it is sufficient to use a universal set of gates to construct any unitary
operation. As proved in Chapter 4.5.2 of Ref. (Nielsen and Chuang, 2011),
any unitary operator U in Eqn. (2.18) can be decomposed into the single-
qubit and two-qubit gates with a certain arrangement.
Fact 2.8 (Solovay-Kitaev theorem, (Dawson and Nielsen, 2005)). Suppose
we are given a fixed universal gate set G, which generates a dense group
SU(d). Then any unitary operator U ∈ SU(d) can be approximated to an
arbitrary precision ϵ > 0 by a finite sequence of gates from G. Formally,
there exists a decomposition such that
L
Y
U− Gl ≤ ϵ, Gl ∈ G, L ∈ N, (2.20)
l=1 op

where ∥·∥op is the operator norm which is the largest singular value of a
matrix, and L is the required number of gates that scales as:
L = O(logc (1/ϵ)), (2.21)
with c ≈ 4.
A commonly used universal gate set includes single-qubit rotations RX(θ),
RY(θ), RZ(θ), and two-qubit gates such as the CNOT gate. As illustrated
in Figure 1.1, any ideal quantum computation can be represented by a uni-
tary operator. This universal gate set provides a practical and foundational
toolkit for implementing arbitrary quantum algorithms.

Quantum channels
Analogous to the unitary operation describing the evolution of quantum
states in the closed system, the quantum channel formalizes the evolution
of quantum states in the open system. Refer to the textbook (Wilde, 2011)
for more details.
Mathematically, every quantum channel N (·) can be treated as a linear,
completely positive, and trace-preserving map (CPTP map).
Definition 2.9 (CPTP map). Denote L(H) as the space of square linear
operators acting on the Hilbert space H. We say N (·) is a CPTP map if the
following conditions are satisfied:
2.2. FROM DIGITAL LOGICAL CIRCUIT TO QUANTUM CIRCUIT MODEL35

• The ‘linearity’ requires for any XA , YA ∈ L(HA ) and a, b ∈ C, N (aXA +

bYA ) = aN (XA ) + bN (YA ).

• The definition of completely positive is as follows. A linear map N :

L(HA ) → L(HB ) is a positive map if N (XA ) is positive semi-definite
for all positive semi-definite operators XA ∈ L(HA ). Moreover, a
linear map N : L(HA ) → L(HB ) is completely positive if IR ⊗ N is a
positive map for any size of R.

• The trace preservation requires Tr(N (XA )) = Tr(XA ) for any XA ∈

L(HA ).

A quantum channel can be represented by the Choi-Kraus decomposition

(Nielsen and Chuang, 2011). Mathematically, let L(HA , HB ) denote the
space of linear operators taking HA to HB . The Choi–Kraus decomposition
of the quantum channel N (·) : L(HA ) → L(HB ) is
d
X
N (XA ) = Ma XA M†a (2.22)
a=1
P
where XA ∈ L(HA ), Ma ∈ L(HA , HB ), da=1 M†a Ma = Idim(HA ) , and d ≤
dim(HA )dim(HB ). Here dim(H∗ ) refers to the dimension of the space H∗ .
We next introduce two common types of quantum channels, which will be
broadly employed in the following context to simulate the noise of quantum
devices.
The first type is the depolarizing channel, which considers the scenario
such that the information of the input state can be entirely lost with some
probability.

Definition 2.10 (Depolarization channel). Given an N -qubit quantum state

N N
ρ ∈ C2 ×2 , the depolarization channel Np acts on a 2N -dimensional Hilbert
space follows
IN
Np (ρ) = (1 − p)ρ + p 2N , (2.23)
2
where I2N /2N refers to the maximally mixed state and p is a scalar repre-
senting the depolarization rate.

Example 2.11. (Single-qubit state with depolarization channel). Con-

36 CHAPTER 2. BASICS OF QUANTUM COMPUTING

sider a single-qubit pure state ρ = |0⟩ ⟨0| with the density matrix
 
1 0
ρ = |0⟩ ⟨0| = . (2.24)
0 0

When the depolarizing channel Np acts on this state, the output is given
by      
p
1 0 p 1 0 1− 2 0
Np (ρ) = (1 − p) + = p . (2.25)
0 0 2 0 1 0 2
Therefore, the purity is inferred as:

p2
Tr(Np2 (ρ)) = 1 − p + . (2.26)
2
When p = 0, the state remains pure and unchanged. When 0 < p ≤ 1,
the state becomes a mixture of states |0⟩ and |1⟩ with Tr(Np2 (ρ)) < 1.
When p = 1, the state evolves into the maximally mixed state.

The second type is the Pauli channel, which serves as a dominant noise
source in many computing architectures and as a practical model for ana-
lyzing error correction (Flammia and Wallman, 2020).

Definition 2.12 (Single-qubit Pauli channel). Given a quantum state ρ ∈

C2×2 , the single-qubit Pauli channel Np⃗ acts on this state follows

Np⃗ (ρ) = pI ρ + pX X ρ X +pY Y ρ Y +pZ Z ρ Z , (2.27)

where p⃗ = (pI , pX , pY , pZ ) and pI + pX + pY + pZ = 1.

Note that for a single-qubit system, the depolarization channel Np is a

special Pauli channel with setting pX = pY = pZ = p.

Example 2.13. (Single-qubit state with Pauli channel). Consider a

single-qubit pure state ρ = |0⟩ ⟨0| with the density matrix:
 
1 0
ρ = |0⟩ ⟨0| = . (2.28)
0 0
2.2. FROM DIGITAL LOGICAL CIRCUIT TO QUANTUM CIRCUIT MODEL37

When the Pauli channel Np⃗ acts on this state, the output is given by
       
1 0 0 0 0 0 1 0
Np⃗ (ρ) = pI + pX + pY + pZ (2.29)
0 0 0 1 0 1 0 0
 
pI + pZ 0
= . (2.30)
0 pX + pY

Let us analyze three special cases for the probability vector p⃗ = (pI , pX , pY , pZ ):

• Case 1: If pX = pY = pZ = p, the Pauli channel reduces to the

depolarization channel and the prepared state becomes:
 
1 − 2p 0
Np⃗ (ρ) = . (2.31)
0 2p

• Case 2: If pY = pZ = 0, the prepared state becomes:

 
1 − pX 0
Np⃗ (ρ) = . (2.32)
0 pX

In this scenario, the Pauli channel reduces to the bit-flip channel.

• Case 3: For other values of p⃗, the effect of the Pauli channel
on the pure state |0⟩ can be interpreted as a combination of the
depolarizing channel and the bit-flip channel.

To generalize the single-qubit Pauli channel to a multi-qubit Pauli chan-

nel, we extend the definition to account for the action of Pauli operators on
multiple qubits.

Definition 2.14 (Multi-qubit Pauli channel). Given a quantum state ρ ∈

N N
C2 ×2 for an N -qubit system, the multi-qubit Pauli channel Np⃗ acts as
X
Np⃗ (ρ) = pP P ρP † , (2.33)
P ∈PN

where PN = {I, X, Y, Z}⊗N denotes the set of all tensor products of the N
single-qubit PauliPoperators, and pP is the probability of applying the Pauli
operator P with P ∈PN pP = 1.
38 CHAPTER 2. BASICS OF QUANTUM COMPUTING

Remark
The multi-qubit Pauli channel considers the existence of correlated
Pauli noise on different qubits. If each qubit only experiences in-
dependent single-qubit Pauli noise, the multi-qubit channel can be
written as the tensor product of sing-qubit Pauli channels:

Np⃗ (ρ) = ⊗N
i=1 Np
⃗i (ρ), (2.34)

where Np⃗i is the single-qubit Pauli channel acting on the i-th qubit
with probabilities p⃗i = (pI , pX , pY , pZ ).

Having acknowledged the motivation and definition of quantum chan-

nels, it is natural to ask what is the relation between quantum channels
and quantum gates? A straightforward observation is that a quantum gate
is a special case of a quantum channel. Conversely, the evolution of the
quantum state can be built from the unitary operation via the isometric
extension (Wilde, 2011). The following theorem shows that any quantum
channel arises from a unitary evolution on a larger Hilbert space.

Remark
According to the Choi-Kraus decomposition, the unitary operator is
a special case of a quantum channel. Specifically, when d = 1, the
quantum channel reduces to:

N (XA ) = M1 XA M†1 , (2.35)

where M1 is a unitary operator satisfying M†1 M1 = I. This highlights

that all unitary operators are quantum channels, but not all quantum
channels are unitary.

Theorem 2.15. (Wilde, 2011) Let N (·) : L(HA ) → L(HB ) be a quan-

tum channel defined in Eqn. (2.22). Let HE be the Hilbert space of an
auxiliary system. Denote the input state as ρ (i.e., a density operator
ρ ∈ Cdim(HA )×dim(HA ) ). Then there exists a unitary U : L(HA ⊗ HE ) →
L(HB ⊗ HE ) and a normalized vector (i.e., a pure state) |φ⟩ ∈ Cdim(HE )
such that  
N (ρ) = TrE U (ρ ⊗ |φ⟩ ⟨φ|)U † , (2.36)

where TrE (·) denotes the partial trace over the ancillary Hilbert space HE ,
and the dimension of HE depends on the rank of the Kraus representation
2.2. FROM DIGITAL LOGICAL CIRCUIT TO QUANTUM CIRCUIT MODEL39

of N .

Proof sketch of Theorem 2.15. We extend the system to include an ancillary

Hilbert space HE , representing the environment. The combined space HA ⊗
HE forms a closed physical system, where the evolution of the quantum
state can be described by a unitary operator U acting on HB ⊗ HE .
To find a feasible unitary U , we express the quantum channel N using
its isometric extension (Wilde, 2011), i.e.,
 
N (ρ) = TrE V ρV † , (2.37)

where V : HA → HB ⊗ HE is an isometry operator embedding the input

state into the larger Hilbert space. For simplicity, assume HA = HB . The
isometry operator V can always be embedded into a unitary operator U
acting on HB ⊗ HE , ensuring that U captures the reversible evolution of the
extended system.
Next, we augment the input state ρ by introducing an ancillary state
|φ⟩ ∈ HE , yielding the combined state ρ ⊗ |φ⟩ ⟨φ|. Substituting this aug-
mented state and the unitary operator U into the isometric extension in
Eqn. (2.37) gives Eqn. (2.36). Theorem 2.15 is thereby proven.

The translation between the unitary operation and the quantum channels
described by Theorem 2.15 can be visually explained, as shown in Figure 2.4.
In this diagram, the first wire corresponds to the original input state ρ,
while the second wire represents the initial state |φ⟩ of the environment.
To determine the output of the quantum channel N applied to ρ, an N -
induced unitary operation U is performed on the combined system, followed
by a partial trace over the environment to discard its information.

ρ N (ρ)
U
|φ⟩ Trace over HE

Figure 2.4: The evolution of quantum states based on Theorem 2.15.

Quantum measurements
In addition to quantum gates and quantum channels that manipulate quan-
tum states, another special operation in quantum circuits is measurement.
40 CHAPTER 2. BASICS OF QUANTUM COMPUTING

The aim of quantum measurements is to extract quantum information of the

evolved state into the classical form. The quantum circuit diagram, which
describes applying a unitary U followed by the quantum measurement to a
single-qubit state |a⟩, is shown in Figure 2.5. In particular, both types of
measurements are depicted by the ‘meter’ symbol.

|ai
U
input state
1

Figure 2.5: The quantum circuit diagram with measurement.

The quantum measurements can be categorized into two types, i.e., pro-
jective measurements and positive operator-valued measures (Preskill, 1999;
Nielsen and Chuang, 2011).
The projective measurement, which is also called the von Neumann
P mea-
surement, is formally described by the Hermitian operator A = i λi |vi ⟩ ⟨vi |,
where {λi } and {|vi ⟩} refer to the eigenvalues and eigenvectors of A, re-
spectively. Supported by the Born rule (Nielsen and Chuang, 2011), when
N N
the measurement operator A ∈ C2 ×2 is applied to an N -qubit state
N
|Φ⟩ ∈ C2 , the probability of measuring any one of the eigenvalues in {λi }
is
Pr(λi ) = | ⟨vi |Φ⟩ |2 . (2.38)

In the density operator representation, suppose that the state to be measured

N N
is ρ ∈ C2 ×2 , the probability of measuring any one of the eigenvalues in
{λi } is
Pr(λi ) = Tr(ρ |vi ⟩ ⟨vi |). (2.39)

Define Πi = |vi ⟩ ⟨vi | as the i-th projective operator. The complete set of
projective operators {Πi } has the following properties
X
1)Πi Πj = δij ; 2)Π†i = Π; 3)Π2i = Π; 4) Πi = I2N . (2.40)
i

A special set of projectors is defined as Πi = |i⟩ ⟨i| for ∀i ∈ [2N ], which

measures the probability corresponding to the basis state |i⟩. For example,
given the single-qubit state |α⟩ in Eqn. (2.2), the probability to measure the
computational basis state |i⟩ is

Pr(i) = | ⟨vi |α⟩ |2 = |αi |2 . (2.41)

2.3. QUANTUM READ-IN AND READ-OUT PROTOCOLS 41

The second type of quantum measurement is the positive operator-valued

measures (POVM). A POVM P is described by a collection of positive oper-
ators 0 ⪯ Ei satisfying i Ei = I. Each positive operator Ei is associated
with an outcome of measurement. Specifically, applying the measurement
{Em } to the state |ψ⟩, the probability of outcome i is given by

Pr(i) = | ⟨ψ|Ei |ψ⟩ |2 . (2.42)

In the density operator representation, suppose that the state to be measured

N N
is ρ ∈ C2 ×2 , the probability of outcome i is given by

Pr(λi ) = Tr(ρEi ). (2.43)

We remark that the main difference between projective measurements and

POVM elements is that the POVM elements do not have to be orthogonal.
Due to this reason, the projective measurement is a special case of the
generalized measurement (i.e., with setting Ei = Π†i Πi ).

Remark
Here we address the accessible information through quantum mea-
surements in the ideal and practical settings. For ease of discussion,
suppose that the computation result corresponds to the probabil-
ity amplitude a1 in the single-qubit state |a⟩ = a1 |0⟩ + a2 |1⟩ in
Eqn. (2.2). To extract a1 from the quantum state into the classi-
cal form, we apply the projective operator Π1 = |0⟩ ⟨0| to this state.
Due to the law of quantum mechanics, after each measurement, the
state is collapsed and the measured outcome Vi can be viewed as a
binary random variable with the Bernoulli distribution Ber(ai ), i.e.,
Pr(Vi = 1) = a1 and Pr(Vi = 0) = 1 − a1 . Through applying the
measurement Πi to K copies of the state |a⟩, P the obtained statistics,
K
i.e., the sample mean, is denoted by ā1 = i=1 Vi /K. The large
number theorem indicates ā1 = a1 when K → ∞. However, only
the finite number of measurements K is allowed in practice and thus
results in an estimation error.

2.3 Quantum Read-in and Read-out protocols

The terms quantum read-in and read-out refer to the processes of transfer-
ring information between classical systems and quantum systems. These are
42 CHAPTER 2. BASICS OF QUANTUM COMPUTING

fundamental steps in the workflow of quantum machine learning shown in

Figure 1.1, responsible for loading data and extracting results.
Quantum read-in and read-out pose significant bottlenecks in leveraging
quantum computing to address classical computational tasks. As empha-
sized in (Aaronson, 2015), while quantum algorithms can offer exponential
speed-ups in specific problem domains, these advantages can be negated if
the processes of loading classical data into quantum systems (read-in) or
extracting results from quantum systems (read-out) are inefficient. Specifi-
cally, the high-dimensional nature of quantum states and the constraints on
measurement precision often lead to overheads that scale poorly with prob-
lem size. These challenges underscore the importance of optimizing quantum
read-in and read-out protocols to realize the full potential of quantum com-
puting. Below is a detailed introduction to quantum read-int and read-out
protocols, including the basic concept and several typical algorithms.

2.3.1 Quantum read-in protocols

Quantum read-in refers to the process of encoding classical information into
quantum systems that can be manipulated by a quantum computer, which
can be regarded as the classical-to-quantum mapping. It acts as a bridge
to utilize quantum algorithms to solve classical problems in quantum com-
puting. Here, we will introduce several typical encoding methods, including
basis encoding, amplitude encoding, angle encoding, and quantum random
access memory. Some easy-to-use demonstrations are provided in Chap-
ter 2.5.

Basis encoding
Basis encoding is a basic method for processing classical data that can be
represented in binary form. Given a classical binary vector x = (x0 , . . . , xi , . . . , xN −1 ) ∈
{0, 1}N , this encoding technique maps the vector directly into a quantum
computational basis state as follows:
|ψ⟩ = |x0 , . . . , xN −1 ⟩ . (2.44)
In this process, N qubits are required to represent a binary vector of length
N . To prepare the corresponding quantum state |ψ⟩, an X gate is applied
to each qubit where the corresponding bit value is 1. The overall quantum
state preparation can be expressed as:
N
O −1
|ψ⟩ = X xi |0⟩⊗N ,
i=0
2.3. QUANTUM READ-IN AND READ-OUT PROTOCOLS 43

where |0⟩⊗N represents an initial state of all qubits set to |0⟩, and X xi means
applying the X gate to the i-th qubit only if xi = 1.

Example 2.16. (Basis encoding). Consider encoding the integer 6,

which has the binary representation x = (1, 1, 0). The corresponding
quantum state is |110⟩. This state can be implemented by applying X
gates to the first and second qubits, as shown in Figure 2.6.

|0⟩ X |1⟩
|0⟩ X |1⟩
|0⟩ |0⟩
Figure 2.6: Example of basis encoding for the integer 6.

Amplitude encoding
Amplitude encoding is a technique that maps classical data into the ampli-
N
tudes of a quantum state. Given a vector x = (x0 , . . . , xi , . . . , x2N −1 ) ∈ C2
containing complex values, we first apply L2 normalization to obtain a nor-
malized vector
x
x̂ = , (2.45)
∥x∥2
where ∥x∥2 is the Euclidean norm. This ensures that the normalized vec-
PN
tor x̂ satisfies 2i=0−1 |x̂i |2 = 1. The corresponding quantum state is then
expressed as
N −1
2X
|ψ⟩ = x̂i |i⟩ (2.46)
i=0

with |i⟩ representing the N -qubit computational basis states.

Example 2.17. (Amplitude encoding). Consider encoding a normalized

vector x = (x0 , x1 ) ∈ C2 into the quantum state |ψ⟩ = x0 |0⟩ + x1 |1⟩.
This can be achieved by applying a rotation gate U = RY (θ) to the
initial state |0⟩, where θ = 2 arccos(x0 ).
44 CHAPTER 2. BASICS OF QUANTUM COMPUTING

Amplitude encoding is highly efficient because it allows an exponentially

large vector of length 2N to be represented using only N qubits. However,
preparing this quantum state requires constructing a unitary transformation
U such that |ψ⟩ = U |0⟩⊗N . Efficiently finding such transformations can
be challenging and is an active area of research (see Chapter 2.6 for the
discussions).

Angle encoding
Basis encoding and amplitude encoding are fundamental techniques for map-
ping classical data to quantum states, but each comes with distinct resource
costs. Basis encoding requires a number of qubits equal to the dimension-
ality of the binary representation of classical data and necessitates minimal
gate operations for state preparation. In contrast, amplitude encoding is
highly compact in terms of qubits, using only the logarithmic of the data
dimensionality, but it involves a significant gate complexity.
To address this limitation, an alternative is angle encoding. The core idea
of angle encoding is to embed classical data into a quantum state through
rotation angles.
Given a real-valued vector x = (x0 , . . . , xi , . . . , xN −1 ) ∈ RN , the en-
coded quantum state can be represented as:
N
O −1 N
O −1  x 
⊗N i
|ψ⟩ = Rσ (xi ) |0⟩ = exp −i σ |0⟩⊗N , (2.47)
2
i=0 i=0

where σ ∈ {X, Y, Z} denotes a Pauli operator, as defined in Figure 2.1. Since

Pauli rotation gates are 2π-periodic, it is essential to scale each element xi
into the range [0, π) to ensure that different values are encoded into distinct
quantum states.
A key advantage of angle encoding is its ability to introduce nonlinearity.
By mapping classical data into the parameters of quantum rotation gates,
angle encoding leverages trigonometric functions to naturally capture non-
linear relationships. This property is particularly important in quantum
machine learning, where nonlinearity is essential for models to learn complex
patterns in data, such as non-linearly separable decision boundaries.

Quantum Random Access Memory (QRAM)

Basis encoding, amplitude encoding, and angle encoding are generally de-
signed to encode a single item of data at one time, which makes it challenging
to process complicated classical datasets. The QRAM (Giovannetti et al.,
2.3. QUANTUM READ-IN AND READ-OUT PROTOCOLS 45

2008), analogous to classical RAM, aims to simultaneously store, address,

and access multiple quantum states.
QRAM consists of two types of qubits: data qubits for storing clas-
sical data and address qubits for addressing. Given a classical dataset
−1
D = {x(j) }M j=0 with M training examples, assume we separately encode
each data item into a quantum state |x(j) ⟩d using one of the encoding meth-
ods above. The QRAM can be constructed as follows: (1) Prepare an Na -
qubit address register where Na = ⌈log2 (M )⌉; (2) Associate each data state
|x(j) ⟩d with corresponding address state |j⟩a . The whole dataset is therefore
encoded into a quantum state of the form
M
X −1
1
|D⟩ = √ |j⟩a |x(j) ⟩d . (2.48)
j=0
M

Remark

The subscript d in |x(j) ⟩d indicates that this quantum state resides

in the data register, differentiating it from address qubits, which are
denoted with the subscript a (e.g., |j⟩a ). This convention helps to
distinguish between the roles of data and address qubits in QRAM
operations.

Example 2.18. (QRAM Encoding). Consider a dataset D = {2, 3}.

Using basis encoding, each sample is first converted into a two-qubit
quantum state: {|10⟩d , |11⟩d }. Each data state is then assigned an ad-
dress state, |0⟩a for the first state |10⟩d and |1⟩a for the second state
|11⟩d . The resulting QRAM-encoded state is:

1
|D⟩ = √ (|0⟩a |10⟩d + |1⟩a |11⟩d ). (2.49)
2
The corresponding quantum circuit for implementing this state is
shown in Fig. 2.7.

QRAM allows the dataset D to be stored in a coherent quantum super-

position, enabling simultaneous access to all data items through the entan-
glement of address and data qubits. While QRAM is theoretically powerful,
its practical implementation remains a significant challenge due to the need
for a large number of qubits and quantum operations (see Chapter 2.6 for
the discussion).
46 CHAPTER 2. BASICS OF QUANTUM COMPUTING

|0⟩a H X X
|0⟩d
|0⟩d

Figure 2.7: Example of QRAM encoding for the dataset D = {2, 3}.

2.3.2 Quantum read-out protocols

Quantum read-out refers to the process of translating the quantum state
resulting from a quantum computation into classical data, enabling further
processing, interpretation, or optimization in classical systems. This process
can be considered the inverse operation of quantum read-in, representing a
quantum-to-classical mapping.
Based on the completeness of the information obtained during the read-
out process, quantum read-out protocols can be broadly categorized into two
types, i.e., full information and partial information read-out protocols. These
protocols enable tailored read-out processes that match the requirements of
different quantum applications, ranging from tomography to optimization
and machine learning tasks.

Full information read-out protocol

The full information read-out protocol is used to completely reconstruct the
quantum state, which is used to fully understand the quantum system’s be-
havior. The most general approach to implementing this protocol is through
quantum state tomography (QST) (Vogel and Risken, 1989).
QST involves performing quantum measurements, gathering measure-
ment statistics, and using classical post-processing to reconstruct the quan-
tum state. In what follows, we introduce two reconstruction techniques
broadly used in QST, i.e., linear inversion (Qi et al., 2013) and maximum
likelihood estimation (MLE) (Hradil, 1997).
QST with linear inversion. Linear inversion is a straightforward method to
reconstruct the quantum state from measurement data by directly solving
linear systems of equations. Let ρ be the explored quantum state and {Ei }
be a set of measurements. According to the Born rule, the probability of
measurement outcome i is given by
Pr(Ei |ρ) = Tr(ρEi ). (2.50)
1
In practice, Pr(Ei |ρ) is not directly accessible but is approximated by the
frequency pi of measurement outcome i over multiple measurements. By the
2.3. QUANTUM READ-IN AND READ-OUT PROTOCOLS 47

law of large numbers, as the number of measurements increases, pi converges

to the true probability Pr(Ei |ρ). Collecting measurements across all bases,
we obtain a linear system
   †   
Tr(ρE0 ) ⃗ ·ρ
E 0 ⃗ p0
Tr(ρE1 ) E ⃗ †   
 = 1·ρ ρ ≈ p = p1 ,
⃗ = A⃗ (2.51)
.. .. ..
. . .

where E ⃗ and ρ⃗ refer to the vector representations of matrices Ei and ρ, re-

spectively. The vector representation of a matrix is obtained by stacking its
columns into a single-column vector. For example, the vector representation
of a 2 × 2 identity matrix is ⃗I2 = [1, 0, 0, 1]T . The matrix A is constructed
such that each row corresponds to the vector representation of the measure-
ment operator, i.e., A = [E ⃗ † ; ...]. The vector p contains the measured
⃗ †; E
0 1
frequencies pi .
Assuming the measurements are tomographically complete, i.e., {Ei }
forms a basis for the system’s Hilbert space, we can reconstruct ρ by solving
the following linear systems of equations, i.e.,

⃗ = (AT A)−1 AT p.
ρ (2.52)

A common strategy is to use Pauli operators as measurement bases {Ei }.

The density matrix ρ of an N -qubit system can be expanded in terms of the
Pauli basis as:
4 −1N
1 X
ρ= N ci Pi , ci ∈ R, Pi ∈ {I, X, Y, Z}⊗N , (2.53)
2
i=0

where the coefficients ci represent projections of ρ onto the Pauli basis,

calculated as:
ci = Tr(ρPi ). (2.54)
To fully reconstruct ρ, the quantum state must theoretically be measured
in all 4N − 1 Pauli bases to estimate each ci .

Remark
The Pauli basis consists of four Hermitian matrics I, X, Y and Z
introduced in Figure 2.1. These operators form a complete basis for
the space of 2 × 2 complex matrices. For N -qubit systems, the tensor
products of these single-qubit operators span the space of 2N × 2N
48 CHAPTER 2. BASICS OF QUANTUM COMPUTING

complex matrix. This makes the Pauli basis essential for representing
quantum states, observables, and their transformations.

A key limitation of linear inversion is that it does not guarantee a valid

density matrix, as the estimated quantum state may lack properties such as
positive semi-definiteness in Definition 2.4, especially with limited measure-
ments.
Maximum Likelihood Estimation (MLE). To ensure physical constraints on
the quantum state during reconstruction, MLE is introduced. MLE recon-
structs ρ by maximizing the likelihood of observing the measurement out-
comes, subject to the constraints that ρ is Hermitian, positive semi-definite,
and trace one. The likelihood function is given by
Y
L(ρ) = Tr(ρEi )pi . (2.55)
i

Reconstructing ρ then reduces to solving the following optimization problem

arg max L(ρ′ ), s.t. ρ′ ⪰ 0, ρ′ = ρ′† , Tr(ρ′ ) = 1. (2.56)

ρ′

Solving this typically requires iterative numerical optimization, which can

be computationally intensive.

Remark
A common challenge across all quantum state tomography (QST)
methods, including linear inversion and MLE, is the exponential com-
putational cost with respect to the number of qubits. Specifically,
the number of parameters to reconstruct grows exponentially with
the system size, making QST methods feasible only for small-qubit
systems in practice. This limitation underscores the need for scal-
able approaches to quantum state characterization in larger quantum
systems.

Partial information read-out protocol

The partial information read-out protocol focuses on extracting specific,
task-relevant information from a quantum state without reconstructing the
entire density matrix. This protocol is efficient and can be applied to com-
prehend large-qubit systems. According to the type of collected information,
2.3. QUANTUM READ-IN AND READ-OUT PROTOCOLS 49

current partial read-out protocols can be categorized into three classes, i.e.,
sampling, expectation value estimation, and shadow tomography.
Sampling. Sampling involves repeatedly measuring the quantum state in the
computational basis to estimate the probability distribution over bit-strings.
Given a state |ψ⟩, the probability of observing a specific computational basis
|i⟩ is given by
Pr(i) = |⟨ψ|i⟩|2 . (2.57)
The empirical frequency of each outcome from repeated measurements pro-
vides an estimate of Pr(i). Sampling is particularly useful in the following
applications

• Sampling over complicated distributions. Quantum states can rep-

resent complex probability distributions that are difficult to sample
classically. Quantum sampling allows efficient exploration of these
distributions for specific applications, such as probabilistic modeling
and Markov chain Monte Carlo (Layden et al., 2023).

• Optimization problems. Sampling can identify high-probability bit-

strings in quantum algorithms, such as the Quantum Approximate Op-
timization Algorithm (Farhi et al., 2014) and Grover search (Grover,
1996), where these bitstrings often correspond to optimal or near-
optimal solutions.

• Verification. Sampling facilitates the comparison of a quantum cir-

cuit’s output with theoretical expectations or desired distributions,
helping to verify the quantum systems (Boixo et al., 2018; Bouland
et al., 2019; Arute et al., 2019).

Expectation value estimation. For a wide class of quantum computation

problems, such as quantum chemistry and quantum many-body physics,
the computation outcome refers to the estimation of the expectation values
of certain observables on the evolved quantum state (Kandala et al., 2017a;
Tilly et al., 2022).
N N
An observable O ∈ C2 ×2 mentioned here is a Hermitian operator that
represents a measurable physical quantity. For an N -qubit system, O can
be expressed in terms of a Pauli basis expansion, i.e.,

4 N
X
O= αi Pi , Pi ∈ {I2 , X, Y, Z}⊗N , αi ∈ R. (2.58)
i=1
50 CHAPTER 2. BASICS OF QUANTUM COMPUTING

where Pi denotes the i-th N -qubit Pauli string.

The expectation value of an observable O with respect to an N -qubit
state ρ is
⟨O⟩ = Tr(ρO). (2.59)
Substituting the Pauli expansion of O, the expectation value is expressed
as the weighted sum of the expectation values of each Pauli basis term due
to the linearity of the trace operation, i.e.,

4N 4N
X X
⟨O⟩ = αi Tr(ρPi ) ≡ αi ⟨Pi ⟩ . (2.60)
i=1 i=1

To estimate the expectation value of each individual Pauli term Pi , the

quantum state ρ must be measured on the basis of the eigenstates of Pi . The
measurement outcome is then associated with the corresponding eigenvalue
of Pi . Notably, the eigenstates and eigenvalues of Pi can be derived from
the eigenstates and eigenvalues of its constituent single-qubit Pauli operators
Pij :

• Eigenvalues. The eigenvalues of Pi are the product of the eigenvalues of

each single-qubit Pauli operator Pij , i.e., Pi = ⊗N
j=1 Pij . For example,
if the eigenvalues of Pij are ±1, then the eigenvalues of Pi are products
of these individual eigenvalues and remain in {±1}.

• Eigenstates. The eigenstates of Pi are the tensor products of the

eigenstates of the single-qubit Pauli operators Pij . If |λijk ⟩ is one
of the eigenstate of Pij , then the corresponding eigenstate of Pi is
NN
j=1 |λijk ⟩.

This structure allows Pi to be analyzed in terms of its simpler single-qubit

components, significantly simplifying the process of determining the mea-
surement basis for expectation value estimation. By repeating the mea-
surements M times and obtaining the corresponding measurement results
{rj }M
j=1 , the statistical value of ⟨Pi ⟩ can be estimated by

M
1 X
⟨P̂i ⟩ = rj . (2.61)
M
j=1

The expectation
P value of the observable O is therefore statistically estimated
by ⟨Ô⟩ = K−1
i=0 αi ⟨P̂i ⟩.
2.3. QUANTUM READ-IN AND READ-OUT PROTOCOLS 51

Remark
A key step in the process is to measure the quantum system in the ba-
sis of the eigenstates of Pi . If Pi is diagonal in the computational basis
(e.g., a tensor product of Pauli-Z operators), we can directly measure
the state without additional operations. Otherwise (e.g., for Pauli-X
or Pauli-Y operators), we need to apply a unitary transformation to
rotate the quantum state into the desired basis. Specifically, when
measuring in the Pauli-X basis (i.e., |+⟩ and |−⟩), a Hadamard gate
H is applied to the state ρ, i.e.,

ρ′ = HρH. (2.62)

When measuring in the Pauli-Y basis (i.e., |0⟩+i|1⟩

√ and |0⟩−i|1⟩
√ ), a
√ 2 2
phase gate S = Z followed by a Hadamard gate H is applied, i.e.,

ρ′ = S † HρHS. (2.63)

Measuring the state ρ′ in the computational basis is equivalent to

measuring the state ρ in the corresponding Pauli basis.

Shadow tomography. Performing full QST requires an exponential number

of copies of the quantum state, making it impractical for systems beyond
a small number of qubits. Instead of reconstructing the complete density
matrix, shadow tomography Aaronson (2018) focuses on efficiently obtaining
specific properties of a quantum state, such as the expectation values of
many observables.

Definition 2.19 (Shadow tomography, Aaronson (2018)). Given an un-

known D-dimensional quantum state ρ, as well as M observables O1 , ..., OM ,
output real numbers b1 , ..., bM such that |bi − Tr(Oi ρ)| ≤ ϵ for all i, with
success probability at least 1 − δ. Do this via a measurement of ρ⊗k , where
k = k(D, M, ϵ, δ) is as small as possible.

Aaronson (2018) proved that the shadow tomography problem can be

solved using a polylogarithmic number of copies of states in terms of the di-
mension D and number M of observables. This result demonstrates that it
is possible to estimate the expectation values of exponentially many observ-
ables for a quantum state of exponential dimension using only a polynomial
number of measurements.
52 CHAPTER 2. BASICS OF QUANTUM COMPUTING

The central idea of shadow tomography is to create a compact measure-

ment classical representation, or “shadow”, of a quantum state that encodes
sufficient information to estimate many properties of the state. Building on
this concept, Huang et al. (2020b) proposed a more practical and efficient
approach, termed classical shadow, which uses randomized measurements
to construct this classical representation. The classical shadow approach
consists of the following steps:

1. Randomized measurements. Perform random unitary transformations

on the quantum state and measure the transformed state in the com-
putational basis. These random transformations can be drawn from
specific ensembles, such as Clifford gates or local random rotations,
which ensure that the measurement outcomes capture the essential
properties of the quantum state.

2. Classical shadow construction. Using the measurement results, con-

struct a classical shadow of the quantum state. This compact rep-
resentation encodes the quantum state in a way that allows for the
efficient estimation of properties.

3. Property estimation. Use the classical shadow to compute the desired

properties of the quantum state, such as expectation values of specific
observables, subsystem entropies, or fidelities with known states.

Shadow tomography requires exponentially fewer measurements com-

pared to full quantum state tomography, making it a practical solution for
large-scale quantum systems. Moreover, the shadow of a quantum state
serves as a versatile representation, enabling the efficient estimation of vari-
ous properties such as expectation values, entanglement measures, and sub-
system correlations.

2.4 Quantum Linear Algebra

We next introduce quantum linear algebra, a potent toolbox for designing
various FTQC-based algorithms introduced in Chapter 1.2.2. For clarity, we
start with the definition of block encoding in Chapter 2.4.1, which is about
how to implement a matrix on the quantum computer. Based on this, we in-
troduce some basic arithmetic rules for block encodings in Chapter 2.4.2, like
the multiplication, linear combination, and the Hadamard product. Finally,
in Chapter 2.4.3, we introduce the quantum singular value transformation
2.4. QUANTUM LINEAR ALGEBRA 53

a
|0⟩ 0
UA A|ψ⟩
|ψ⟩ ∥A|ψ⟩∥

Figure 2.8: Quantum circuit for block encoding.

method, which enables one to implement functions onto singular values of

block-encoded matrices.

2.4.1 Block encoding

For many computational problems, such as solving linear equations, we need
to deal with a non-unitary matrix A. However, remember that quantum
gates as discussed in Chapter 2.2 are unitaries. Therefore, if we want to
solve these problems on quantum computers, it is essential to consider how
to encode the matrix A into a unitary. This challenge can be addressed by
the block encoding technique.

Definition 2.20 (Block encoding, Gilyén et al. (2019)). Suppose that A is

an N -qubit operator, α, ε ≥ 0 and a ∈ N. Then we say that the (a+N )-qubit
unitary U is an (α, a, ε)-block-encoding of A if

∥A − α(⟨0|⊗a ⊗ I2N )U (|0⟩⊗a ⊗ I2N )∥ ≤ ε. (2.64)

Here, ∥ · ∥ represents the spectral norm, i.e., the largest singular value of the
matrix.

The circuit implementation of the block encoding is illustrated in Fig-

ure 2.8. The scaled matrix A/α interacts with the state |ψ⟩ if the first qubit
registers are measured as |0⟩. By definition, we have α ≥ ∥A∥ and any
unitary U is an (1, 0, 0)-block encoding of itself.

Fact 2.21. (Block encoding via the linear combination of unitaries (LCU)
method, Gilyén et al. (2019)). Suppose that A can be written in the form
X
A= αk Uk , (2.65)
k

where {αk } are real numbers and Uk are some easily prepared unitaries such
as Pauli strings. Then, the LCU method allows us to have the access to two
54 CHAPTER 2. BASICS OF QUANTUM COMPUTING

unitaries, i.e.,
X
USEL = |k⟩⟨k| ⊗ Uk , (2.66)
k
1 X√
UPREP : |0⟩ → p αk |k⟩ , (2.67)
∥⃗
α ∥1 k
where α⃗ = (α1 , α2 , . . . ).
†
After simple mathematical analysis, one can obtain U = (UPREP ⊗
I2N )USEL (UPREP ⊗ I2N ) is a (∥⃗α∥1 , m, 0)-block-encoding of A. Here, I2N
is the identity operator of N -qubit size and ∥ · ∥1 denotes the ℓ1 norm of a
given vector.
Similar to the definition of block encoding, we can also define the state
preparation encoding.
Definition 2.22 (State preparation encoding Guo et al. (2024a)). We say
a unitary Uψ is an (α, a, ϵ)-state-encoding of an N -qubit quantum state |ψ⟩
if
∥|ψ⟩ − α(⟨0a | ⊗ I)Uψ |0a+N ⟩∥∞ ≤ ϵ, (2.68)
where ∥ · ∥∞ denotes the infinity norm of the given vector.
More straightforwardly, the (α, a, ϵ)-state-encoding Uψ prepares the state
1 p
Uψ |0⟩ |0⟩ = |0⟩ |ψ ′ ⟩ + 1 − α2 |1⟩ |bad⟩ ,
α
′
where ∥|ψ ⟩ − |ψ⟩∥∞ ≤ ϵ and |bad⟩ is an arbitrary quantum state. One can
further prepare the state |ψ ′ ⟩ by using O(α) times of amplitude amplification
(Brassard et al., 2002). The state preparation encoding can be understood
as a specific case of the block encoding, i.e., it is the block encoding of a
N
C2 ×1 matrix.

2.4.2 Basic arithmetic for block encodings

Now we introduce some arithmetic rules for block encoding unitaries. The
following two facts describe the product and linear combination rules of
block encoding unitaries, respectively.
Fact 2.23 (Product of block encoding, Gilyén et al. (2019)). If U is an
(α, a, δ)-block encoding of an N -qubit operator A, and V is a (β, b, ε)-block
encoding of an N -qubit operator B, then (I2b ⊗ U )(I2a ⊗ V ) is an (αβ, a +
b, αε+βδ)-block-encoding of AB. Here, I2a is the identity operator of a-qubit
size.
2.4. QUANTUM LINEAR ALGEBRA 55

FactP 2.24 (Linear combination of block encoding, Gilyén et al. (2019)). Let
A = k xk Ak be an s-qubit operator with β ≥ ∥⃗x∥1 and ε1 > 0, where ⃗x is
the vector of coefficients. Suppose we have access to
X
PL |0⟩ = ck |k⟩ , (2.69)
k
X
PR |0⟩ = dk |k⟩ , (2.70)
k
!
X X

W = |k⟩⟨k| ⊗ Uk + Is − |k⟩⟨k| ⊗Ia ⊗ Ib , (2.71)
k k
P ∗
where − xk | ≤ ε1 and Uk is an (α, a, ε2 )-block-encoding of Ak .
k |βck dk
Then we can implement an (αβ, a + b, αε1 + βε2 )-block-encoding of A by
using one time of W, PL , and PR .
These results can be verified via direct computation. Another arithmetic
rule broadly employed in quantum machine learning is the Hadamard prod-
uct, a.k.a, the element-wise product. The following lemma exhibits how to
achieve this operation via the block encoding framework.
Lemma 2.25 (Hadamard product of the block encoding unitaries, Guo et al.
N N
(2024a)). With N ∈ N, consider two matrices A, B ∈ C2 ×2 , and assume
that we have an (α, a, δ)-encoding UA of matrix A and (β, b, ϵ)-encoding UB
of matrix B, then we can construct an (αβ, a + b + N, αϵ + βδ)-encoding of
matrix A ◦ B corresponding to the Hadamard product of A and B.
Proof sketch of Lemma 2.25. For simplicity, we only consider the perfect
case, i.e., no errors. Refer to Ref. (Guo et al., 2024a) for the proof details
under the more general cases.
The intuition for achieving the Hadamard product is that all the needed
elements can be found in the tensor product, i.e.,
(⟨0a+b | ⊗ I22N )(I2b ⊗ UA ⊗ I2N )(I2a ⊗ UB ⊗ I2N )(|0a+b ⟩ ⊗ I22N ) (2.72)
A⊗B
= .
αβ
To this end, the question is reduced to finding proper permutation uni-
taries that can shift the required elementsPto the correct positions to achieve
d−1
the Hadamard product. Denote P ′ = i=0 |i⟩⟨i| ⊗ |0⟩⟨i|. As proved by
Zhao et al. (2021), the tensor product of A and B can be reformulated to
the Hadamard product via P , i.e.,
P ′ (A ⊗ B)P ′† = (A ◦ B) ⊗ |0⟩⟨0|.
56 CHAPTER 2. BASICS OF QUANTUM COMPUTING

Pd−1
However, P ′ is not a unitary. Instead, we consider P = i,j=0 |i⟩⟨i| ⊗
|i ⊕ j⟩⟨j|, which can be easily constructed by using N CNOT gates, i.e.,
one CNOT gate between each pair of qubits consisting of one qubit from
the first register and the corresponding qubit from the second register. By
direct computation, we have

(I2N ⊗ ⟨0N |)P (A ⊗ B)P † (I2N ⊗ |0N ⟩) = A ◦ B. (2.73)

Therefore, by direct computation, one can verify that (P ⊗ I2a+b )(I2b ⊗ UA ⊗

I2N )(I2a ⊗ UB ⊗ I2N )(P † ⊗ I2a+b ) is the desired block encoding.

2.4.3 Quantum singular value transformation

Now we understand how to implement matrices on the quantum computer
and some arithmetic methods among these matrices, here we further intro-
duce how one can implement matrix functions on the quantum computer.
The method is called the quantum singular value transformation (QSVT),
which is a powerful framework that can unify most known quantum algo-
rithms.
For machine learning applications, we mostly deal with the real matrices.
The computational cost of QSVT for the real matrix case is summarized in
the following theorem.
P For a matrix A, consider its singular value decom-
|ψ ⟩⟨ϕ (SV ) (A) to
position A = σ
i i Pi i |. Given a function P (x), we use P
represent P (SV ) (A) = i P (σi )|ψi ⟩⟨ϕi |.

Fact 2.26 (Quantum singular value transformation - Real matrix case,

Gilyén et al. (2019)). Suppose that UA is an (α, a, ε)-block-encoding of a
real matrix A. If δ ≥ 0 and P : R → C is a d-degree polynomial satisfying
that
1
for all x ∈ [−1, 1] : |P (x)| ≤ , (2.74)
4
p
then there is a quantum circuit Ũ , which is an (1, a + 3, 4d ε/α + δ)-block-
encoding of P (SV ) (A/α), and consists of d applications of UA and UA† gates.
Further, the description of such a circuit can be computed classically in time
O(poly(d, log(1/δ))).

Notice that if the block-encoded matrix A is Hermitian, the singular

value transformation is equivalent to the eigenvalue transformation. In this
case, we can directly implement the matrix function via QSVT.
2.4. QUANTUM LINEAR ALGEBRA 57

In the following, we introduce some applications of QSVT method. There

are several important applications, however, in this tutorial, we focus on in-
troducing some applications that can be applied to machine-learning related
tasks. The first is matrix inversion, which has been widely used in traditional
machine learning methods such as principal component analysis. Note that
for a general matrix, we actually mean to implement the Moore-Penrose
pseudoinverse, i.e., the inverse of all singular values.

Lemma 2.27 (Matrix inversion, simplified Gilyén et al. (2019)). Let UA be

a (1, a, 0)-block encoding of matrix A. Further, for simplicity, assume the
nonzero singular values of A are lower bounded by δ > 0. Let 0 ≤ ϵ ≤ δ ≤ 12 .
One can construct a (1/δ, a+2, ϵ)-block encoding of A−1 by using Õ( 1δ log( 1ϵ ))
times of UA and UA† .

Proof sketch of Lemma 2.27. This can be achieved by finding a good poly-
nomial approximation for the function 1/x. One can not find such a poly-
nomial on the whole interval [−1, 1], however, such a polynomial exists on
the interval [−1, −δ] ∪ [δ, 1] for some δ > 0.

The second application of QSVT is the nonlinear amplitude transforma-

tion. As mentioned in Chapter 2.3.1, to deal with classical data, there are
several ways to encode them into quantum. Here, we focus on the amplitude
encoding case described in Chapter 2.3.1, especially for the real amplitudes.
The nonlinear transformation is achieved by combining the diagonal block
encoding and QSVT.

Fact 2.28 (Diagonal block encoding of amplitudes, Guo et al. (2024b);

Rattew and Rebentrost (2023)). Given a state preparation unitary Uψ of an
PN
N -qubit state |ψ⟩ = 2j=1 ψj |j⟩, where {ψj } are real, ∥ψ∥2 = 1, one can con-
struct an (1, N + 2, ϵ)-encoding of the diagonal matrix A = diag(ψ1 , . . . , ψd )
with O(N ) circuit depth and O(1) times of controlled-U and controlled-U † .

As a straightforward generalization, one can replace the state prepa-

ration unitary with the general state preparation encoding, mentioned in
Definition 2.22. By constructing the block encoding of amplitudes, one can
implement many functions onto these amplitudes via QSVT. A direct appli-
cation is performing the neural network on the quantum computer, as will
be detailed in Chapter 5.2.
 58 CHAPTER 2. BASICS OF QUANTUM COMPUTING

2.5 Code Demonstration

This section provides code implementations for key techniques introduced
earlier, including quantum read-in strategies and block encoding, to give
readers the opportunity to practice and deepen their understanding.

2.5.1 Read-in implementations

This subsection demonstrates toy examples of implementing data encoding
methods in quantum computing, as discussed in earlier sections. Specif-
ically, we cover basis encoding, amplitude encoding, and angle encoding
from Chapter 2.3.1. These examples aim to provide readers with hands-on
experience in applying quantum data encoding techniques.

Basis encoding
PennyLane provides built-in support for basis encoding through its ‘Ba-
sisEmbedding’ function. Below is the Python code demonstrating the basis
encoding for the integer 6.
1 import pennylane as qml
2
3 dev = qml . device ( " default . qubit " , range (3) )
4 @qml . qnode ( dev )
5 def circuit ( x ) :
6 qml . BasisEmbedding (x , range (3) )
7 return qml . state ()
8
9 # Call the function
10 circuit (6)

Amplitude encoding
PennyLane offers built-in support for amplitude encoding via the ‘Ampli-
tudeEmbedding’ function. Below is a Python example demonstrating am-
plitude encoding for a randomly generated complex vector.
1 import pennylane as qml
2 import numpy as np
3
4 # Number of qubits
5 n_qubits = 8
6
 2.5. CODE DEMONSTRATION 59

7 # Define a quantum device with 8 qubits

8 dev = qml . device ( " default . qubit " , wires = n_qubits )
9
10 @qml . qnode ( dev )
11 def circuit ( x ) :
12 qml . Am pl it ud eEm be dd in g ( features =x , wires = range (
n_qubits ) , normalize = True , pad_with =0.)
13 return qml . state ()
14
15 # Generate a random complex vector of length 2^ n_qubits
16 x_real = np . random . normal ( loc =0 , scale =1.0 , size =2**
n_qubits )
17 x_imag = np . random . normal ( loc =0 , scale =1.0 , size =2**
n_qubits )
18 x = x_real + 1 j * x_imag
19

20 # Execute the circuit to encode the vector as a quantum

state
21 circuit ( x )

Angle encoding
PennyLane provides built-in support for angle encoding via the ‘AngleEm-
bedding’ function. Below is a Python example demonstrating angle encoding
for a randomly generated real vector.
1 import pennylane as qml
2 import numpy as np
3
4 # Number of qubits
5 n_qubits = 8
6
7 # Define a quantum device with 8 qubits
8 dev = qml . device ( " default . qubit " , wires = n_qubits )
9
10 @qml . qnode ( dev )
11 def circuit ( x ) :
12 qml . AngleEmbedding ( features =x , wires = range ( n_qubits ) ,
rotation = " X " )
13 return qml . state ()
14
15 # Generate a random real vector of length n_qubits
16 x = np . random . uniform (0 , np . pi , ( n_qubits ) )
17
 60 CHAPTER 2. BASICS OF QUANTUM COMPUTING

18 # Execute the circuit to encode the vector as a quantum

state
19 circuit ( x )

2.5.2 Block encoding

Here, we provide an example of how we may construct a block encoding.
We construct the block encoding via the linear combination, as fact 2.21.
We use PennyLane to keep consistency, yet there are many other platforms
that are available as well. Please note that it is time-consuming to do the
Pauli decomposition (for an N -qubit matrix, it takes time O(N 4N )), so we
suggest not trying a large matrix with this method.
1 import numpy as np
2 import pennylane as qml
3 import matplotlib . pyplot as plt
4
5 a = 0.36
6 b = 0.64
7
8 # matrix to be decomposed
9 A = np . array (
10 [[ a , 0 , 0 , b ] ,
11 [0 , -a , b , 0] ,
12 [0 , b , a , 0] ,
13 [b , 0 , 0 , -a ]]
14 )
15
16 # decompose the matrix into sum of Pauli strings
17 LCU = qml . pauli_decompose ( A )
18 LCU_coeffs , LCU_ops = LCU . terms ()
19
20 # normalized square roots of coefficients
21 alphas = ( np . sqrt ( LCU_coeffs ) / np . linalg . norm ( np . sqrt (
LCU_coeffs ) ) )
22
23 dev = qml . device ( " default . qubit " , wires =3)
24
25 # unitaries
26 ops = LCU_ops
27 # relabeling wires : 0 --> 1 , and 1 --> 2
28 unitaries = [ qml . map_wires ( op , {0: 1 , 1: 2}) for op in
ops ]
29
 2.6. BIBLIOGRAPHIC REMARKS 61

30 @qml . qnode ( dev )

31 def lcu_circuit () : # block_encode
32 # PREP
33 qml . StatePrep ( alphas , wires =0)
34
35 # SEL
36 qml . Select ( unitaries , control =0)
37
38 # PREP_dagger
39 qml . adjoint ( qml . StatePrep ( alphas , wires =0) )
40 return qml . state ()
41
42 print ( np . real ( np . round ( output_matrix ,2) ) )

2.6 Bibliographic Remarks

We end this chapter by discussing the recent advancements in efficiently
implementing fundamental components of quantum computing. For clarity,
we begin with a brief discussion of advanced quantum read-in and read-out
protocols, which are crucial for efficiently loading and extracting classical
data in the pipeline of quantum machine learning. Next, we review the
latest progress in quantum linear algebra.

2.6.1 Advanced quantum read-in protocols

Although conventional read-in protocols offer feasible solutions for encoding
classical data into quantum computers, they typically face two key challenges
that limit their broad applicability for solving practical learning problems.
To address these limitations, initial efforts have been made to develop more
advanced quantum read-in protocols.
Challenge I: high demand for quantum resources. Encoding methods like
amplitude encoding and basis encoding presented in Chapter 2.3.2 generally
suffer from high quantum resource requirements. While amplitude encoding
is highly compact in terms of qubit requirements, the trade-off is the re-
quirement of an exponential number of quantum gates with the data size to
prepare an exact amplitude-encoded state. In contrast, while basis encoding
can be implemented with a small number of quantum gates, it requires a
large number of qubits proportional to the input size. The high demand for
either quantum gates or qubit counts makes these basic encoding strategies
infeasible for practical use.
62 CHAPTER 2. BASICS OF QUANTUM COMPUTING

Challenge II: insufficient nonlinearity. While quantum mechanics is inher-

ently linear, most practical machine learning models require nonlinearity to
capture complex data patterns effectively. Conventional encoding methods
like angle encoding introduce some degree of nonlinearity; however, the rep-
resentational power remains limited due to the linear nature of quantum
operations and limited circuit depth.
For Challenge I, a practical alternative is the approximate amplitude
encoding (AAE) (Nakaji et al., 2022). Instead of implementing exact am-
plitude encoding, AAE trains a parameterized quantum circuit with a con-
strained depth to approximate the desired quantum state with high fidelity.
The training process optimizes the fidelity between the target state and the
approximate state, ensuring that the representation error remains within a
small bound.
For Challenge II, techniques like data re-uploading (Pérez-Salinas et al.,
2020) have been developed. Data re-uploading involves feeding the same
classical data into the quantum circuit multiple times, interspersed with
trainable quantum operations. By alternating data encoding with train-
able transformations, this approach allows the quantum model to capture
non-linear relationships more effectively without requiring additional qubits.
Additionally, neural quantum embedding (Hur et al., 2024) has been pro-
posed, which leverages classical deep learning techniques to learn optimal
quantum embeddings, effectively separating non-linearly separable classes
of data.
To address both Challenges I & II, hybrid encoding strategies have been
introduced to leverage the respective advantages of each encoding method.
For instance, basis-amplitude encoding combines basis encoding for discrete
random variables with amplitude encoding for high-precision probabilities,
effectively encoding both categorical and continuous features without requir-
ing additional qubits (Schuld et al., 2018). Another widely used strategy
involves classical preprocessing methods for high-dimensional data, such as
principal component analysis (PCA) (Abdi and Williams, 2010), to reduce
input dimensionality before applying quantum encoding. This preprocess-
ing step reduces the overall quantum resource requirements while preserving
relevant information.
In addition to fixed encoding strategies, learning-based approaches have
emerged to dynamically adjust data encoding for specific tasks. For ex-
ample, Lloyd et al. (2020) achieves task-specific quantum embeddings by
incorporating learnable parameters into the encoding layers, which are op-
timized to maximize class separability in Hilbert space. This technique is
2.6. BIBLIOGRAPHIC REMARKS 63

analogous to classical metric learning. Following this routine, a quantum

few-shot embedding framework (Liu et al., 2022) has been proposed to en-
code classical data into quantum states, which can be generalized to the
downstream quantum machine learning tasks. These methods enable quan-
tum circuits to adapt their encodings dynamically, improving efficiency and
performance.

2.6.2 Advanced quantum read-out protocols

Conventional quantum read-out protocols often face significant challenges,
including high computational overhead and resource inefficiencies. Below,
we discuss the primary challenges and discuss solutions in two quantum
read-out protocols: QST and observable estimation.
Challenge I: High computational overhead of QST. QST aims to reconstruct
the density matrix of a quantum state, but this becomes computationally
infeasible as the system size increases. This is because the required number
of measurements and the classical memory grows exponentially with the
number of qubits.
Challenge II: Resource inefficiency in observable estimation. The required
number of measurements for observable estimation grows linearly with the
number of Pauli terms in the observable. For observables where the number
of Pauli terms substantially increases with the system size, the measurement
cost becomes prohibitive.
For Challenge I, the key idea is to focus on representing only a subspace
of the quantum space, effectively capturing task-relevant properties while
reducing the computational cost. For example, in many QML algorithms,
such as the HHL algorithm for solving linear systems (Harrow et al., 2009)
and quantum singular value decomposition (Rebentrost et al., 2018a), the
solution state exists within the row or column space of the input matrix.
When the input matrix is low-rank, state tomography can be obtained effi-
ciently (Zhang et al., 2021a) as the linear combination of a complete basis
chosen from the input matrix. Besides, an effective technique is matrix
product state (MPS) tomography (Lanyon et al., 2017; Orús, 2019), which
leverages the fact that many practical quantum states, such as those in Ising
models or low-entanglement systems, can be efficiently represented with a
reduced number of parameters. By focusing on states with limited entan-
glement, MPS tomography reconstructs the state using only a polynomial
number of measurements with the qubit counts.
Another promising approach is the use of neural networks to parame-
terize quantum states. Neural quantum states allow for the efficient repre-
64 CHAPTER 2. BASICS OF QUANTUM COMPUTING

sentation and reconstruction of density matrices, particularly for complex

or high-dimensional quantum systems. For instance, Restricted Boltzmann
Machines (Fischer and Igel, 2012) and Transformer (Vaswani, 2017) have
been applied to approximate the probability of measurement outcome and
density matrices (Torlai et al., 2018; Schmale et al., 2022; Wang et al., 2022a;
Zhao et al., 2023). These approaches are particularly effective for systems
that are difficult to capture using traditional methods.
For Challenge II, a measurement reduction technique can be applied
by exploiting the commutativity of Pauli operators. When multiple Pauli
terms commute, they can be measured simultaneously within the same mea-
surement basis, significantly reducing the total measurement cost (Kandala
et al., 2017b; Verteletskyi et al., 2020). This approach has been widely
adopted in hybrid quantum-classical algorithms, such as variational quan-
tum Eigensolvers (VQE) (Cerezo et al., 2021a), where Hamiltonians are de-
composed into sums of Pauli terms. Grouping commuting terms into clusters
allows for efficient measurement strategies while preserving accuracy.
In addition to measurement grouping, adaptive measurement strategies
further improve resource allocation during expectation value estimation.
The key observation is that not all Pauli terms contribute equally to the to-
tal observable—terms with higher variance require more measurement shots
for reliable estimation, while low-variance terms can be measured with fewer
shots. Building on this insight, adaptive shot allocation techniques (Rubin
et al., 2018; Arrasmith et al., 2020; Qian et al., 2024) dynamically dis-
tribute measurement resources across Pauli terms based on their statistical
properties and achieve more accurate estimations with a finite measurement
budget.

2.6.3 Advanced quantum linear algebra

Quantum linear algebra, based on the block encoding and quantum singu-
lar value transformation framework, has proven its power for the design of
quantum algorithms. Compared to the traditional subroutines like quan-
tum phase estimation and quantum arithmetic (Kitaev, 1995; Ruiz-Perez
and Garcia-Escartin, 2017), quantum linear algebra can exponentially im-
prove the dependency on precision (Gilyén et al., 2019). However, a major
drawback is that it can only deal with the singular values of block-encoded
matrices.
A natural consideration is to generalize the singular value transformation
to the eigenvalue transformation. One strong motivation from the applica-
tion aspect for this is to solve the differential equations on the quantum
2.6. BIBLIOGRAPHIC REMARKS 65

computer (Liu et al., 2021a; Childs et al., 2021; An et al., 2021; Jin et al.,
2022; Shang et al., 2024). This remains an active research field. Quantum
eigenvalue processing, proposed by (Low and Su, 2024), focuses on matri-
ces with real spectra and Jordan forms, in which they prepare the Faber
history state to achieve efficient eigenvalue transformation over the complex
plane. (An et al., 2023, 2024) shows that simulating a general class of non-
unitary dynamics can be achieved by the linear combination of Hamiltonian
simulation (LCHS).
Another approach is to broaden the range of functions that can be im-
plemented by quantum linear algebra. Quantum phase processing, proposed
by (Wang et al., 2023b), can directly apply arbitrary trigonometric trans-
formations to eigenphases of a unitary operator. Similar results have been
independently obtained by Motlagh and Wiebe (2024). In addition, Rossi
and Chuang (2022) investigates how to implement multivariate functions.
For the application, a representative example is the multivariate state prepa-
ration achieved by (Mori et al., 2024), enabling the amplitude encoding of
classical multivariate data.
In Chapter 2.4, we introduce the concept of diagonal block encoding,
which can convert a state preparation unitary into a block encoding. As the
efficient construction of block encodings is a prerequisite for achieving end-
to-end quantum advantage, an important research direction is to investigate
which types of matrices can be efficiently prepared. By leveraging state-
of-the-art techniques in quantum state preparation (Zhang et al., 2022a;
Sun et al., 2023) and the linear combination of unitaries (Childs and Wiebe,
2012), it is possible to efficiently construct block encodings for certain classes
of matrices (Guseynov and Liu, 2024; Guseynov et al., 2024). Additionally,
explicit constructions have been explored for specific types of sparse matrices
(Camps et al., 2023).
66 CHAPTER 2. BASICS OF QUANTUM COMPUTING
Chapter 3

Quantum Kernel Methods

The fundamental goal of machine learning (ML) algorithms is to learn the

underlying feature representations embedded in the training data, allow-
ing data points to be effectively modeled using simple models like linear
classifiers. Kernel methods are a powerful approach to achieving this by
enabling non-linear patterns to be captured in a computationally efficient
manner. In kernel methods, a kernel function is defined as the inner product
between the high-dimensional feature representations of data points. These
feature representations are generated by a hidden feature map that trans-
forms the original data into a higher-dimensional space where complex pat-
terns become easier to identify and model. The kernel function, therefore,
serves as a measure of similarity between data points in this transformed
space.
The effectiveness of kernel methods heavily depends on the hidden fea-
ture map’s ability to capture relevant patterns in the data. The more effec-
tively this feature map can reveal the underlying structure, the better the
kernel method’s performance in learning and generalizing from the data.
However, classical kernel methods are inherently limited by the types of
patterns they can recognize, as these are constrained by classical computa-
tional frameworks. Essentially, classical models excel at detecting patterns
they are specifically designed to recognize but may struggle with patterns
that deviate from this framework.
In contrast, quantum mechanics is known for generating complex, non-
intuitive patterns that are often beyond the reach of classical algorithms.
Quantum systems can produce statistical correlations that are computa-
tionally challenging—or even impossible—for classical computers to repli-
cate. This suggests that employing quantum circuits as hidden feature maps

67
68 CHAPTER 3. QUANTUM KERNEL METHODS

could enable the detection of patterns that are difficult or impractical for
classical models to capture. By leveraging quantum circuits, we can poten-
tially access new regions of the feature space, leading to improved pattern
recognition capabilities and, consequently, better learning performance.
These insights motivate the development of quantum kernel meth-
ods, where both the hidden feature map and the kernel function are im-
plemented on a quantum computer. By harnessing the unique properties
of quantum mechanics, such as superposition and entanglement, quantum
kernel methods have the potential to surpass their classical counterparts in
specific machine learning tasks, particularly those involving highly complex
or subtle patterns. This could result in more powerful models with enhanced
generalization capabilities.
In this chapter, we provide a step-by-step explanation of the transition
from classical kernel machines to quantum kernel machines in Chapter 3.1
and Chapter 3.2. Moreover, we discuss the theoretical foundation of quan-
tum kernel machines in Chapter 3.3 from the aspects of expressivity and
generalization of quantum kernel machines. Finally, we demonstrate simple
yet illustrative code implementations on MNIST dataset.

3.1 Classical Kernel Machines

3.1.1 Motivation of kernel methods

(a) (b) (c)

Figure 3.1: Various distributions of data points. The left and middle
panels show the cases where data points can and cannot be separated by a
straight line. The right panel shows that the kernel function could map the
linearly inseparable data points into the high dimensional linearly separable
data points.

Before delving into kernel machines, it is essential to first understand the

motivation behind kernel methods. In many machine learning tasks, par-
ticularly in classification, the goal is to find a decision boundary that best
3.1. CLASSICAL KERNEL MACHINES 69

separates different classes of data. When the data is linearly separable, this
boundary can be represented as a straight line (in 2D), a plane (in 3D), or
a hyperplane (in higher dimensions), as illustrated in Figure 3.1(a). Math-
ematically, given an input space X ⊂ Rd with d ≥ 1 and a target or output
space Y = {+1, −1}, we consider a training dataset D = {(x(i) , y (i) )}ni=1 ∈
(X × Y)n where each data point x(i) ∈ X is associated with a label y (i) ∈ Y.
For the dataset to be linearly separable, there must exist a vector w ∈ Rd
and a bias term b ∈ R such that

∀i ∈ [n], y (i) (w⊤ x(i) + b) ≥ 0, (3.1)

where w⊤ x(i) represents the inner product of vectors w and x(i) . This
means that a hyperplane defined by (w, b) can perfectly separate the two
classes.
However, in real-world scenarios, data is often not linearly separable, as
shown in Figure 3.1(b). The decision boundary required to separate classes
may be curved or highly complex. Traditional linear models struggle with
such non-linear data because they are inherently limited to creating only
linear decision boundaries. This limitation highlights the need for more
flexible approaches.
To address the challenge of non-linear data, one effective strategy is to
transform the input data into a higher-dimensional space where the data
may become linearly separable. This transformation is known as feature
mapping, denoted by
ϕ : x → ϕ(x) ∈ RD , (3.2)
where the original input space X is mapped to a higher-dimensional feature
space RD with D ≥ d. The idea is that, in this higher-dimensional space,
complex patterns in the original data can be more easily identified using
linear models.
However, explicitly computing the feature map ϕ(x) in Eqn. (3.2) can be
computationally expensive, especially if the feature space is high-dimensional
or even infinite-dimensional. Fortunately, many machine learning algorithms
for tasks like classification or regression depend primarily on the inner prod-
uct between data points, which will be explained in Chapter 3.1.2. In the
feature space, this inner product is given by ⟨ϕ(x(i) ), ϕ(x(j) )⟩.

Remark

Throughout the whole tutorial, we interchangeably use a⊤ b, a · b,

⟨a, b⟩, and ⟨a|b⟩ to denote the inner production of two vectors a and
70 CHAPTER 3. QUANTUM KERNEL METHODS

b.

To circumvent the computational cost of explicitly calculating the feature

map, we can use a kernel function. A kernel function k(x(i) , x(j) ) is defined
as
k(x(i) , x(j) ) = ⟨ϕ(x(i) ), ϕ(x(j) )⟩ . (3.3)
This allows us to compute the inner product in the higher-dimensional fea-
ture space indirectly, without ever having to compute ϕ(x) explicitly. This
approach is commonly known as the kernel trick.
By using the kernel function directly within algorithms, we avoid the
computational overhead of working in a high-dimensional space. The collec-
tion of kernel values for a dataset forms the kernel matrix (or Gram matrix),
where each entry is given by k(x(i) , x(j) ). This matrix is central to many
kernel-based algorithms, as it captures the pairwise similarities between all
training data points.
To illustrate the kernel trick, let’s consider a simple example in a d-
dimensional input space, where x = (x1 , · · · , xd )⊤ . Suppose we use the
polynomial kernel of degree 2, defined as

k(x, z) =(x⊤ z)2

=(x1 z1 + · · · + xd zd )2
d X
X d
= xi zi xj zj
i=1 j=1
√ √
=[x21 , · · · , x2d , 2x1 x2 , · · · , 2xd xd−1 ]
√ √
[z12 , · · · , zd2 , 2z1 z2 , · · · , 2zd zd−1 ]⊤
=ϕ(x)⊤ ϕ(z). (3.4)

Here, we see that the feature mapping, which comprises all second-order
terms, takes the form as
√ √
ϕ(x) = [x21 , · · · , x2d , 2x1 x2 , · · · , 2xd xd−1 ]⊤ . (3.5)

Notably, directly computing the kernel function (x⊤ z)2 for a large d is much
more efficient than explicitly calculating the feature map ϕ(x) and then
taking the inner product ϕ(x)⊤ ϕ(z). Specifically, using the kernel function
only requires O(d) time, since it involves computing the dot product in the
original input space Rd . In contrast, if we were to explicitly compute the
3.1. CLASSICAL KERNEL MACHINES 71

transformed feature vectors ϕ(x) and their inner product, the time com-
plexity could increase to O(D), where D is the dimensionality of the feature
space after mapping. For this example of a polynomial kernel with degree
2, D can grow to O(d2 ). This demonstrates the computational efficiency of
using the kernel trick.

Remark
Throughout this manuscript, we use the notations O and Ω to repre-
sent the asymptotic upper and lower bounds, respectively, on the
growth rate of a term, ignoring constant factors and lower-order
terms.

3.1.2 Dual representation

To understand why many machine learning algorithms rely primarily on the
inner products between data points, we need to introduce the concept of
the dual representation. In essence, many linear parametric models used
for regression or classification can be re-cast into an equivalent dual form,
where the kernel function evaluated on the training data emerges naturally.
Let’s start with a linear regression model with the training dataset
{(x , y (i) )}ni=1 , where the parameters are determined by minimizing a reg-
(i)

ularized sum-of-squares error function

1 X ⊤ 2 λ
n
L(w) = w ϕ(x(i) ) − y (i) + w⊤ w, (3.6)
2 2
i=1

where w⊤ refers to the transpose of model parameters w, ϕ(x(i) ) represents

the feature mapping of the input x(i) , and λ ≥ 0 is the regularization factor
that helps prevent overfitting.
To find the optimal w, we set the gradient of L(w) with respect to w to
zero, i.e.,

∂L(w) X ⊤ 
n
= w ϕ(x(i) ) − y (i) ϕ(x(i) ) + λw = 0, (3.7)
∂w
i=1

From this, we see that the solution for w can be expressed as a linear
combination of the training data’s feature vectors
n n
1X ⊤ X
w=− (w ϕ(x(i) ) − y (i) )ϕ(x(i) ) = a(i) ϕ(x(i) ) := Φ⊤ a, (3.8)
λ
i=1 i=1
72 CHAPTER 3. QUANTUM KERNEL METHODS

where Φ = [ϕ(x(1) ), · · · , ϕ(x(n) )]⊤ is the design matrix, whose i-th row is
given by ϕ(x(i) )⊤ . Here, the coefficients a(i) are functions of w, defined as
1
a(i) = − (w⊤ ϕ(x(i) ) − y (i) ). (3.9)
λ
Thus, instead of directly optimizing w, we can reformulate the problem in
terms of the parameter vector a, giving rise to a dual representation. By sub-
stituting w = Φ⊤ a into the original objective function L(w) in Eqn. (3.6),
we obtain
1 1 λ
L(a) = a⊤ ΦΦ⊤ ΦΦ⊤ a − a⊤ ΦΦ⊤ y + y ⊤ y + a⊤ ΦΦ⊤ y, (3.10)
2 2 2
where y = (y (1) , · · · , y (n) )⊤ denotes the vector representation of n training
labels. We define the kernel matrix K = ΦΦ⊤ , where each element is given
by
Kij = ϕ(x(i) )⊤ ϕ(x(j) ) = k(x(i) , x(j) ), (3.11)
using kernel function k(x, x′ ) defined by Eqn. (3.3). The objective function
in terms of a simplifies to
1 1 λ
L(a) = a⊤ K 2 a − a⊤ Ky + y ⊤ y + a⊤ Ky, (3.12)
2 2 2
Setting the gradient of L(a) with respect to a to zero give us

a = (K + λIn )−1 y, (3.13)

where In is the identity matrix of size n × n.

Now, using this dual formulation, we can derive the prediction for a new
input x. Substituting w = Φ⊤ a in Eqn. (3.8), the prediction of x is given
by
y(x) = w⊤ ϕ(x) = ⟨Φ⊤ a, ϕ(x)⟩ = k(x)⊤ (K + λIn )−1 y, (3.14)
where k(x) ∈ Rn is a vector with elements ki (x) = k(x(i) , x) = ϕ(x(i) )⊤ ϕ(x).
This shows that the dual formulation allows us to express the solution en-
tirely in terms of the kernel function k(x, x′ ), rather than explicitly working
with the feature map ϕ(x). This is particularly advantageous because it
enables us to work in high-dimensional or even infinite-dimensional feature
spaces implicitly.
In the dual formulation, we determine the parameter vector a by invert-
ing an n × n matrix, compared to the original parameter space formulation
which requires inverting a d × d matrix to determine w. Although this may
3.1. CLASSICAL KERNEL MACHINES 73

not seem advantageous when n > d, the true benefit of the dual formulation
lies in its ability to leverage the kernel trick. By expressing the solution
in terms of the kernel function, we avoid the explicit computation of the
feature vectors ϕ(x). This allows us to implicitly utilize feature spaces of
very high, or even infinite, dimensionality, enabling the model to capture
complex, non-linear relationships in the data without the associated com-
putational cost.

Remark
We standardize the notation used throughout this chapter to help
readers follow the content more easily. The kernel function is rep-
resented by the lowercase letter k, or with subscripts kQ and kC .
The kernel matrix is denoted by the capital letter K, or with sub-
scripts KQ and KC . Additionally, we use the bold lowercase letter
k(x) to represent the vector of kernel values, where each element
is given by kj (x) = k(x(j) , x), corresponding to the training points
x(j) ∈ {x(1) , . . . , x(n) }.

3.1.3 Kernel construction

To utilize the kernel trick in machine learning algorithms, it is essential
to construct valid kernel functions. One approach is to start with a fea-
ture mapping ϕ(x) and then derive the corresponding kernel. For a one-
dimensional input space, the kernel function is defined as
D
X
k(x, x′ ) = ϕ(x)⊤ ϕ(x′ ) = ⟨ϕi (x), ϕi (x′ )⟩, (3.15)
i=1

where ϕi (x) are the basis functions of the feature map.

Alternatively, kernels can be constructed directly without explicitly defin-
ing a feature map. In this case, we must ensure that the chosen function is
a valid kernel, meaning it corresponds to an inner product in some (possi-
bly infinite-dimensional) feature space. The validity of a kernel function is
guaranteed by Mercer’s condition.
Fact 3.1 (Mercer’s condition). Let X ⊂ Rd be a compact set and let k :
X × X → R be a continuous and symmetric function. Then, k admits a
uniformly convergent expansion of the form
∞
X
k(x, x′ ) = ai ⟨ϕi (x), ϕi (x′ )⟩ (3.16)
i=0
74 CHAPTER 3. QUANTUM KERNEL METHODS

with ai > 0 if and only if for any square-integrable function c, the following
condition holds: Z Z
c(x)c(x′ )k(x, x′ )dxdx′ ≥ 0. (3.17)
X X

Mercer’s condition is crucial because it ensures that the optimization

problem for algorithms like support vector machines (SVM) remains convex
(Mohri, 2018), guaranteeing convergence to a global minimum. A condition
equivalent to Mercer’s condition (under the assumptions of the theorem) is
that the kernel k(·, ·) be positive definite symmetric. This property is more
general since it does not require any assumption about X .

Definition 3.2 (Positive definite symmetric kernels). A kernel k : X ×X →

R is said to be positive definite symmetric (PDS) if for any {x(1) , · · · , x(n) } ⊂
X , the matrix K = [k(x(i) , x(j) )]ij ∈ Rn×n is symmetric positive semidefinite
(SPSD).

In other words, a kernel matrix K associated with a PDS kernel function

will always be SPSD, ensuring that the corresponding optimization problem
remains well-behaved.
Below, we present several commonly used positive definite symmetric
kernels.

Example 3.3 (Polynomial kernels). A polynomial kernel of degree m ∈

N with a constant c > 0 is defined as

k(x, x′ ) = (x · x′ + c)m , ∀x, x′ ∈ Rd . (3.18)

This kernel maps

the input space to a higher-dimensional space of di-
d+m
mension m . For instance, in a two-dimensional input space (d = 2)
and with m = 2, the kernel expands as follows
   ′

x21 x12
 2   ′
x22 
 √ x2  
 √ 

 2 x x  2 x ′ x′
k(x, x′ ) = (x1 x′1 + x2 x′2 + c)2 =  √ 1 2 ·  √ 1 2  (3.19)

  2c x′1 
 √2c x1    √ 
 2c x2   2c x′2 
c c

In other words, this kernel corresponds to an inner product in a higher-

dimensional space of dimension 6.
3.1. CLASSICAL KERNEL MACHINES 75

Thus, the features corresponding to a second-degree polynomial are the

original features (x1 and x2 ), as well as products of these features, and the
constant feature. More generally, the features associated with a polynomial
kernel of degree m are all the monomials of degree at most m based on the
original features.

Example 3.4 (Gaussian kernels). The Gaussian kernel (or Radial Ba-
sis Function, RBF) is one of the most widely used kernels, defined as
 
′ ′ ∥x − x′ ∥
∀x, x ∈ R , k(x, x ) = exp −
d
, (3.20)
2σ 2

where σ > 0 controls the width of the Gaussian function.

Gaussian kernels are particularly effective in capturing complex non-

linear patterns due to their infinite-dimensional feature space.

Example 3.5 (Sigmoid kernels). The sigmoid kernel over Rd is defined

as:
k(x, x′ ) = tanh(a · (x · x′ ) + b), ∀x, x′ ∈ Rd , (3.21)
c −c
where a, b > 0 are constants, and tanh(c) = eec −e
+e−c
is the hyperbolic
tangent function, which squashes an arbitrary constant c ∈ R to a value
between −1 and 1.

This kernel is related to neural networks, as it resembles the activation

function commonly used in multi-layer perceptrons as will be introduced in
the next chapter. Using the sigmoid kernel with support vector machines
results in a model similar to a simple neural network.

Remark
Support Vector Machines (SVMs) are a well-known algorithm that
heavily relies on kernel methods and are primarily used for classi-
fication tasks. The objective of an SVM is to identify the optimal
hyperplane that separates data points from different classes with the
maximum margin. The margin is defined as the distance between
the hyperplane and the closest data points from each class, known as
support vectors. SVMs can be applied to both linear and non-linear
76 CHAPTER 3. QUANTUM KERNEL METHODS

classification problems. For non-linear cases, kernel functions are em-

ployed to map the data into higher-dimensional spaces, enabling the
separation of data that is not linearly separable in the original space.
For a detailed introduction to SVMs, please refer to Mohri (2018).

3.2 Quantum Kernel Machines

3.2.1 Motivations for quantum kernel machines
To effectively introduce quantum kernel machines, it is essential to recog-
nize the limitations of classical kernel machines. As discussed in Chapter 3.1,
classical kernel machines rely on manually tailored feature mappings, such
as polynomials or radial basis functions. However, these mappings may
fail to capture the complex patterns behind the dataset. Quantum kernel
machines emerge as a promising alternative, as they perform feature map-
ping using quantum circuits, enabling them to explore exponentially larger
feature spaces that are otherwise infeasible for classical computation.

⋯
⋯

Data space 𝒳 𝜙(𝑥 (𝑗) )

𝜙(𝑥 (𝑖) )

𝑥 (𝑖) Classical feature space ℳ Classical kernel

𝑥 (𝑗) |0⟩
|0⟩
⋯ 𝑈(𝑥 (𝑖) ) 𝑈 † (𝑥 (𝑗) )
|𝜓(𝑥 (𝑖) )⟩ |0⟩

|0⟩
|0⟩ 𝑈(𝑥) ⋯ |𝜓(𝑥 (𝑗) )⟩

|0⟩
Quantum feature space ℋ Quantum kernel

Figure 3.2: The paradigm of classical and quantum kernels. Both of

the classical and quantum kernels embed the data points from data space
X into high-dimensional space, and then compute the kernel as the inner
product of feature maps. The quantum kernel leverages quantum circuits
to achieve this goal, as indicated by the blue color.
3.2. QUANTUM KERNEL MACHINES 77

Another crucial characteristic of quantum kernels is that they can be ef-

fectively implemented on near-term quantum devices, making them a prac-
tical tool for exploring the utility of near-term quantum technologies.

3.2.2 Quantum feature maps and quantum kernel machines

The key difference between quantum kernel machines and classical kernel
machines lies in how the feature mapping is performed. In the quantum
context, a feature map refers to the injective encoding of classical data
x ∈ Rd into a quantum state |ϕ(x)⟩ = U (x) |ϕ⟩ on an N -qubit quantum
register, where U (x) refers to the physical operation or quantum circuit
that depends on the data x. This feature map is implemented on a quantum
computer and produces quantum states, which are referred to as quantum
feature maps.
Definition 3.6 (Quantum feature map). Given an N -qubit quantum system
initialized in state |ψ⟩, let x ∈ X ⊂ Rd be classical data. The quantum
feature map is defined as the mapping

ϕ : X → F,
ϕ(x) = |ϕ(x)⟩ ⟨ϕ(x)| = ρ(x), (3.22)

where F is the space of complex-valued 2N × 2N matrices equipped with the

Hilbert-Schmidt inner product ⟨ρ, σ⟩ = Tr(ρσ) for ρ, σ ∈ F. In addition,
the state |ϕ(x)⟩ can be implemented by applying a data-encoding quantum
circuit U (x) introduced in Chapter 2.3.1 on an initial state |ψ⟩, leading to
the expression of |ϕ(x)⟩ = U (x) |ψ⟩.
Recall that one way of constructing kernels is adopting the inner product
of the defined feature mappings. Using the Hilbert-Schmidt inner product
from Definition 3.6, the quantum kernel is defined as follows.
Definition 3.7 (Quantum Kernel). Let ϕ be a quantum feature map over
the domain X . The quantum kernel kQ is the inner product between two
quantum feature maps ρ(x) and ρ(x′ ) for data points x, x′ ∈ X ,

kQ : X × X → R,
2
kQ (x, x′ ) = Tr(ρ(x)ρ(x′ )) = ⟨ϕ(x)|ϕ(x′ )⟩ . (3.23)

To justify the term ‘kernel’, we need to show that the quantum kernel is
indeed a positive definite function. A quantum kernel can be expressed as
the product of a complex-valued kernel k̂Q (x, x′ ) = ⟨ϕ(x)|ϕ(x′ )⟩ ∈ C and
78 CHAPTER 3. QUANTUM KERNEL METHODS

its complex conjugate k̂Q (x, x′ )∗ = ⟨ϕ(x)|ϕ(x′ )⟩∗ = ⟨ϕ(x′ )|ϕ(x)⟩. Since the
product of two kernels is known to be a valid kernel, it suffices to show that
k̂Q (x, x′ ) is a valid complex-valued kernel and satisfies positive definiteness.
For any x(i) ∈ X , i = 1, · · · , n, and any coefficients ci ∈ C, we have
X   X
ci c∗j k̂Q (x(i) , x(j) ) = ci c∗j ⟨ϕ(x(i) )|ϕ(x(j) )⟩
i,j i,j
! 
X X
= ci ⟨ϕ(x(i) )|  c∗j |ϕ(x(j) )⟩
i j
2
X
= c∗i |ϕ(x(i) )⟩ ≥ 0. (3.24)
i

This inequality confirms that k̂Q (x, x′ ) satisfies Mercer’s condition to be a

valid kernel as illustrated in Eqn. (3.17). Therefore, the quantum kernel
kQ (x, x′ ) is also a valid kernel.

(a) (b)
|0⟩ H H

|0⟩ U (x) U (x′ )†

|0⟩ U (x)
swap
|0⟩ U (x′ )

Figure 3.3: Two methods for computing the inner product of the
kernel. (a) Loschmidt echo test. (b) Swap test.

The inner product between quantum states can be efficiently estimated

on quantum computers using techniques such as Loschmidt echo test (Kusumoto
et al., 2021) and SWAP test (Blank et al., 2020). Both methods correspond
to distinct quantum circuit architectures, as illustrated in Figure 3.3.
One key merit of quantum kernels is that their derivation does not re-
quire the explicit representation of the quantum feature maps. Instead, it
relies only on the construction of the associated quantum circuits. This
aligns with the essence of kernel methods: while feature mappings can be
computationally complex, the kernel function itself must remain efficient to
evaluate.
Below, we outline the core steps for constructing a quantum kernel.
3.2. QUANTUM KERNEL MACHINES 79

General construction rules of quantum kernels

There are three steps to construct a quantum kernel:

1. Quantum feature map construction. Design a data-dependent

quantum circuit U (x) to encode classical input data x into the
amplitudes or parameters of a quantum state |ϕ(x)⟩ = U (x) |ψ⟩
where the initial state |ψ⟩ is typically |0⟩⊗N .

2. Kernel evaluation. The quantum kernel is typically defined as

the inner product of quantum states corresponding to two data
points. Mathematically, this can be expressed as kQ (x, x′ ) =
|⟨ϕ(x)|ϕ(x′ )⟩|2 .

3. Post-processing. After executing the quantum circuit for dif-

ferent input pairs, measure the output and calculate the kernel
matrix. This matrix will then be used in machine learning mod-
els, such as SVM.

Below is a simple example of a quantum kernel with an angle encoding

feature map introduced in Chapter 2.3.1.

Example 3.8 (Single-qubit kernel). Consider an embedding that en-

codes a scalar input x ∈ R into the quantum state of a single qubit.
The embedding is implemented by the Pauli-X rotation gate RX(x) =
e−ixσx /2 , where σx is the Pauli-X operator. The quantum feature map
is then given by ϕ : x → ρ(x) = |ϕ(x)⟩ ⟨ψ(x)| with

|ϕ(x)⟩ =e−ixσx /2 |0⟩

=(cos(x)I − i sin(x)σx ) |0⟩
= cos(x) |0⟩ − i sin(x) |1⟩ , (3.25)

and hence the quantum kernel yields

x   x  ′ 2  
′ x′ x x − x′ 2
k(x, x ) = cos cos + sin sin = cos ,
2 2 2 2 2

which is a translation invariant squared cosine kernel.

80 CHAPTER 3. QUANTUM KERNEL METHODS

3.2.3 Relation between quantum and classical kernel ma-

chines
An intuitive way to understand the connections and differences between
classical and quantum kernel machines is by comparing their fundamental
components. As illustrated in Figure 3.2, both types of kernel machines in-
volve four fundamental components: input, feature mapping, kernel matrix,
and the computation process. Table 3.1 summarizes how these components
are implemented in classical and quantum kernel machines.

Table 3.1: Comparison between classical and quantum kernel machines.

Classical Kernel Quantum Kernel
Input {x(i) }n
classical data i=1 ∈R
d
i=1 ∈ R
classical data {x(i) }n d
N
Feature Real vector ϕ(x) ∈ R D
Complex vector |ϕ(x)⟩ ∈ C2
Kernel n-dimensional real matrix KC n-dimensional real matrix KQ
Computation Digital logical circuits ϕ(x) Quantum circuits U (x) |ψ⟩

The main distinctions between classical and quantum kernel machines

lie in the computation processes for feature mapping and kernel matrix con-
struction, as outlined below.

• Classical versus quantum feature maps. Quantum feature maps encode

data into quantum states, resulting in exponentially large complex-
N
valued vectors |ϕ(x)⟩ ∈ C2 , whereas classical feature maps operate in
finite-dimensional real-valued spaces ϕ(x) ∈ RD . Although quantum
feature maps can theoretically be simulated on classical computers by
separating real and imaginary parts, this simulation becomes compu-
tationally infeasible as the number of qubits grows. Even feature maps
generated by shallow quantum circuits are hard to simulate efficiently
on classical hardware, demonstrating the inherent computational com-
plexity of quantum feature maps.

• Classical versus quantum kernels. The kernel function is determined

by the feature mapping, but its computational properties differ sig-
nificantly between classical and quantum methods. A key merit of
kernel methods is that they allow the use of complex feature maps
while maintaining efficient kernel evaluations. Quantum kernels lever-
age quantum circuits to compute the inner product of quantum states,
enabling the recognition of intricate patterns that classical kernels fail
to capture. If a quantum kernel is computationally hard to evalu-
3.2. QUANTUM KERNEL MACHINES 81

ate classically, it offers a significant advantage by exploiting quantum

computing’s ability to process complex data representations efficiently.

Remark
The efficiency discussed here refers to the computational time within
the respective classical or quantum frameworks. Specifically,

• Classical Efficiency: Determined by the depth of digital logical

circuits used for feature mapping and kernel computation.

• Quantum Efficiency: Determined by the depth of quantum cir-

cuits required to achieve the same tasks.

A computation process is considered efficient if it can be completed

in polynomial time relative to the problem size in its corresponding
framework (classical or quantum).

3.2.4 Concrete examples of quantum kernels

To better understand the concept of a quantum kernel, let’s examine the ker-
nels associated with common information encoding strategies used in quan-
tum machine learning. It is important to note that some kernels cannot be
efficiently computed on classical computers (Liu et al., 2021b). While such
results are significant, the question of which quantum kernels are practically
useful for real-world problems remains an open challenge.
In the following examples, we will first review the various encoding
strategies introduced in Chapter 2.3.1, and then present the corresponding
quantum kernels.

Example 3.9 (Quantum kernel with basis encoding). Given a classical

binary vector x = (x1 , · · · , xd ) ∈ {0, 1}d , the quantum feature mapping
related to basis encoding refers to

|ϕ(x)⟩ = |x1 , · · · , xd ⟩ , (3.26)

and the induced quantum kernel yields

k(x, x′ ) = | ⟨ϕ(x)|ϕ(x′ )⟩ |2 = δxx′ , (3.27)

where δxx′ = 1 if x = x′ and otherwise 0.

82 CHAPTER 3. QUANTUM KERNEL METHODS

The basis encoding requires N = d qubits. This kernel function is a very

strict similarity measure on input space, and arguably not the best choice
of data encoding for quantum machine learning tasks.

Example 3.10 (Quantum kernel with amplitude encoding). Given a

vector x = (x1 , · · · , xd ) ∈ Rd , the quantum feature mapping related to
amplitude encoding refers to
d
X xi
|ϕ(x)⟩ = |i⟩ , (3.28)
∥x∥2
i=1

where ∥x∥2 is the Euclidean norm. The related quantum kernel is given
by
k(x, x′ ) = | ⟨x|x′ ⟩ |2 = |⟨x, x′ ⟩|2 . (3.29)

The amplitude encoding requires N = ⌈log 2(d)⌉ qubits. This encoding

strategy leads to an identity feature map, which can be implemented by a
non-trivial quantum circuit (for obvious reasons also known as “arbitrary
state preparation”), which takes time O(d) in the worst case. Besides, this
quantum kernel does not add much power to a linear model in the original
feature space, and it is more of interest for theoretical investigations that
want to eliminate the effect of the feature map.

Example 3.11 (Quantum kernel with angle encoding). Given a vector

x = (x1 , · · · , xd ) ∈ Rd , the quantum feature mapping related to angle
encoding refers to

|ϕ(x)⟩ = Wd e−ixd Gd Wd · · · W2 e−ix1 G1 W1 |0⟩⊗d , (3.30)

where W0 , · · · , Wd are arbitrary unitary evolutions, and Gi is di ≤ d-

dimensional Hermitian operator called the generating Hamiltonian.
For a special case in which Wi = I and Gi refers to the Pauli-
X operators σx acting on the i-th qubit, the quantum feature mapping
refers to
Od  x 
i
|ϕ(x)⟩ = exp −i σx |0⟩⊗d , (3.31)
2
i=1
3.2. QUANTUM KERNEL MACHINES 83

and the related quantum kernel is given by

d
Y 2
k(x, x′ ) = sin(xi ) sin(x′i ) + cos(x(i) ) cos(x′i )
i=1
Yd
2
= cos(xi − x′i ) . (3.32)
i=1

The angle encoding requires d-qubit, mapping the classical data to 2d -

dimensional Hilbert space. One merit of angle encoding is introducing non-
linearity, which is crucial for transforming low-dimensional, non-linearly sep-
arable data into higher-dimensional, linearly separable representations—a
property essential for effective kernel-based machine learning. Additionally,
angle encoding is well-suited for implementation on modern devices featur-
ing limited qubits and circuit depth, making it practical for exploring the
practical utility of near-term quantum computers.
The quantum kernels related to different data encoding strategies have a
resemblance to kernels from the classical machine learning literature. This
means that sometimes up to an absolute square value, they can be identified
with standard kernels such as the polynomial or Gaussian kernel. For the
special case of angle encoding, the resemblance to classical kernels is because
the employed quantum circuit does not employ any entangled quantum gates
such that it can be simulated classically. We now discuss the general form of
the quantum kernels induced by quantum feature maps from angle encoding
in Eqn. (3.30). We focus on the simplified case that each input x(i) is only
encoded once and that all the encoding Hamiltonians are the same, i.e.,
G1 = · · · = Gd = G.
Theorem 3.12 (Fourier representation of the quantum kernel). Let X = Rd
and U (x) be a quantum circuit that encodes the data inputs x = (x1 , · · · , xd ) ∈
X into a d-qubit quantum state |ϕ(x)⟩ via gates of the form e−ixi G for
i = 1, · · · , d. Without loss of generality, G is assumed to be a m ≤ 2d -
dimensional diagonal operator with spectrum λ1 , · · · , λm . Between such
data-encoding gates, and before and after the entire encoding circuit, ar-
bitrary unitary evolutions W1 , · · · , Wd+1 can be applied, so that
U (x) = Wd+1 e−ixd Gd Wd · · · W2 e−ix1 G1 W1 . (3.33)
The quantum kernel kQ (x, x′ ) can be written as
X ′
kQ (x, x′ ) = eisx eitx cst , (3.34)
s,t∈Ω
84 CHAPTER 3. QUANTUM KERNEL METHODS

where Ω ⊂ Rd , and cst ∈ C. For every s, t ∈ Ω, we have −s, −t ∈ Ω and

cst = c∗−s−t , which guarantees that the quantum kernel is real-valued.

Proof sketch of Theorem 3.12. The assumption that the generator G is di-
agonal could be made without loss of generality because one can diagonalize
Hermitian operators as G = V e−ixi Σ V † with
 
e−ixi λ1 0 ··· 0
 0 e−ixi λ2 ··· 0 
e−ixi Σ =
 ···
,
 (3.35)
···
0 ··· 0 e−ixi λm

where V † refers to the conjugate transpose of the matrix V , λ1 , · · · , λm are

the eigenvalues of G. Formally, V, V † can be absorbed into the arbitrary
circuits Wi+1 and Wi before and after the encoding gate. In this regard,
the quantum kernel can be written down as the inner product between the
feature state of the specific forms in Eqn. (3.30), i.e.,

k(x, x′ )
= ⟨ϕ(x′ )|ϕ(x)⟩
′ ′ 2
†
= ⟨0| W1† (e−ix1 Σ )† · · · (e−ixd Σ )† Wd+1 Wd+1 e−ixd Σ · · · e−ix1 Σ W1 |0⟩
′ ′ 2
= ⟨0| W1† (e−ix1 Σ )† · · · (e−ixd Σ )† e−ixd Σ · · · e−ix1 Σ W1 |0⟩
m
X m
X ′ ′
= e−i(λj1 x1 −λk1 x1 +···+λjd xd −λkd xd )
j1 ,··· ,jd =1 k1 ,··· ,kd =1
  2
(1k ) (k k ) ∗ (j j ) (j 1)
× W1 1 · · · Wd d−1 d Wd d d−1 · · · W1 1

2
XX
x′ )
= e−i(Λj x−Λk (ωk )∗ ωj
j k
XXXX ′
= e−i(Λj −Λl )x ei(Λk −Λh )x (ωk ωh )∗ ωj ωl , (3.36)
j k h l

(ab)
Here, the scalars Wi refer to the element ⟨a| Wi |b⟩ of the unitary operator
Wi , the bold multi-index j summarizes the set (j1 , · · · , jd ) and Λj is a vector
containing the eigenvalues selected by the multi-index (and similarly for
k, h, l ).
3.2. QUANTUM KERNEL MACHINES 85

We can now summarize all terms where Λj − Λl = s and Λk − Λh = t, in

other words where the differences of eigenvalues amount to the same vectors
s, t. Then
X ′
X X
k(x, x′ ) = e−isx eitx ωj ωl (ωk ωh )∗
s,t∈Ω j,l:Λj −Λl =s k,h:Λk −Λh =t
X
itx′
= e−isx e cst . (3.37)
s,t∈Ω

The frequency set Ω contains all vectors {Λj − Λl } with Λj = (λj1 , · · · , λjd )
and λj1 , · · · , λjd ∈ [1, · · · , m].
We summarize the various strategies for the construction of quantum
feature mappings and quantum kernels in Table 3.2.

Table 3.2: Overview of typical data encoding strategies and their quantum
kernels. The input domain is assumed to be the x = (x1 , · · · , xd ) ∈ X ⊂ Rd .
Encoding Qubits Dimension Quantum Kernel k(x, x′ )
Basis encoding d 2d δx,x′
Amplitude encoding ⌈log2 (d)⌉ d |x† x′ |2
Qd
Angel encoding d 2d | cos(xk − x′k )|2
Pk=1 −isx itx′
General angle encoding d 2d s,t∈Ω e e cst

Remark
After obtaining the quantum kernel matrix KQ for a given training
dataset {(x(i) , y (i) )}ni=1 , we can use it to perform regression or classi-
fication tasks in a manner similar to the classical kernel methods. In
particular, as discussed in Chapter 3.1.2, consider the linear regression
model given by
1 X ⊤ 2 λ
n
L(w) = w · ϕQ (x(i) ) − y (i) + w⊤ · w, (3.38)
2 2
i=1

where ϕQ (x(i) ) denotes the quantum feature mapping related to the

quantum kernel kQ , w denotes the model parameters, and λ ≥ 0 is the
regularization factor. Using the quantum kernel matrix, we can ex-
press the dual representation of the linear model given in Eqn. (3.14)
to predict the output for a new input as
y(x) = kQ (x)⊤ · (KQ + λIn )−1 y, (3.39)
86 CHAPTER 3. QUANTUM KERNEL METHODS

𝜽(𝟎) ℋ
ℋ𝑄
Target function

𝜽∗ ⋯
𝜽∗
𝜽(𝑻) Optimization path

Figure 3.4: The expressivity and generalization ability of quantum

kernels. Expressivity concerns the size of the hypothesis space HQ repre-
sented by quantum kernels, where H refers to the whole hypothesis space.
Generalization ability considers the learned hypothesis that could predict
the unseen data accurately features a small distance with the target con-
cept.

where y = (y (1) , · · · , y (n) ) refers to the label vector, kQ (x) is a vector

(i)
with elements kQ (x) = kQ (x(i) , x).

3.3 Theoretical Foundations of Quantum Kernel

Machines
In this section, we take a step further to explore the theoretical foundations
of quantum kernels. Specifically, we focus on two crucial aspects: the expres-
sivity and generalization properties of quantum kernel machines. As shown
in Figure 3.4, these two aspects are essential for understanding the potential
advantages of quantum kernels over classical learning approaches and their
inherent limitations. For ease of understanding, this section emphasizes the
fundamental concepts necessary for evaluating the power and limitation of
quantum kernels instead of exhaustively reviewing all theoretical results.
The outline of this chapter is as follows. In Chapter 3.3.1, we will discuss
the expressivity of quantum kernels, which refers to the diversity of feature
spaces that quantum kernels can represent. The achieved insights will help
identify tasks that are particularly well-suited for quantum kernels. Then, in
Chapter 3.3.2, we will examine the potential advantage of quantum kernels
3.3. THEORETICAL FOUNDATIONS OF QUANTUM KERNEL MACHINES87

in terms of generalization error compared to all classical kernel machines.

This analysis highlights their ability to accurately predict labels or values
for unseen data.

3.3.1 Expressivity of quantum kernel machines

Quantum kernels, as discussed in Chapter 3.2, are constructed by explic-
itly defining quantum feature mappings. In this context, the expressivity of
quantum kernel machines refers to the types of functions that quantum fea-
ture mappings can approximate and the kinds of correlations that quantum
kernels can effectively model.
Following the conventions of Gil-Fuster et al. (2024), we demonstrate
that any kernel function can be approximated using finitely deep quantum
circuits by showing that the associated feature mapping can also be approx-
imated using quantum circuits. This conclusion rests on two key theoretical
foundations: Mercer’s feature space construction and the universality of
quantum circuits. Together, these principles establish the theoretical feasi-
bility of realizing any kernel function as a quantum kernel.
It is important to note that if exact mathematical equality were re-
quired, Mercer’s construction would demand an infinite-dimensional Hilbert
space, which in turn would require quantum computers with infinitely many
qubits—an impractical scenario. However, in practical applications, we are
more interested in approximating functions to a certain level of precision
rather than achieving exact evaluations. This perspective makes it feasible
to implement the corresponding quantum feature mappings using a finite
number of qubits. The following theorem confirms that any kernel func-
tion can be approximated as a quantum kernel to arbitrary precision with
finite computational resources (We defer the proof details at the end of this
subsection).
Theorem 3.13 (Approximate universality of finite-dimensional quantum
feature maps). Let k : X × X → R be a kernel function. Then, for any
ε ≥ 0 there exists N ∈ N and a quantum feature mapping ρN onto the
Hilbert space of quantum states of N qubits such that

|k(x, x′ ) − 2N Tr(ρN (x)ρN (x)′ ) + 1| < ε (3.40)

for almost all x, x′ ∈ X .

Theorem 3.13, instead of discussing the ε-approximation of quantum ker-
nels in the form |k(x, x′ )−Tr(ρN (x)ρN (x)′ )| < ε, introduces additional mul-
tiplicative and additive factors, expressed as |k(x, x′ )−2N Tr(ρN (x)ρN (x′ ))+
88 CHAPTER 3. QUANTUM KERNEL METHODS

1| < ε. These additional factors, explained below, do not impede the uni-
versality of the theorem.
Moreover, the statement that Eqn. (3.40) holds for almost all x, x′ ∈ X
stems from measure theory. It signifies that the inequality is valid “except
on sets of measure zero,” or equivalently “with probability 1.” In other
words, while adversarial instances of x, x′ ∈ X may exist for which the
inequality does not hold, such instances are so sparse that the probability of
encountering them when sampling from the relevant probability distribution
is zero.
Last, Theorem 3.13 establishes that any kernel function can be approx-
imated as a quantum kernel up to a multiplicative and an additive factor
using a finite number of qubits.
Before presenting the proof of this theorem, let us first introduce Algo-
rithm 1, which maps classical vectors to quantum states. These quantum
states can then be used to evaluate Euclidean inner products as quantum
kernels. Then, we demonstrate Lemma 3.14 and Lemma 3.15, which sep-
arately formalize the correctness and runtime complexity of Algorithm 1,
as well as establish the relationship between the Euclidean inner product
of encoded real vectors and the Hilbert-Schmidt inner product of the corre-
sponding quantum states.

Algorithm 1 Classical to quantum embedding (C2QE)

Input: a unit vector with 1-norm rP∈ ℓd1 .
Output: Quantum state ρr ∝ I + di=1 ri Pi . ▷ See Lemma 3.14.
1: Set N = ⌈log4 (d + 1)⌉.
2: Pad r with zeros until its length is 4N − 1.
3: Draw i ∈ {1, . . . , 4N − 1} with probability |ri |.
4: Prepare ρi = 21N (I + sign(ri )Pi ).
5: return ρi .

The output of Algorithm 1, 21N (I ± P ), is a single (pure) eigenstate of

a Pauli operator P with eigenvalue ±1. However, since Line 3 involves
sampling an index i ∈ {1, · · · , 4N − 1}, Algorithm 1 is inherently random,
and the resulting quantum state is a classical mixture of pure states.

Lemma 3.14 (Correctness and runtime of Algorithm 1). Let r ∈ ℓd1 ⊂ Rd

be a unit vector with respect to the 1-norm, i.e., ∥r∥1 = 1. Take N =
4N −1
⌈log4 (d + 1)⌉ and pad r with zeros until its length is 4N − 1. Let (Pi )i=1
be the set of all Pauli matrices on N qubits, excluding the identity. Then
3.3. THEORETICAL FOUNDATIONS OF QUANTUM KERNEL MACHINES89

Algorithm 1 prepares the following state as a classical mixture

ρ(·) :ℓd1 → Herm(2N ),

PN
I + 4i=1−1 ri Pi
r 7→ ρr = . (3.41)
2N
The total runtime complexity t of Algorithm 1 fulfills t ≤ O(poly(d)).

Proof of Lemma 3.14. The proof begins by expanding the state as follows
 
P4N −1 N −1
4X N −1
4X
I + i=1 ri Pi 1
N
= N |ri |I + ri Pi , (3.42)
2 2
i=1 i=1

N
where the first equality follows that ∥r∥1 = 1 and r ∈ R4 −1 . Rewriting
the above equation using sign(ri ) yields
 
P4N −1 N −1
4X N −1
4X
I + i=1 ri Pi 1
N
= N |ri |I + |ri |sign(ri )Pi 
2 2
i=1 i=1
4N −1
1 X
= |ri |(I + sign(ri )Pi ) ⪰ 0. (3.43)
2N
i=1
P
Here, it is used that i |ri | = ∥r∥1 = 1 and I±Pi ≥ 0 for all Pauli operators
Pi . Notice that efficiently preparing I + Pi can be achieved by rotating each
qubit’s |0⟩ basis state to the corresponding Pauli basis and flipping the
necessary qubits individually. Since this state is a convex combination of
quantum states, it can be efficiently prepared by mixing, when the number
of terms is polynomial.

Lemma 3.15 (Euclidean inner products). Let r, r ′ ∈ Rd be unit vectors

with respect to the 1-norm, i.e., ∥r∥1 = ∥r ′ ∥1 = 1. For the states ρr , ρ′r
produced in Algorithm 1, the following identity holds

⟨r, r ′ ⟩ = 2N Tr(ρr ρ′r ) − 1. (3.44)

Proof of Lemma 3.15. The proof utilizes the following principles: (1) The
trace is linear, and the trace of a tensor product equals the product of traces.
(2) All Pauli words are traceless except for the identity, and each Pauli
operator is its own inverse. Hence, the product of distinct Pauli operators
is also traceless.
90 CHAPTER 3. QUANTUM KERNEL METHODS

Expanding the trace of ρr ρr′ , we have

   
4XN −1 N −1
4X
1
Tr(ρr ρr′ ) = Tr N I + rj Pj I + rk′ Pk , (3.45)
4
j=1 k=1

which could be simplified as

 
N −1
4X N −1
4X
1
Tr(ρr ρr′ ) = N TrI + rj rj′ Pj2 + rj rk′ Pj Pk . (3.46)
4
j=1 k̸=j

Using the properties of Pauli operators, the trace becomes

  
N −1
4X
1  1 + ⟨r, r ′ ⟩
Tr(ρr ρr′ ) = N Tr(I) + Tr rj rj′ I = . (3.47)
4 2N
j=1

This completes the proof.

Lemma 3.15 clarifies the origin of the extra factors in Theorem 3.13. In
particular, the 2N multiplicative factor is unproblematic, as N ≤ O(log(d))
and the methods are designed to scale polynomially with d. Moreover, the
quantum state ρr is generally mixed but can be efficiently prepared. The
mapping is injective but not surjective.
With these results in place, we now present the proof of Theorem 3.13.

Proof of Theorem 3.13. The proof follows from a corollary of Mercer’s theo-
rem and the universality of quantum computing. First, by a direct corollary
of the Mercer’s Theorem (i.e., Fact 3.1) which states that an arbitrary kernel
k admits a uniformly convergent expansion of the form in Eqn. (3.16), it is
ensured that there exists a finite-dimensional feature map Φm : X → Rm
such that
k(x, x′ ) − ⟨Φm (x), Φm (x′ )⟩ < ε. (3.48)
Without loss of generality, it is assumed that ∥Φm (x)∥ = 1 for all x ∈ X .
The quantum state ρΦm can then be prepared, which requires ⌈log4 (m + 1)⌉
qubits. By preparing two such states—one for Φm (x) and one for Φm (x′ )—
their inner product can be computed as the Hilbert-Schmidt inner product
of the quantum states, as shown in Lemma 3.15. This leads to


⟨Φm (x), Φm (x′ )⟩ = 2N Tr ρΦm (x) ρΦm (x′ ) − 1. (3.49)
3.3. THEORETICAL FOUNDATIONS OF QUANTUM KERNEL MACHINES91

For reference, it is noted that Tr ρΦm (x) ρΦm (x′ ) can be computed using
the SWAP test to an additive precision determined by the number of mea-
surement shots. This allows us to approximate the result efficiently to any
desired polynomial additive precision. Consequently, it follows that


k(x, x′ ) − 2N Tr ρΦm (x) ρΦm (x′ ) + 1 < ε, (3.50)
for almost all x, x′ ∈ X . This completes the proof.
We remark that Theorem 3.13 does not aim to demonstrate any quan-
tum advantage but rather establishes the ultimate expressivity of quantum
kernels. The theorem guarantees the existence of a quantum kernel us-
ing a finite number of qubits but does not address how quickly the num-
ber of required qubits grows with increasing computational complexity of
the kernel function k or with decreasing approximation error ε > 0. The
number of qubits N will depend on certain properties of the kernel k and
the approximation error ε. For instance, if the required number of qubits
scales exponentially with these parameters, Theorem 3.13 would have lim-
ited practical utility. Similarly, the time required to find such a quantum
kernel approximation-independent of the memory and runtime requirements
for preparing the feature vectors and computing their inner product—must
also be considered.

Remark
Although Theorem 3.13 establishes that all kernel functions can be
realized as quantum kernels, there may still exist kernel functions
that cannot be realized efficiently as quantum kernels. This observa-
tion requires us to identify quantum kernels that can be computed
efficiently on quantum computers, i.e., in polynomial time.

3.3.2 Generalization of quantum kernel machines

Generalization, which quantifies the ability of learning models (both classical
and quantum) to predict unseen data, is a critical metric for evaluating
the quality of a learning model. Due to its importance, here we analyze
the potential advantages of quantum kernels in terms of the generalization
ability.
For comprehensive, in this section, we first elucidate the generalization
error bounds for general kernel machines, establishing a unified framework
for a fair comparison between quantum kernels and classical kernels. Sub-
sequently, we introduce a geometry metric to assess the potential quantum
92 CHAPTER 3. QUANTUM KERNEL METHODS

advantage of quantum kernels with respect to generalization error for a fixed

amount of training data.

Generalization error bound for kernel machines

We begin by reviewing the optimal learning models based on the speci-
fied kernel machines which could be either classical or quantum, as dis-
cussed in Chapter 3.1.2. Suppose we have obtained n training examples
{(x(i) , y (i) )}ni=1 with x(i) ∈ Rd and y (i) = f (x(i) ) ∈ R, where f is the tar-
get function. After training on this data, there exists a machine learning
algorithm that outputs h(x) = w† ϕ(x), where ϕ(x) ∈ CD refers to the
hidden feature map corresponding the classical/quantum kernel function
k(x(i) , x(j) ) = Kij = ϕ(x(i) ) · ϕ(x(j) ). More precisely, considering the mean
square error as the loss function for such a task, we have
X n  2
†
L(w, x) = λw w + w† ϕ(x(i) ) − y (i) , (3.51)
i=1

where λ ≥ 0 is the regularization parameters for avoiding over-fitting.

Then the optimal parameters for optimizing this loss function refer to
w∗ = arg min L(w, x). (3.52)
w∈Θ

As discussed in Chapter 3.1.2, the optimal solution w∗ in Eqn. (3.52) has

the explicit form of
n X
X n
w∗ = Φ† (K + λIn )−1 y = ϕ(x(i) )((K + λIn )−1 )ij y (j) , (3.53)
i=1 j=1

where y = [y (1) , ..., y (n) ]⊤ refers to the vector of labels and K ∈ Rn×n is the
kernel matrix, and the second equality follows that Φ = [ϕ(x(1) ), · · · , ϕ(x(n) )]† .
Moreover, the norm of the optimal parameters has a simple form for the case
of λ → 0, i.e.,
∥w∗ ∥22 = y ⊤ K −1 y. (3.54)
We now expose the prediction error of these learning models, i.e.,

ϵw∗ (x) = f (x) − (w∗ )† ϕ(x) , (3.55)

which is uniquely determined by the kernel matrix K and the hyper-parameter

λ as shown in Eqn. (3.53). In particular, we will focus on discussing the up-
per bound on the expected prediction error, which is the sum of training
error and generalization error.
3.3. THEORETICAL FOUNDATIONS OF QUANTUM KERNEL MACHINES93

Prediction, training, and generalization error

In the context of learning theory, the upper bound of the expected pre-
diction error defined in Eqn. (3.55) (a.k.a, expected risk) is achieved
by separately analyzing the upper bounds of the training error (a.k.a,
empirical risk) and the generalization error, i.e.,
n n
1X 1X
Ex∼D ϵw∗ (x) = ϵw∗ (x(i) ) + Ex∼D ϵw∗ (x) − ϵw∗ (x(i) ) .
n n
i=1 i=1
| {z } | {z }
Training error Generalization error
(3.56)
This decomposition stems from the fact that data distribution D is
inaccessible in most scenarios.

We now will separately give a rough derivation of the upper bound of

training error and generalization error, which present the necessary steps for
the derivation for a clear exposition and omit the specific details that could
be found in Huang et al. (2021a).
• Training error. Employing the convexity of function and Jensen’s inequal-
ity, the training error yields
v
n u n
1X u1 X
2
ϵw∗ (x ) ≤ t
(i)
(w∗ )† ϕ(x(i) ) − y (i) . (3.57)
n n
i=1 i=1

Moreover, combining with the expression for the optimal w∗ given in Eqn. (3.53),
we can obtain the upper bound of training error in terms of the kernel matrix
K and hyper-parameter λ, i.e.,
n
r
1X λ2 y ⊤ (K + λIn )−2 y
ϵw∗ (x(i) ) ≤ . (3.58)
n n
i=1

We can see that when λ = 0 and K are invertible, the training error is zero.
However, the hyper-parameter is usually set as λ > 0 in practice.
• Generalization error. The derivation of generalization error is more com-
plicated than training error, which involves a basic theorem in statistic and
learning theory as presented below.

Fact 3.16 (Theorem 3.3, Mohri (2018)). Let G be a family of function map-
pings from a set Z to [0, 1]. Then for any δ > 0, with probability at least 1−δ
94 CHAPTER 3. QUANTUM KERNEL METHODS

over identical and independent draw of n samples from Z : z (1) , · · · , z (n) ,

we have for all g ∈ G,

n
" n
# r
1X 1 X log(2/δ)
Ez g(z) ≤ g(z (i) ) + 2Eσ sup σi g(z (i) ) + 3 , (3.59)
n g∈G n 2n
i=1 i=1

where σ1 , · · · , σn are in independent and uniform random variables over

{1, −1}.

For kernel functions defined in Eqn. (3.55), the set Z refers to the space
of input vector with z (i) = x(i) drawn from some input distribution. Each
function g would be equal to ϵw /α for some w, where ϵw is defined in
Eqn. (3.55) and α is a normalization factor such that the range of ϵw /α is
[0, 1]. Without loss of generality, we assume that α = 1. For any specific
parameter w, consider the special case of G with setting Gw = {ϵv | ∀ ∥v∥ ≤
∥w∥}. Then we have the upper bound of generalization error for the optimal
parameter,

n
1X
Ex ϵ
w∗ (x) − ϵw∗ (x(i) )
n
i=1
" n
# r
1 X log(2∥w∗ ∥/δ)
≤2Eσ sup σi ϵv (x(i) ) + 3 . (3.60)
∥v∥≤∥w∗ ∥ n i=1
2n

Moreover, applying Talagrand’s contraction lemma (Mohri, 2018) to the first

term on the right-hand side, we have
" n
# " n
#
1X 1X ∗ †
Eσ sup (i)
σi ϵv (x ) ≤Eσ sup (i)
σi (w ) ϕ(x )
∥v∥≤∥w∗ ∥ n i=1 ∥v∥≤∥w∗ ∥ n i=1
r
∥w∗ ∥2
≤ , (3.61)
n

where the first inequality follows that ϵv (x(i) ) is Lipschitz continuous with
respect to (w∗ )† · ϕ(x(i) ) with Lipschitz constant 1, the second inequality
follows direct algebra operation. For the detailed simplification processes,
refer to Lemma 1 of Huang et al. (2021a).
In conjunction with Eqn. (3.60), Eqn. (3.61), and the expression of the
optimal parameter w∗ given in Eqn. (3.53), we can reach the final upper
3.3. THEORETICAL FOUNDATIONS OF QUANTUM KERNEL MACHINES95

bound of generalization error in terms of the kernel matrix, i.e.,

n
1X
Ex ϵw∗ (x) − ϵw∗ (x(i) )
n
i=1
r
y ⊤ (K + λIn )−1 K(K + λIn )−1 y log(2/δ)
≤5 · +3 . (3.62)
n 2n
For the case of λ = 0, the first term in the generalization error bound has a
simple form of 5 · y ⊤ K −1 y/n.
By obtaining the upper bound of training and generalization error, we
can directly get the prediction error of the learning model for a specific
kernel matrix. We summarize these three errors below.

Remark
The upper bound of the prediction error for kernel methods defined
in Eqn. (3.55) refers to
r
λ2 y ⊤ (K + λIn )−2 y
Ex∼D ϵw∗ (x) ≤ O +
| {zn }
Training error
r r !
y ⊤ (K + λIn )−1 K(K + λIn )−1 y log(1/δ)
+ , (3.63)
| n {z n }
Generalization error
where K is a specific kernel related to the learning models, y =
[y (1) , · · · , y (n) ] refers to the label vector of n training data. For the
special case of λ = 0, the training error is zero, and the prediction
error reduce to the generalization error with a simple form
r r !
y ⊤ K −1 y log(1/δ)
Ex∼D ϵw∗ (x) ≤ O + . (3.64)
n n

We remark that the derived upper bound of the prediction error ap-
plies to both classical and quantum kernels, as we have not imposed any
restrictions on the kernel matrix K during the derivation.

Quantum kernels with prediction advantages

Using the above theoretical results of generalization error for general kernel
machines, we now elucidate how to access the potential quantum advantage
96 CHAPTER 3. QUANTUM KERNEL METHODS

of quantum kernels. For a clear understanding, we focus on the

p case of λ = 0
⊤ −1
p which the prediction error bound has a simple form of O( y K y/n +
in
log(1/δ)/n) as shown in Eqn. (3.64). In particular, this bound has a key
dependence on two quantities, namely (1) the size of training data n; (2)
the kernel-dependent term y ⊤ K −1 y, which we denote as

sK (y) = y ⊤ K −1 y, (3.65)

in the following discussion for simplification.

The dependence on n reflects the role of data to improve prediction
performance. On the other hand, the quantity sK (y) is equal to the model
complexity of the trained function h(x) = (w∗ )† · ϕ(x), where sK (y) =
∥w∗ ∥2 = (w∗ )† · w∗ after training. A smaller value of sK (y) implies better
generalization to new data x sampled from the distribution D. Intuitively,
sK (y) measures whether the closeness between x(i) and x(j) defined by the
kernel function k(x(i) , x(j) ) matches well with the closeness of the labels y (i)
and y (j) , recalling that a larger kernel value indicates two points are closer.
Based on the above discussion, we are now in the position to analyze the
potential advantage of quantum kernel machines. Given a set of training
data {(x(i) , y (i) )}ni=1 , let Q and C be the class of Quantum and Classical
kernels respectively that can be efficiently evaluated on quantum and clas-
sical computers for any given x. In order to formally evaluate the potential
for quantum prediction advantage generally, one must take the quantum
kernel KQ ∈ Q to satisfy the following two conditions:

• KQ is hard to compute classically for any given x.

• According to Eqn. (3.65), the quantity sQ (y) related to the quan-

tum kernel KQ must be the minimal over all efficient classical models,
namely sQ (y) ≤ sC (y) for any KC ∈ C with sC (y) being the KC
related quantity.

From the second condition, we can see that the potential advantage for
the quantum kernel KQ to predict better than a classical kernel KC depends
on the largest possible separation between sQ (y) and sC (y) for a dataset.
Huang et al. (2021a) define a geometry metric, namely asymmetric ge-
ometric difference, to characterize this separation for a fixed training
dataset, which is given by
r
p p
gCQ = g(KC ||KQ ) = KQ (KC−1 ) KQ , (3.66)
∞
3.3. THEORETICAL FOUNDATIONS OF QUANTUM KERNEL MACHINES97

Geometry test for quantum prediction advantage

Classical ML predicts similar or

𝑔𝐶𝑄 ≪ 𝑛 Classical ML can
better than the quantum ML 𝑠𝐶 ≪ 𝑛
learn & predict well
Data set exists with 𝑠𝐶 ∝ 𝑛, potential quantum
Complexity test
𝑔𝐶𝑄 ∝ 𝑛 potential quantum 𝑠𝑄 ≪ 𝑛
for specific data advantage
advantage
Can be constructed Else Likely hard to learn

Figure 3.5: A flowchart for understanding the potential for quantum

prediction advantage (Adapted from Huang et al. (2021a)).

where ∥ · ∥∞ is the spectral norm of the resulting matrix and we assume

Tr(KQ ) = Tr(KC ) = n. The geometric difference g(KC ||KQ ) can be com-
puted on a classical computer by performing a singular value decomposition
of the n × n matrices KC and KQ in time at most order n3 .
Figure 3.5 presents a detailed flowchart for evaluating the potential quan-
tum prediction advantage using the defined geometric difference gCQ in a
machine learning task. The input consists of n data samples, along with
both quantum and classical methods, each associated with its respective
kernel. The tests are conducted as a function of n to highlight the role of
data size in determining the potential for a prediction advantage.
First, the geometric quantity gCQ is evaluated, which quantifies the po-
tential for a separation between quantum and classical predictions, without
yet considering the actual function to be learned. Specifically, a large value
√
of gCQ ∝ n suggests the possibility of a quantum prediction advantage.
If the test is passed, an adversarial dataset that saturates this limit can
be constructed. In particular, there exists a dataset with sC = gCQ 2 s ,
Q
where the quantum model exhibits superior prediction performance, as will
be described in the subsequent context.
Subsequently, to incorporate the provided data, a label-specific test can
be performed using the model complexities sC and sQ . For quantum kernels
and classical learning models, when sQ ≪ n and sC ∝ n, a prediction ad-
vantage for quantum models is possible, as supported by the generalization
√
bound in Eqn. (3.64). In contrast, if gCQ is small such as gCQ ≪ n, the
classical learning model will likely have a similar or better model complexity
sC (y) compared to the quantum model. In this case, the classical model’s
prediction performance will be competitive or superior, and the classical
model would likely be preferred.
98 CHAPTER 3. QUANTUM KERNEL METHODS

Construction of dataset with maximal quantum advantage

We now elucidate how to explicitly construct such a data set to enable the
maximal separation between the model complexity of quantum kernels and
classical kernels, as indicated by the geometry test in Figure 3.5. To separate
between quantum and classical models related to kernel matrix KQ and KC ,
we consider that the ratio between sC and sQ is as large as possible for a
particular choice of targets y (1) , · · · , y (n) . This could be achieved by solving
the optimization problem

sC y ⊤ K −1 y
minn = minn ⊤ C−1 , (3.67)
y∈R sQ y∈R y KQ y

which has an exact solution p given by a generalized eigenvaluepproblem. pThe

−1
solution is given by y = KQ v, where v is the eigenvector of KQ KC KQ
p p
corresponding to the eigenvalue g 2 = ∥ KQ KC−1 KQ ∥∞ . This guaran-
tees that sC = g 2 sQ , and note that by definition of g, sC ≤ g 2 sQ . Hence
this dataset fully utilized the geometric difference between the quantum
and classical space. Finally, we can turn this dataset, which maps input
x to a real value yQ , into a classification task by replacing yQ with +1 if
yQ > median(y (1) , · · · , y (n) ) and −1 if yQ ≤ median(y (1) , · · · , y (n) ). The
constructed dataset will yield the largest separation between quantum and
classical models from a learning theoretic sense, as the model complexity
fully saturates the geometric difference. If there is no quantum advantage
in this dataset, there will likely be none.

3.4 Code Demonstration

In this section, we explore the practical implementation of a quantum kernel.
Before diving into concrete code examples, we discuss an efficient strategy
for estimating the quantum kernel in practice.
As explained in Chapter. 3.2, one method for estimating the quantum
kernel is the SWAP test, which is resource-intensive. Alternatively, we can
encode the classical data vector x using a unitary operation U (x) and apply
the inverse embedding of x′ using U (x′ )† on the same qubits. The quan-
tum kernel kQ (x, x′ ) is then estimated by measuring the expectation of the
projector O = (|0⟩ ⟨0|)⊗N on the zero state.
The complete quantum circuit architecture for this process is illustrated
 3.4. CODE DEMONSTRATION 99

in Figure 3.2. Mathematically, the process is expressed as:

⟨0⊗N |U (x′ )U (x)† OU (x′ )† U (x)|0⊗N ⟩

= ⟨0⊗N |U (x′ )U (x)† |0⟩⊗N ⟨0|⊗N U (x′ )† U (x)|0⊗N ⟩
2
= ⟨0⊗N |U (x′ )† U (x)|0⊗N ⟩
2
= ⟨ϕ(x)|ϕ(x′ )⟩
=kQ (x, x′ ). (3.68)

This approach allows the quantum kernel estimation to use the same number
of qubits required for the quantum feature mapping of the classical vector
x.
Next, we provide an example demonstrating the workflow of applying
quantum kernels for classification tasks on the MNIST dataset, with step-
by-step code implementation.

3.4.1 Classification on MNIST dataset

We train a Support Vector Machine (SVM) classifier associated with a quan-
tum kernel on the MNIST dataset. The pipeline involves the following steps.

Step 1 Load and preprocess the dataset.

Step 2 Define the quantum feature mapping.

Step 3 Construct the quantum kernel.

Step 4 Train and evaluate the SVM classifier.

We begin by importing the required libraries.

1 import pennylane as qml
2 from sklearn . datasets import fetch_openml
3 from sklearn . decomposition import PCA
4 from sklearn . model_selection import train_test_split
5 from sklearn . preprocessing import StandardScaler
6 from sklearn . svm import SVC
7 from sklearn . metrics import accuracy_score
8 import numpy as np

Step 1: Dataset preparation. We focus on the digits 3 and 6 in the

MNIST dataset, forming a binary classification problem. Principal Com-
ponent Analysis (PCA) (Abdi and Williams, 2010) is applied to reduce the
 100 CHAPTER 3. QUANTUM KERNEL METHODS

feature dimension of the images, minimizing the number of required qubits

for encoding. The compressed features are normalized to align with the
periodicity of the quantum feature mapping.
1 def load_mnist ( n_qubit ) :
2 # Load MNIST dataset from OpenML
3 mnist = fetch_openml ( ’ mnist_784 ’ , version =1)
4 X , y = mnist . data , mnist . target
5
6 # Filter out the digits 3 and 6
7 mask = ( y == ’3 ’) | ( y == ’6 ’)
8 X_filtered = X [ mask ]
9 y_filtered = y [ mask ]
10
11 # Convert labels to binary (0 for digit 3 and 1 for
digit 6)
12 y_filtered = np . where ( y_filtered == ’3 ’ , 0 , 1)
13

14 # Apply PCA to reduce feature dimension

15 pca = PCA ( n_components = n_qubit )
16 X_reduced = pca . fit_transform ( X_filtered )
17
18 # Normalize the input features
19 scaler = StandardScaler () . fit ( X_reduced )
20 X_scaled = scaler . transform ( X_reduced )
21
22 # Split into training and testing sets
23 X_train , X_test , y_train , y_test = train_test_split (
X_scaled , y_filtered , test_size =0.2 , random_state
=42)
24 return X_train , X_test , y_train , y_test
25
26 n_qubit = 8
27 X_train , X_test , y_train , y_test = load_mnist ( n_qubit )

To better understand the structure of the dataset, we visualize the

training data using t-distributed Stochastic Neighbor Embedding (t-SNE)
(Van der Maaten and Hinton, 2008). The following code generates the vi-
sualization:
1 def v isuali ze_dat aset (X , labels ) :
2 import matplotlib . pyplot as plt
3 from sklearn . manifold import TSNE
4

5 tsne = TSNE ( n_components =2 , random_state =42 ,

 3.4. CODE DEMONSTRATION 101

perplexity =30)
6 label2name = {
7 0: ’3 ’ ,
8 1: ’6 ’
9 }
10 mnist_tsne = tsne . fit_transform ( X )
11 for label in np . unique ( labels ) :
12 indices = labels == label
13 plt . scatter ( mnist_tsne [ indices , 0] , mnist_tsne [
indices , 1] , cmap = ’ coolwarm ’ , s =20 , label = f ’
Number ␣ { label2name [ label ]} ’)
14
15 # Add labels and legend
16 plt . title ( "t - SNE ␣ Visualization ␣ of ␣ Two ␣ Classes ␣ (3 ␣ and ␣
6) " )
17 plt . xlabel ( "t - SNE ␣ Dimension ␣ 1 " )
18 plt . ylabel ( "t - SNE ␣ Dimension ␣ 2 " )
19 plt . legend ()
20
21 plt . tight_layout ()
22 plt . show ()
23

24 visu alize_ datase t ( X_train , y_train )

The resulting t-SNE visualization is shown in Figure 3.6.

 102 CHAPTER 3. QUANTUM KERNEL METHODS

t-SNE Visualization of Two Classes (3 and 6)

80
Number 3
Number 6
60
40
20
t-SNE Dimension 2

0
20
40
60
80
75 50 25 0 25 50 75 100
t-SNE Dimension 1

Figure 3.6: T-SNE visualization of MNIST dataset of two classes

‘3’ and ‘6’.

Steps 2&3: Define quantum feature mapping and building quan-

tum kernel. We use angle embedding as the quantum feature mapping
method. The quantum kernel is implemented as follows.
1 dev = qml . device ( ’ default . qubit ’ , wires = n_qubit )
2
3 @qml . qnode ( dev )
4 def kernel ( x1 , x2 , n_qubit ) :
5 qml . AngleEmbedding ( x1 , wires = range ( n_qubit ) )
6 qml . adjoint ( qml . AngleEmbedding ) ( x2 , wires = range (
n_qubit ) )
7 return qml . expval ( qml . Projector ([0]* n_qubit , wires =
range ( n_qubit ) ) )

Using the quantum kernel, we construct the kernel matrix by computing

the kernel values for all pairs of samples:
1 def kernel_mat (A , B ) :
2 mat = []
 3.4. CODE DEMONSTRATION 103

3 for a in A :
4 row = []
5 for b in B :
6 row . append ( kernel (a , b , n_qubit ) )
7 mat . append ( row )
8 return np . array ( mat )

Next, we visualize the quantum kernel matrix to gain insight into its
structure.
1 def visualize_kernel (X , y , n_sample ) :
2 X_vis = []
3 for label in np . unique ( y ) :
4 index = y == label
5 X_vis . append ( X [ index ][: n_sample ])
6
7 X_vis = np . concatenate ( X_vis , axis =0)
8 n _sa mp le _p er _c la ss = len ( X_vis ) // 2
9
10 sim_mat = kernel_mat ( X_vis , X_vis )
11 np . save ( ’ code / chapter_4_kernel / sim_mat . npy ’ , sim_mat )
12
13 import matplotlib . pyplot as plt
14 plt . imshow ( sim_mat , cmap = ’ viridis ’ , interpolation = ’
nearest ’)
15

16 # Add color bar to show the scale

17 plt . colorbar ( label = ’ Similarity ’)
18
19 plt . axhline ( n_ sa mp le _p er_ cl as s - 0.5 , color = ’ red ’ ,
linewidth =1.5) # Horizontal line
20 plt . axvline ( n_ sa mp le _p er_ cl as s - 0.5 , color = ’ red ’ ,
linewidth =1.5) # Vertical line
21
22 xticks = yticks = np . arange (0 , len ( X_vis ) )
23 xtick_labels = [ f " 3 -{ i +1} " if i < n_ sa mpl e_ pe r_ cl as s
else f " 6 -{ i +1 - n _s am pl e_ pe r_ cl as s } " for i in range
( len ( X_vis ) ) ]
24 ytick_labels = xtick_labels
25
26 plt . xticks ( xticks , labels = xtick_labels , rotation =90 ,
fontsize =8)
27 plt . yticks ( yticks , labels = ytick_labels , fontsize =8)
28

29 # Title and axis labels

 104 CHAPTER 3. QUANTUM KERNEL METHODS

30 plt . title ( " Quantum ␣ Kernel ␣ Matrix " )

31 plt . xlabel ( " Sample ␣ Index " )
32 plt . ylabel ( " Sample ␣ Index " )
33

34
35 plt . tight_layout ()
36 plt . show ()
37
38 visualize_kernel ( X_train , y_train , 10)

The resulting kernel matrix is shown in Figure 3.7.

Quantum Kernel Matrix

3-1 1.0
3-2
3-3
3-4
3-5 0.8
3-6
3-7
3-8
0.6
Sample Index

3-9

Similarity
3-10
6-1
6-2
6-3 0.4
6-4
6-5
6-6
6-7 0.2
6-8
6-9
6-10
3-1
3-2
3-3
3-4
3-5
3-6
3-7
3-8
3-9
3-10
6-1
6-2
6-3
6-4
6-5
6-6
6-7
6-8
6-9
6-10

Sample Index

Figure 3.7: Visualization of quantum kernel matrix on 20 samples,

equally drawn from two classes ‘3’ and ‘6’ in MNIST dataset.

From the visualization, we observe a clear block structure:

• Most of the elements in the top-left and bottom-right blocks, where

samples belong to the same class, show higher similarity values.
• Most of the elements in the top-right and bottom-left blocks, where
samples belong to different classes, exhibit lower similarity values.

This indicates that it may be possible to distinguish the two classes by

setting a similarity threshold.
Step 4: Training SVM. To achieve higher classification accuracy, we
build, train, and evaluate the SVM classifier with the quantum kernel ma-
trix:
 3.4. CODE DEMONSTRATION 105

1 svm = SVC ( kernel = kernel_mat )

2 svm . fit ( X_train , y_train )
3 pred = svm . predict ( X_test )
4 print ( " Accuracy : " , accuracy_score ( y_test , pred ) )

To further analyze how the performance of the SVM with a quantum

kernel depends on the size of the training dataset, we vary the number of
training samples from 10 to 100 in increments of 10. For each configuration,
we record the corresponding classification accuracy on the test data.
1 svm = SVC ( kernel = ’ precomputed ’)
2 n_sample_max = 100
3 X_train_sample = []
4 y_train_sample = []
5 for label in np . unique ( y_train ) :
6 index = y_train == label
7 X_train_sample . append ( X_train [ index ][: n_sample_max ])
8 y_train_sample . append ( y_train [ index ][: n_sample_max ])
9 X_train_sample = np . concatenate ( X_train_sample , axis =0)
10 y_train_sample = np . concatenate ( y_train_sample , axis =0)
11 kernel_mat_train = kernel_mat ( X_train_sample ,
X_train_sample )
12 kernel_mat_test = kernel_mat ( X_test , X_train_sample )
13
14 accuracy = []
15 n_samples = []
16 for n_sample in range (10 , n_sample_max +10 , 10) :
17 class1_indices = np . arange ( n_sample )
18 class2_indices = np . arange ( n_sample_max , n_sample_max
+ n_sample )
19 selected_indices = np . concatenate ([ class1_indices ,
class2_indices ])
20
21 svm . fit ( kernel_mat_train [ np . ix_ ( selected_indices ,
selected_indices ) ] , np . concatenate ([
y_train_sample [: n_sample ] , y_train_sample [
n_sample_max : n_sample_max + n_sample ]]) )
22 pred = svm . predict ( np . concatenate ([ kernel_mat_test [: ,
: n_sample ] , kernel_mat_test [: , n_sample_max :
n_sample_max + n_sample ]] , axis =1) )
23 accuracy . append ( accuracy_score ( y_test , pred ) )
24 n_samples . append ( n_sample )
25

26 plt . plot ( n_sample , accuracy , marker = ’o ’)

 106 CHAPTER 3. QUANTUM KERNEL METHODS

27 plt . title ( ’ Classification ␣ Accuracy ␣ vs . ␣ # Training ␣ Samples ’

)
28 plt . xlabel ( ’# Training ␣ Samples ’)
29 plt . xticks ( n_sample , n_sample )
30 plt . ylabel ( ’ Accuracy ’)
31 plt . grid ()
32 plt . tight_layout ()
33 plt . show ()

Classification Accuracy vs. #Training Samples

0.99

0.98

0.97
Accuracy

0.96

0.95

0.94

20 40 60 80 100 120 140 160 180 200

#Training Samples

Figure 3.8: The classification accuracy on test data as a function of

the number of training samples.

3.5 Bibliographic Remarks

The foundational concept of using quantum computers to evaluate kernel
functions, namely the concept of quantum kernels, was first explored by
Schuld et al. (2017), who highlighted the fundamental differences between
quantum kernels and quantum support vector machines. Building on this,
Havlı́ček et al. (2019) and Schuld and Killoran (2019) established a connec-
tion between quantum kernels and parameterized quantum circuits (PQCs),
demonstrating their practical implementation. These works emphasized the
parallels between quantum feature maps and the classical kernel trick. Since
then, a large number of studies delved into figuring out the potential of quan-
tum kernels for solving practical real-world problems.
The recent advancements in quantum kernel machines can be roughly
3.5. BIBLIOGRAPHIC REMARKS 107

categorized into three key areas: kernel design, theoretical findings, and
applications. Specifically, the advances in kernel design focus on addressing
challenges such as vanishing similarity and kernel concentration by exploring
innovative frameworks. Theoretical studies delve into the limitations and
capabilities of quantum kernels, examining factors such as generalization
error bounds, noise resilience, and their capacity to demonstrate quantum
advantage. Finally, applications of quantum kernels showcase their potential
across diverse domains. In the rest of this section, we separately review the
existing developments within each of these three branches.

3.5.1 Quantum kernel design

A crucial research line in this field focuses on constructing trainable quan-
tum kernels to maximize performance for specific datasets and problem do-
mains. In particular, traditional quantum kernels, with fixed data embed-
ding schemes, are limited to specific feature representation spaces and often
fail to capture the complex and diverse patterns inherent in real-world data.
To address this limitation, Lloyd et al. (2020) explored the construction of
task-specific quantum feature maps using measurement theory. Building on
this idea, Hubregtsen et al. (2022) introduced a method to optimize quantum
feature maps variationally within quantum kernels, linking this approach
to the concept of data re-uploading techniques (Pérez-Salinas et al., 2020;
Schuld et al., 2021). Additionally, Vedaie et al. (2020) and Lei et al. (2024)
proposed leveraging multiple kernel learning and architecture search to con-
struct quantum kernels, respectively. Last, Glick et al. (2024) proposed the
covariant quantum kernels for efficiently solving the problems with group
structure.
An orthogonal research direction is addressing the issue of exponential
kernel concentration, also known as vanishing similarity, in quantum kernels
(Thanasilp et al., 2022). Specifically, quantum kernels, which are defined
as the inner product between quantum feature mappings, often suffer from
the phenomenon of vanishing similarity. This issue was first highlighted
by Huang et al. (2021a), who found that quantum feature mappings are
typically “far” from one another in high-dimensional feature spaces, leading
to vanishing similarity and, consequently, poor generalization performance.
To mitigate this issue, Huang et al. (2021a) introduced projected quan-
tum kernels, which store feature vectors in classical memory and evaluate a
Gaussian kernel. This approach replaces the reliance on the inner product of
quantum states, as seen in traditional quantum embedding kernels. More-
over, Suzuki et al. (2022) proposed the anti-symmetric logarithmic derivative
108 CHAPTER 3. QUANTUM KERNEL METHODS

quantum Fisher kernel, which avoids the exponential kernel concentration

problem by encoding geometric information of the input data. Beyond de-
veloping new types of quantum kernels, Shaydulin and Wild (2022) and
Canatar et al. (2022) explored strategies to mitigate the exponential con-
centration issue for quantum embedding kernels by scaling input data with
carefully chosen hyperparameters. This approach clusters the data-encoded
quantum states closer together in feature space, reducing the risk of vanish-
ing similarity at the cost of slightly lowering expressivity.

3.5.2 Theoretical studies of quantum kernels

The theoretical studies of quantum kernels aim to rigorously understand
their performance potential and limitations under realistic conditions, en-
abling the design of more effective, robust, and generalizable quantum kernel
methods. Prior literature in this context focuses on exploring two aspects
of quantum kernels, namely, expressivity and generalization ability.

Expressivity of quantum kernels

The expressivity of quantum kernels refers to their capacity to capture com-
plex data relationships and represent intricate patterns in the feature space.
A common approach to studying this is through the analysis of the reproduc-
ing kernel Hilbert space (RKHS), which provides insights into the underlying
feature representations of quantum kernels.
Schuld (2021) rigorously analyzed the RKHS of embedding-based quan-
tum kernels and established the universality approximation theorem, demon-
strating that quantum kernels can approximate a wide class of functions.
Building on this, Jerbi et al. (2023) extended the analysis by investigating
parameterized quantum embedding kernels, introducing a data-reuploading
structure and proving a corresponding universality approximation theorem.
These results underscore the expressive power of quantum kernels in repre-
senting complex data structures.
Despite these advances, the studies on expressive power and universality
approximation often overlook the efficiency of constructing quantum kernels.
Specifically, if the computational cost of constructing a universal quantum
kernel is comparable to that of classical methods, the practical advantages
of quantum kernels become questionable.
To narrow this gap, Gil-Fuster et al. (2024) examined the expressive
power of efficient quantum kernels that can be implemented on quantum
computers within polynomial time. Their work provides a detailed analysis
3.5. BIBLIOGRAPHIC REMARKS 109

of the types of kernels that are achievable with a polynomial number of

qubits and within polynomial time, offering insights into the feasibility and
practical utility of quantum kernels in real-world scenarios.
However, alongside the exploration of expressive power, a significant
challenge known as exponential kernel concentration has been identified.
Thanasilp et al. (2022) identified four key factors contributing to this issue:
high expressivity of data embeddings, global measurements, entanglement,
and noise. To address this limitation, substantial research has focused on
designing advanced quantum kernels to mitigate exponential kernel concen-
tration, as discussed in Chapter 3.5.1.

Generalization of quantum kernels

The generalization ability of a learning model—its capacity to perform well
on unseen data—is a critical factor in evaluating its effectiveness. In this con-
text, a considerable body of research has investigated the generalization abil-
ity of quantum kernels. Huang et al. (2021a) established a data-dependent
generalization error bound for quantum kernels and demonstrated that, for
certain types of data (such as those generated by quantum circuits), quan-
tum kernels can achieve a generalization advantage over classical learning
models.
In addition, Wang et al. (2021a) explored the generalization performance
of quantum kernels in the noisy scenario, where practical limitations such
as finite measurements and quantum noise are taken into account. Their
work rigorously showed that the generalization performance of quantum
kernels could be significantly degraded in scenarios involving large training
datasets, limited measurement repetitions, or high levels of system noise.
To address these challenges, they proposed an effective method based on
indefinite kernel learning to help preserve generalization performance under
such constraints.
Beyond quantum data, Liu et al. (2021b) examined the generalization
error of quantum kernels using artificial classical datasets, such as those
based on the discrete logarithm problem. Their results demonstrated that
quantum kernels could achieve accurate predictions in polynomial time for
such problems, whereas classical learning models require exponential time,
highlighting the potential computational advantages of quantum kernels.
Despite these promising results, Kübler et al. (2021) studied the gener-
alization ability of quantum kernels from the perspective of inductive bias.
They argued that quantum kernels, lacking inductive bias, often fail to out-
perform classical models in practical scenarios. This underscores the im-
110 CHAPTER 3. QUANTUM KERNEL METHODS

portance of carefully designing embeddings and aligning kernels to achieve

meaningful and practical quantum advantages.

Provable advantages of quantum kernels

The potential for quantum kernels to demonstrate quantum advantage has
been a central focus of research. For instance, Huang et al. (2021a) provided
evidence of generalization advantages for quantum kernels on quantum data.
Similarly, Liu et al. (2021b) presented a rigorous framework showing that
quantum kernels can efficiently solve problems like the discrete logarithm
problem, which is believed to be intractable for classical computers under
standard cryptographic assumptions. Moreover, Sweke et al. (2021) demon-
strated quantum advantage in distribution learning tasks, offering some of
the earliest theoretical evidence of quantum advantage in machine learning.
However, many of these tasks are artificial, designed specifically to show-
case quantum advantages. This raises the question of how these theoretical
benefits can be translated to real-world applications. In this regard, the next
significant challenge is to demonstrate that quantum models can consistently
outperform classical models in solving practical, real-world problems.

3.5.3 Applications of quantum kernels

Motivated by the potential of quantum kernels to recognize complex data
patterns, numerous studies have explored their practical applications across
diverse fields, including classification, drug discovery, anomaly detection,
and financial modeling.
For instance, Beaulieu et al. (2022) investigate the use of quantum ker-
nels for image classification, specifically in identifying real-world manufac-
turing defects. Similarly, Rodriguez-Grasa et al. (2024) apply quantum ker-
nels to satellite image classification, a task of particular importance in the
earth observation industry. In the field of quantum physics, Sancho-Lorente
et al. (2022) and Wu et al. (2023) leverage quantum kernels to recognize
phases of quantum matter, where quantum kernels outperform classical
learning models in solving certain problems. In drug discovery, Batra et al.
(2021) explore the potential of quantum kernels to accelerate and improve
the identification of promising compounds.
Quantum kernels have also been explored in anomaly detection. Liu
and Rebentrost (2018) demonstrate their superior performance over clas-
sical methods in detecting anomalies within quantum data. Furthermore,
Grossi et al. (2022) employ quantum kernel methods for fraud classification
3.5. BIBLIOGRAPHIC REMARKS 111

tasks, showing improvements when benchmarked against classical methods.

Miyabe et al. (2023) expand their application to the financial domain by
proposing a quantum multiple-kernel learning methodology. This approach
broadens the scope of quantum kernels to include credit scoring and di-
rectional forecasting of asset price movements, highlighting their potential
utility in financial services.
Despite the promise shown in these applications, the realization of quan-
tum advantage in practical tasks remains an ongoing area of research, with
current efforts directed toward identifying real-world problems where quan-
tum kernels outperform classical alternatives.
112 CHAPTER 3. QUANTUM KERNEL METHODS
Chapter 4

Quantum Neural Networks

Classical neural networks (LeCun et al., 2015) are the foundation of modern
artificial intelligence technologies and have achieved widespread success in
fields such as computer vision (Voulodimos et al., 2018) and natural lan-
guage processing (Otter et al., 2020). However, despite these achievements,
classical neural networks face significant challenges, including excessively
large model sizes and the corresponding high computational costs (Hoff-
mann et al., 2022), especially in terms of energy consumption (de Vries,
2023). These limitations result from their dependence on classical computa-
tional resources, which are becoming increasingly unsustainable as models
grow in complexity.
Quantum neural networks (QNNs) (Jeswal and Chakraverty, 2019) offer
a promising solution by enhancing neural networks with the computational
potential of quantum circuits (Liu et al., 2024a). In QNNs, classical input
data is encoded into quantum states, and quantum gates with trainable pa-
rameters process these states in ways that classical systems cannot easily
replicate. This computational regime leverages quantum mechanics to ex-
plore new forms of pattern recognition and problem-solving that go beyond
classical methods. Thus, QNNs have the potential to outperform classical
neural networks in specific learning tasks (Huang et al., 2022), where the
advantages in processing and learning can be explored.
Despite these promising features, there are challenges in realizing the
full potential of QNNs, such as quantum noise (Peters et al., 2021) and the
requirement for scalable quantum hardware (Acharya et al., 2024). Nonethe-
less, ongoing advancements in quantum hardware and algorithm design
promise QNNs to address the inefficiencies of classical models, especially
in areas such as quantum many-body physics (Gardas et al., 2018) and

113
114 CHAPTER 4. QUANTUM NEURAL NETWORKS

quantum chemistry (Cao et al., 2019).

In this chapter, to provide a systematic overview, we begin by outlin-
ing the structure and function of classical neural networks in Chapter 4.1,
before transitioning to fault-tolerant and near-term quantum neural net-
works in Chapters 4.2 and 4.3, respectively. We also discuss the theoretical
foundations of QNNs in Chapter 4.4, focusing on trainability, expressivity,
and generalization capabilities. Finally, we provide illustrative code imple-
mentations of QNNs using the wine (Dua and Graff, 2017) and MNIST
datasets (LeCun et al., 1998) in Chapter 4.5.

4.1 Classical Neural Networks

Neural networks (McCulloch and Pitts, 1943; Gardner and Dorling, 1998;
Vaswani, 2017) are computer models inspired by the structure of the human
brain, designed to process and analyze complex patterns in data. Originally
developed from the concept of neurons connected by weighted pathways,
neural networks have become one of the most powerful tools in artificial in-
telligence (LeCun et al., 2015). Each neuron processes its inputs by applying
weights and non-linear activations, producing an output that feeds into the
next layer of neurons. This structure enables neural networks to learn com-
plex functions during training (Hornik, 1993). For example, given a dataset
of images and their labels, a neural network can learn to classify categories,
such as distinguishing between cats and dogs, by adjusting its parameters
during training. Guided by optimization algorithms such as gradient de-
scent (Amari, 1993), the learning process allows the network to gradually
reduce the error between the predicted and actual outputs, allowing it to
learn the best parameters for the given task.
After nearly a century of exploration, neural networks have undergone
remarkable advancements in both architectures and capabilities. The sim-
plest model, the perceptron (McCulloch and Pitts, 1943), laid the foundation
by showing how neural networks could learn to separate linearly classifi-
able categories. Building on this, deeper and more complex networks—such
as multilayer perceptrons (MLPs) (Gardner and Dorling, 1998) and trans-
formers (Vaswani, 2017)—have enabled breakthroughs in tasks such as au-
tonomous driving and content generation.

4.1.1 Perceptron
The perceptron model, first introduced by (McCulloch and Pitts, 1943), is
widely regarded as a foundational structure in artificial neural networks, in-
4.1. CLASSICAL NEURAL NETWORKS 115

Figure 4.1: Illustration of the perceptron. Inputs are processed with a

weighted linear combination followed by a non-linear activation to produce
the output.

spiring architectures ranging from convolutional neural networks (CNNs) (Le-

Cun et al., 1989) and residual neural networks (ResNets) (He et al., 2016)
to transformers (Vaswani, 2017). Due to its fundamental role, we next in-
troduce the mechanism of single-layer perceptrons.
A single-layer perceptron comprises three fundamental components: in-
put neurons, a weighted layer, and an output neuron as illustrated in Fig-
ure 4.1. Given a d-dimensional input vector x ∈ Rd , the input layer consists
of d neurons, each representing the feature xi for ∀i ∈ [d]. This input is
processed through a weighted summation, i.e.,

z = w⊤ x, (4.1)

where w⊤ is the transpose of the weight vector and z is the output of the
weighted layer. A non-linear activation function is then applied to produce
the output neuron ŷ. For the standard perceptron model, the sign function
is typically used as the activation function:
(
1, if z ≥ 0,
ŷ = f (z) = (4.2)
−1, if z < 0.

The perceptron learns from input data by iteratively adjusting its train-
able parameters w. In particular, let D = {(x(a) , y (a) )}na=1 be the training
dataset, where x(a) represents the input features of the a-th example, and
116 CHAPTER 4. QUANTUM NEURAL NETWORKS

y (a) ∈ {−1, 1} denotes the corresponding label. When the perceptron out-
puts a prediction ŷ (s) , the parameters are updated accordingly, i.e.,

w ← w + (y (s) − ŷ (s) )x(s) . (4.3)

The training process is repeated iteratively until the error reaches a prede-
fined threshold.
Perceptrons can perfectly classify linearly separable data with a finite
number of mistakes, as stated in Theorem 4.1.

Theorem 4.1 (Convergence of perceptrons (Novikoff, 1962)). Suppose the

training data consists of unit vectors separated by a margin of γ with la-
bels y (i) ∈ {−1, 1}. Then there exists a perceptron training algorithm that
achieves zero error with at most O( γ12 ) mistakes.

Proof of Theorem 4.1. Consider the initial parameter of the perceptron w =

0. Since the training dataset is linearly separable by a margin of γ, there
exists a unit vector w∗ such that y (i) w∗ ⊤ x(i) ≥ γ for all samples i ∈ [n].
Let x(s,t) be the sample that is misclassified in the t-th step, which is then
used for adjusting the parameter. Let w(t) be the parameter after the t-th
step. Using Eqn. (4.3), it can be shown that

w∗ ⊤ w(t) − w∗ ⊤ w(t − 1)
 
= y (s,t) − ŷ (s,t) w∗ ⊤ x(s,t)
= 2y (s,t) w∗ ⊤ x(s,t) ≥ 2γ, (4.4)

where Eqn. (4.4) is derived by noticing the sample (x(s,t) , y (s,t) ) is misclas-
sified with ŷ (s,t) ̸= y (s,t) and y (s,t) , ŷ (s,t) ∈ {−1, 1}. By considering the
initialization w(0) = 0, the norm of the parameter after the t-th step can
be bounded by

∥w(t)∥ ≥ w∗ ⊤ w(t) (4.5)

t
X

= w∗ ⊤ w(t′ ) − w(t′ − 1) (4.6)
t′ =1
≥ 2γt, (4.7)

where Eqn. (4.5) is follows from the condition ∥w∗ ∥ = 1. Eqn. (4.7) is
4.1. CLASSICAL NEURAL NETWORKS 117

derived by using the result in Eqn. (4.4). On the other hand,

∥w(t)∥2 − ∥w(t − 1)∥2

  2
= w(t − 1) + y (s,t) − ŷ (s,t) x(s,t) − ∥w(t − 1)∥2 (4.8)
2
= w(t − 1) + 2y (s,t) x(s,t) − ∥w(t − 1)∥2 (4.9)
= 4∥x(s,t) ∥2 + 4w(t − 1)⊤ y (s,t) x(s,t)
≤ 4 + 4w(t − 1)⊤ y (s,t) x(s,t) (4.10)
≤ 4, (4.11)

where Eqn. (4.8) follows from the weight update rule in Eqn. (4.3). Eqn. (4.9)
is derived by noticing that y (s,t) ̸= ŷ (s,t) and y (s,t) , ŷ (s,t) ∈ {−1, 1}. Eqn. (4.10)
follows from the condition ∥x(i) ∥ = 1 for all samples. Eqn. (4.11) is derived
by noticing that the sample (x(s,t) , y (s,t) ) is misclassified by the perceptron
with the parameter w(t − 1), i.e.

y (s,t) w(t − 1)⊤ x(s,t) ≤ 0.

Thus, after t steps, the parameter is bounded by

√
∥w(t)∥ ≤ 2 t. (4.12)

Combining Eqn. (4.7) and Eqn. (4.12), it can be shown that

1
t≤ . (4.13)
γ2

Since the parameters are used in an inner product operation, as shown

in Eqn. (4.1), the single-layer perceptron can be considered as a basic kernel
method employing the identity feature mapping. Consequently, the single-
layer perceptron can only classify linearly separable data and is inadequate
for handling more complex tasks, such as the XOR problem (Rosenblatt,
1958). This limitation has driven the development of advanced neural net-
works, such as multilayer perceptrons (MLPs) (Gardner and Dorling, 1998),
which can capture non-linear relationships by incorporating non-linear acti-
vation functions and multi-layer structures.
118 CHAPTER 4. QUANTUM NEURAL NETWORKS

Figure 4.2: Illustration of a multilayer perceptron with two hidden

layers. Dashed lines denote softmax operations.

4.1.2 Multilayer perceptron

The multilayer perceptron (MLP) is a fully connected neural network archi-
tecture consisting of three components: the input layer, hidden layers, and
output layer, as illustrated in Figure 4.2. Similar to the single-layer percep-
tron introduced in Chapter 4.1.1, the neurons in the MLP are connected
through weighted sums, followed by non-linear activation functions.
The mathematical expression of MLP is as follows. Let x(a,1) be the a-th
input data and ℓ = 1 denote the input layer. Define L as the number of total
layers. The forward propagation at the (ℓ + 1)-th layer ∀ℓ ∈ {1, 2, ..., L − 2}
yields

z (a,ℓ+1) = W (ℓ) x(a,ℓ) + b(ℓ) ,

x(a,ℓ+1) = σ(z (a,ℓ+1) ),

where σ represents the non-linear activation function, and W (ℓ) and b(ℓ)
denotes trainable weight and the bias term, respectively. Similar to the no-
tation z in the perceptron in Chapter 4.1.1, z (a,ℓ+1) denotes the output of
the linear sum in the ℓ + 1-th layer, which is expressed in a more gener-
alized vector form. Therefore, the parameter for the weighted linear sum
is represented in matrix form as W (ℓ) . Various methodologies have been
proposed for implementing non-linear activations, with some common ap-
proaches summarized in Table 4.1.
4.1. CLASSICAL NEURAL NETWORKS 119

Table 4.1: Common non-linear activation functions.

Name Formulation
sigmoid function σ(x) = 1/(1 + exp(−x))
hyperbolic tangent function σ(x) = tanh(x)
rectified linear unit (ReLU) function σ(x) = max(0, x)

After passing through L − 2 hidden layers, the output of MLP given by

the equation below serves as the prediction to approximate the target label
y (a) , i.e.,
 ⊤
(a,L) (a,L)
exp(x1 ), · · · , exp(xp )
ŷ (a) = softmax(x(a,L) ) := Pp (a,L)
,
i=1 exp(xi )

with p here denotes the dimension of x(a,L) .

Next, we provide a toy example of binary classification to explain the
MLP learning procedure. Let {(x(a) , y (a) )}a∈D be the training dataset D,
where x(a) is the feature vector and y (a) ∈ {(1, 0)⊤ , (0, 1)⊤ } is the label for
two categories. Consider the MLP with one hidden layer. The prediction
can be expressed as follows:
 
ŷ (a) = softmax(x(a,3) ) = softmax ◦ σ z (a,3)
 
= softmax ◦ σ W (2) x(a,2) + b(2)
   
= softmax ◦ σ W (2) σ z (a,2) + b(2)
   
= softmax ◦ σ W (2) σ W (1) x(a,1) + b(1) + b(2) ,

where ◦ denotes the function composition. We use σ(x) = 1/(1 + exp(−x))

as the non-linear activation function.
MLP learns from the given dataset by minimizing the loss function with
respect to the parameters θ = (W (1) , W (2) , b(1) , b(2) ), which is defined as
the ℓ2 norm distance between the prediction and the label,
1 X (a) 1 X (a) 2
L(θ) = L (θ) = ŷ (θ) − y (a) . (4.14)
|D| 2|D|
a∈D a∈D

We use gradient descent with learning rate η to optimize the parameters:

θ(t + 1) = θ(t) − η∇θ L(θ(t)).

120 CHAPTER 4. QUANTUM NEURAL NETWORKS

Figure 4.3: Illustration of backpropagation when calculating the

gradient of an MLP with one hidden layer. The index of sample a is
omitted for simplicity.

As illustrated in Figure 4.3, the gradient is computed using backpropaga-

tion (LeCun et al., 1988) as follows. First, the gradient with respect to the
output layer is given by

∂L(a)
= ŷ (a) − y (a) ,
∂ ŷ (a)
∂L(a) ∂ ŷ (a) ∂L(a) h 
(a)
 i (a)
(a) (a)⊤ ∂L
= = diag ŷ − ŷ ŷ ,
∂x(a,3) ∂x(a,3) ∂ ŷ (a) ∂ ŷ (a)
∂L(a) ∂x(a,3) ∂L(a) h  i (a)
(a,3) (a,3) ∂L
= = diag 1 − z ⊙ z ,
∂z (a,3) ∂z (a,3) ∂x(a,3) ∂x(a,3)

where 1 denotes the vector (1, 1, · · · , 1)⊤ , and ⊙ denotes the element-wise
multiplication (Hadamard product). For convenience, we omit the dimen-
sion of 1 here, which has the same dimension with z (a,3) . Next, the gradient
with respect to the hidden layer can be obtained using the chain rule:

∂L(a) ∂z (a,3) ∂L(a) ∂L(a)

= = W (2) ,
∂x(a,2) ∂x(a,2) ∂z (a,3) ∂z (a,3)
∂L(a) ∂z (a,3) ∂L(a) ∂L(a) (a,2)⊤
= = x ,
∂W (2) ∂W (2) ∂z (a,3) ∂z (a,3)
∂L(a) ∂z (a,3) ∂L(a) ∂L(a)
= = ,
∂b(2) ∂b(2) ∂z (a,3) ∂z (a,3)
∂L(a) ∂x(a,2) ∂L(a) h  i ∂L(a)
= = diag 1 − z (a,2) ⊙ z (a,2) .
∂z (a,2) ∂z (a,2) ∂x(a,2) ∂x(a,2)

The gradient with respect to the parameters for the input layer is derived
4.1. CLASSICAL NEURAL NETWORKS 121

similarly:

∂L(a) ∂z (a,2) ∂L(a) ∂L(a) (a,1)⊤

= = x ,
∂W (1) ∂W (1) ∂z (a,2) ∂z (a,2)
∂L(a) ∂z (a,2) ∂L(a) ∂L(a)
= = .
∂b(1) ∂b(1) ∂z (a,2) ∂z (a,2)
After multiple training epochs, the loss function converges to a value below
a predefined threshold, which leads to a small classification error.
Compared to single-layer perceptrons, MLP can model non-linear rela-
tionships by employing hidden layers and activation functions. This enables
them to learn abstract representations by capturing the complex patterns
inherent in the data. Mathematically, the power of MLPs is guaranteed
by the universal approximation theorem, as stated in Theorem 4.2, which
asserts that a single hidden layer is sufficient to approximate any arbitrary
continuous function.
Fact 4.2 (Universal Approximation Theorem, informal version adapted
from Hornik et al. (1989)). Let C(X , Rm ) denote the set of continuous func-
tions from a subset X of a Euclidean space Rn to a Euclidean space Rm .
Denote by σ a function that is not polynomial. Then for every n, m ∈ N,
compact set K ⊆ Rn , f ∈ C(K, Rm ), and ϵ > 0, there exist k ∈ N, A ∈ Rk×n ,
b ∈ Rk , and C ∈ Rm×k such that

sup ∥f (x) − g(x)∥ < ϵ,

x∈X

where g(x) = Cσ(Ax + b).

Remark
MLPs involve a large number of parameters due to their fully con-
nected multilayer architecture. This high parameter count enables
MLPs to possess considerable representational power, allowing them
to model complex data distributions. However, the excessive capac-
ity to fit the training data often leads to overfitting (Caruana et al.,
2000), where the MLP captures noise and irrelevant patterns instead
of generalizable features. As a result, MLPs tend to perform poorly
on unseen data, especially when the training set is limited or noisy. To
mitigate this issue, advanced techniques such as dropout (Srivastava
et al., 2014), weight decay (Krogh and Hertz, 1991), and attention
mechanisms (Vaswani, 2017) have been proposed to reduce overfit-
122 CHAPTER 4. QUANTUM NEURAL NETWORKS

ting in MLPs while maintaining sufficient expressivity.

4.2 Fault-tolerant Quantum Perceptron

The primary aim of advancing quantum machine learning is to harness the
computational advantages of quantum mechanics to enhance performance
across various learning tasks. As outlined in Chapter 1.1.2, these advantages
manifest in several ways, including reduced runtime, lower query complexity,
and improved sample efficiency compared to classical models. A notable
example of this is the quantum perceptron model (Kapoor et al., 2016).
As a FTQC-based QML algorithm grounded in the Grover search, quantum
perceptron offers a quadratic improvement in the query complexity during
the training over its classical counterpart. For comprehensiveness, we first
introduce the Grover search algorithm, followed by a detailed explanation
of the quantum perceptron model.

4.2.1 Grover search

Grover search (Grover, 1996) provides runtime speedups for unstructured
search problems, which have broad applications in cryptography, quan-
tum machine learning, and constraint satisfaction problems. Unlike clas-
sical search methods that require O(d) queries for a dataset with d entries,
Grover’s algorithm
√ can identify the target element with high probability us-
ing only O( d) queries to a quantum oracle. Consequently, quantum algo-
rithms incorporating Grover search have the potential to achieve a quadratic
speedup over classical approaches.
In general, a search task can be abstracted as a function f (x) such that
f (x) = 1 if x belongs to the solution set of the search problem, and f (x) = 0
otherwise. We consider a dataset consisting of d = 2N elements, where each
element is represented by the quantum state |x⟩ with x = 0, 1, · · · , d − 1.
In this process, two key quantum oracles are introduced. The first oracle,
U0 = 2(|0⟩⟨0|)⊗N −Id , applies a phase shift of eiπ = −1 to all quantum states
except |0⟩⊗N , which remains unchanged. The second oracle, Uf , operates
in a similar manner: it applies a phase shift of −1 to quantum states that
belong to the solution set while leaving all other states unaffected. The
procedure for Grover search is described in Algorithm 2.

Theorem 4.3 (Time complexity of Grover search). Grover search finds

a solution to the unstructured search problem with high probability in time
4.2. FAULT-TOLERANT QUANTUM PERCEPTRON 123

Algorithm 2 Grover search

Require: Quantum oracles Uf and U0 . The size of the dataset and the
solution set, denoted by d = 2N and M , respectively.
Ensure: An index corresponds to one of the solution states with high prob-
ability.
1: Initialize a register of N qubits with the state of uniform superposition:

d−1 N N
!
1 X O |0⟩ + |1⟩ O
|ϕ0 ⟩ = √ |x⟩ = √ = H |0⟩.
d x=0 n=1
2 n=1
q
2: Let m = ⌊ π4 d
M − 12 ⌋. Apply the following operation:
 m
|ϕm ⟩ = H⊗N U0 H⊗N Uf |ϕ0 ⟩.

3: Measure the state |ϕm ⟩ to generate an index.

q
d
O( M (log d + Tf )), where d is the size of the dataset, M is the size of the
solution set, and Tf denotes the time complexity of implementing the oracle
Uf .
Remark
The Grover search achieves a quadratic speed-up in the query com-
plexity of the oracle Uf . It provides a quantum advantage in the
runtime only√if the time complexity of the oracle Uf , denoted as Tf ,
is less than d.

Proof of Theorem 4.3. Let the superposition of the solution state be

1 X
|target⟩ = √ |x⟩.
M x:f (x)=1

Similarly, the superposition of the states outside the solution set is given by
1 X
|other⟩ = √ |x⟩.
2N − M x|f (x)=0

Thus, the initial uniform superposition state can be expressed as

r r
M 2N − M
|ϕ0 ⟩ = N
|target⟩ + |other⟩ := α0 |target⟩ + β0 |other⟩.
2 2N
124 CHAPTER 4. QUANTUM NEURAL NETWORKS

In principle, the coefficient associated with the target state is expected

to increase during the quantum state evolution, such that the solution could
be obtained through quantum measurement with high probability. The
dynamics of these coefficients can be described as follows:

αk = ⟨target|ϕk ⟩
= ⟨target|H ⊗N U0 H ⊗N Uf |ϕk−1 ⟩
= ⟨target|(2|ϕ0 ⟩⟨ϕ0 | − I)Uf (αk−1 |target⟩ + βk−1 |other⟩)
= ⟨target|(2|ϕ0 ⟩⟨ϕ0 | − I)(−αk−1 |target⟩ + βk−1 |other⟩)


= 1 − 2α02 αk−1 + 2α0 β0 βk−1 ,
βk = ⟨other|ϕk ⟩
= ⟨other|(2|ϕ0 ⟩⟨ϕ0 | − I)(−αk−1 |target⟩ + βk−1 |other⟩)


= 2β02 − 1 βk−1 − 2α0 β0 αk−1 .
q
N
Let the angle θ = arccos 2 2−MN , then by induction, it can be shown that

αk = sin[(2k + 1)θ], βk = cos[(2k + 1)θ].

qO(1), there is a condition (2m + 1)θ ≈

To ensure that the coefficient αm =
N
π/2. Therefore, m = O(1/θ) = O( 2M ) suffices to obtain the solution with
high probability.

4.2.2 Online quantum perceptron with quadratic speedups

As stated in Theorem 4.1, for a linearly separable dataset with a margin γ,
a perceptron model can achieve perfect classification after making O(1/γ 2 )
mistakes during training. In classical approaches, identifying a sample that
is misclassified by the current model may require up to O(d) queries, where
d denotes the size of the training dataset. In contrast, the quantum per-
ceptron model (Kapoor et al., 2016) can identify misclassified samples more
efficiently by employing the Grover search algorithm, achieving a quadratic
speed-up in the query complexity.
To begin, we introduce the setup of the input data. We consider the
classification of a dataset {z (i) }di=1 = {(x(i) , y (i) )}di=1 , where the label y (i) ∈
{−1, 1}. For convenience, we assume that the number of samples is a power
of 2, i.e., d = 2N . Each data vector x(i) is assumed to be represented by
using B bits. The information of each sample z (i) is stored in the quantum
state |z (i) ⟩ by using B + 1 qubits.
4.2. FAULT-TOLERANT QUANTUM PERCEPTRON 125

Example 4.4. For the sample (x(i) , y (i) ) = ([0, 0, 1, 0], 1), the corre-
sponding quantum state is |z (i) ⟩ = |00101⟩, where the last qubit encodes
the label (with “0” for the label “−1”), and the remaining qubits repre-
sent the data vector. When x(i) is a float vector, a similar bit sequence
can be obtained by concatenating the binary representations of the ele-
ments in x(i) .

Next, we introduce the oracle models. We assume the existence of a

quantum oracle U for encoding training data as the corresponding quantum
state, i.e.,
U |i⟩|0⟩ = |i⟩|z (i) ⟩ , U † |i⟩|z (i) ⟩ = |i⟩|0⟩. (4.15)
Due to the linearity of unitary,
d−1
X d−1
X
1 1
U √ |i⟩|0⟩ = √ |i⟩|z (i) ⟩. (4.16)
i=0
d i=0
d
In addition to the input oracle U described in Eqn. (4.15), the quantum
perceptron model employs another oracle to distinguish between correctly
′ sat-
classified and misclassified quantum states. Specifically, the oracle Fw
isfies
′ (i) )
Fw |z (i) ⟩ = (−1)f (w,z |z (i) ⟩, (4.17)

where f : (w, z (i) ) → {0, 1}. The function outputs 1 if the current percep-
tron model with weight w misclassifies the training sample z (j) ; otherwise,
it outputs 0. Furthermore, we define
Fw = U † (I ⊗ Fw
′
)U, (4.18)
which is used as the oracle Uf in the Grover search. The online quantum
perceptron procedure is given in Algorithm 3. The query complexity of the
online quantum perceptron is provided in Theorem 4.5.
Theorem 4.5 (Online quantum perceptron (Kapoor et al., 2016)). Consider
a training dataset that consists of unit vectors {x(1) , · · · , x(d) } and labels
{y (1) , · · · , y (d) } with a margin γ, Denote by nquant the number of queries to
Fw needed to learn the weight w, such that the training dataset is perfectly
classified with probability at least 1 − ϵ, then
√ !
d 1
nquant ∈ O log 2 .
γ2 γ ϵ
126 CHAPTER 4. QUANTUM NEURAL NETWORKS

Algorithm 3 Online quantum perceptron

Require: Linearly separable dataset {z (i) }di=1 = {(x(i) , y (i) )}di=1 , where d =
2N . Margin threshold γ. Constants ϵ ∈ (0, 1) and c ∈ (1, 2).
Ensure: Weight w for a perceptron that correctly classifies the dataset with
a margin γ with probability at least 1 − ϵ.
1: Initialize the weight w = 0.
2: for h = 1, · · · , ⌈ γ12 ⌉ do
3: for k = 1, · · · , ⌈log3/4 γ 2 ϵ⌉ do
1
4: for j = 1, · · · , ⌈logc sin(2 sin−1 √
(1/ d))
⌉ do
5: Draw m uniformly from {0, · · · , ⌈cj ⌉ − 1}.
6: Prepare the quantum state
d−1
1 X
|ϕ0 ⟩ = √ |i⟩.
d i=0

7: Generate the state

|ϕ1 ⟩ = {[(2|ϕ0 ⟩⟨ϕ0 | − Id ) ⊗ Id ]Fw }m |ϕ0 ⟩|0⟩⊗N .

8: Measure the first register of the state |ϕ1 ⟩ to obtain an out-

come q.
9: if f (w, z (q) ) = 1 then
10: Update w ← w + y (q) x(q) .
11: end if
12: end for
13: end for
14: end for
15: Output w.
4.2. FAULT-TOLERANT QUANTUM PERCEPTRON 127

For the classical case where the training vectors are uniformly sampled from
the training dataset, the number of queries to fw is bounded by
 
d 1
Ω(d) ∋ nclass ∈ O 2 log 2 .
γ γ ϵ

Proof of Theorem 4.5. The main idea of the quantum perceptron model in
Algorithm 3 is to replace the procedure of finding the misclassified sample
in classical perceptrons with the Grover search. Due to convergence result
for perceptrons in Theorem 4.1, h = 1, · · · , ⌈ γ12 ⌉ iterations of Steps (3-13)
suffice to update the weight w towards the case of perfect classification.
Therefore, Theorem 4.5 is the direct consequence of the following lemmas
and Theorem 4.1. The query complexity of classical perceptrons has the
lower bound Ω(d), since the model needs to go through the entire dataset
in the worst case.

Lemma 4.6. Given only uniform sampling access to the training dataset,
there exists a classical perceptron that either finds a misclassified sample to
update the weight w or concludes that no such example exists with probability
1 − ϵγ 2 , using O(d log(1/ϵγ 2 )) queries to fw .

Lemma 4.7. The procedure of Steps 3-13 in Algorithm 3 either finds a mis-
classified sample to update the weight w√or concludes that no such example
exists with probability 1 − ϵγ 2 , using O( d log(1/ϵγ 2 )) queries to Fw .

Proof of Lemma 4.6. First, let mc = d⌈log(1/ϵγ 2 )⌉ be the number of sam-

ples drawn from the dataset uniformly in each iteration of training. Suppose
these samples are classified correctly, then the probability that the entire
dataset is classified correctly is
   m 
1 mc c
Pr(Correct classification) ≥ 1 − 1 − ≥ 1 − exp − ≥ 1 − ϵγ 2 .
d d

q
Proof of Lemma 4.7. For convenience, denote θa := arccos d−d d , where d0
0

the number of misclassified samples in the dataset according to the current

1
model. Let d1 := ⌈logc sin(2 sin−1 √
(1/ d))
⌉. Here, an exponential expansion
strategy is used in Steps 4-12 to handle the scenario of unknown d0 . Namely,
quantum operations in the Grover search are repeated for m times, where m
is drawn from an exponentially expanded set 0, · · · , ⌈cj ⌉ − 1 uniformly for
128 CHAPTER 4. QUANTUM NEURAL NETWORKS

a predefined c ∈ (1, 2) and j = 1, · · · , d1 . It can be shown that this strategy

can find a misclassified sample before the convergence of Algorithm 3 with
an average probability at least 1/4:

  Xd1 ⌈cj ⌉−1

(q) 1 X
Pr f (w, z ) = 1 = sin2 ((2m + 1)θa )
⌈cj ⌉
j=1 m=0
⌈cd1 ⌉−1
1 X
≥ d
sin2 ((2m + 1)θa )
⌈c 1 ⌉
m=0
 
1 sin(4⌈cd1 ⌉θa )
= 1−
2 2⌈cd1 ⌉ sin(2θa )
1
≥ .
4
The procedure of Steps 4-12 is repeated for k = 1, · · · , ⌈log3/4 γ 2 ϵ⌉ iter-
ations to accumulate the success probability. The probability of finding a
misclassified sample in Steps 3-13 before the convergence of Algorithm 3 is
at least
  2
1 ⌈log3/4 ϵγ ⌉
1− 1− ≥ 1 − ϵγ 2 . (4.19)
4
Finally, the query complexity Q of Steps 3-13 in Algorithm 3 can be
upper bounded as follows:
⌈log3/4 γ 2 ϵ⌉ d1
X X
Q≤ cj
k=1 j=1
  c h i
≤ 1 + log3/4 γ 2 ϵ 1 − cd1
1−c
  c2  1

2
≤ 1 + log3/4 γ ϵ √ −1
c − 1 sin(2 sin−1 (1/ d))
√ 1
= O( d log 2 ).
ϵγ

4.3 Near-term Quantum Neural Networks

Following recent experimental breakthroughs in superconducting quantum
hardware architectures (Arute et al., 2019; Acharya et al., 2024; AbuGhanem,
4.3. NEAR-TERM QUANTUM NEURAL NETWORKS 129

|0⟩

|0⟩
Udata (ρin ) V (θ)
|0⟩

|0⟩

Figure 4.4: Illustration of a QNN. The input state ρin is prepared using
the operation Udata , followed by a variational quantum circuit (VQC) V (θ)
and the measurement operation.

2024; Gao et al., 2024), researchers have devoted considerable effort to devel-
oping and implementing quantum machine learning algorithms optimized for
current and near-term quantum devices (Wang and Liu, 2024). Compared to
fault-tolerant quantum computers, these devices face three primary limita-
tions: quantum noise, limited coherence time, and circuit connectivity con-
straints. Regarding quantum noise, state-of-the-art devices have single-qubit
gate error rates of 10−4 ∼ 10−3 and two-qubit gate error rates of approxi-
mately 10−3 ∼ 10−2 (AbuGhanem, 2024; Gao et al., 2024). The coherence
time is around 102 µs (Acharya et al., 2024; AbuGhanem, 2024; Gao et al.,
2024), primarily limited by decoherence in noisy quantum channels. Regard-
ing circuit connectivity, most superconducting quantum processors employ
architectures that exhibit two-dimensional connectivity patterns and their
variants (Acharya et al., 2024; AbuGhanem, 2024; Gao et al., 2024). Gate
operations between non-adjacent qubits must be executed through interme-
diate relay operations, leading to additional error accumulation. To address
these inherent limitations, the quantum neural network (QNN) framework
has been proposed. Specifically, these QNNs are designed to perform mean-
ingful computations on near-term quantum devices.

4.3.1 General framework

In this section, we introduce the basic architecture of QNNs. As illustrated
in Figure 4.4, a basic QNN consists of three components: the input, the
130 CHAPTER 4. QUANTUM NEURAL NETWORKS

Uent Uent

Figure 4.5: Illustration of a hardware-efficient circuit with two en-

tanglement layers.

model circuit, and the measurement.

Input. The QNN uses quantum states ρin as input data. As shown in Ta-
ble 4.2, QNNs can process both classical and quantum data. Specifically, the
input states ρin may be introduced from physical processes such as quantum
Hamiltonian evolutions or be constructed to encode classical vectors using
encoding protocols introduced in Chapter 2.3.1, such as angle encoding and
amplitude encoding.
Model circuit. QNNs employ variational quantum circuits (VQCs), a.k.a,
ansatzes, to extract and learn features from input data. A typical VQC, de-
noted as V (θ), adopts a layered architecture that consists of both parameter-
ized and fixed quantum gates, with the former being trainable. For problem-
agnostic implementations, an effective parameterization strategy is to use
the parameters θ as the phases of single-qubit rotation gates RX, RY, RZ,
while quantum entanglement is introduced through fixed two-qubit gates,
such as CX and CZ. Standard circuit architectures include the hardware-
efficient circuit (HEC) (Kandala et al., 2017a), shown in Figure 4.5, and the
quantum convolutional neural network (QCNN) (Cong et al., 2019), shown
in Figure 4.6. For problem-specific applications, such as finding the ground
states of molecular Hamiltonians, specialized circuits like the unitary cou-
pled cluster ansatz (Peruzzo et al., 2014) are employed.

Example 4.8. Hardware-efficient circuits incorporate several widely

adopted ansatzes. Single-qubit rotations {RX, RY, RZ} are used to con-
struct parameterized single-qubit unitaries. The entangled unitary layer
4.3. NEAR-TERM QUANTUM NEURAL NETWORKS 131

Figure 4.6: Illustration of a quantum convolutional neural network.

Table 4.2: Examples of classical and quantum data employed in QNNs,

where H denotes the system Hamiltonian, kB is the Boltzmann constant,
and |ϕ0 ⟩ is a predefined initial state.
Example Input state formulation
NN
Angle encoding [RY(xn )|0⟩]
Classical data Pn=1
d−1
Amplitude encoding i=0 xi /∥x∥2 |i⟩
exp(−H/kB T )
Gibbs state Tr[exp(−H/kB T )]
Quantum data
Hamiltonian evolution exp(−iHt)|ϕ0 ⟩
132 CHAPTER 4. QUANTUM NEURAL NETWORKS

can be implemented using two-qubit gates such as

N
⌈2⌉
O
Uent = U (2n − 1 + k%2, 2n + k%2) for the k-th layer,
n=1
⌈N ⌉ ⌈ N 2−1 ⌉
O2 O
Uent = U (2n − 1, 2n) U (2n, 2n + 1),
n=1 n=1

where U ∈ {CX, CZ}.

Measurement. After implementing the model circuit, the quantum state is

measured using specific observables, denoted as O, to extract classical infor-
mation. The choice of observables depends on the experimental objectives.
In the case of a variational quantum eigensolver, where the goal is to find the
ground state and energy of a given Hamiltonian, the observable is chosen to
be the target Hamiltonian itself. In quantum machine learning applications
involving classical data, the measurement outcomes are used to approximate
label information, which typically lacks direct physical significance. As a re-
sult, the observable can, in principle, be any Hermitian operator. However,
for practical experimental considerations, a linear combination of Pauli-Z
operators is commonly used as the observable:
N
X
O= cj I⊗(j−1) ⊗ Zj ⊗ I⊗(N −j) , (4.20)
j=1

where c ∈ RN is a weight vector. The measurement outcome of QNN can

be expressed as a function of θ, i.e.,
h i
f (θ; ρin , V, O) = Tr OV (θ)ρin V (θ)† . (4.21)

Training of QNNs. As a QML framework, the optimization of QNNs

amounts to updating parameters θ using gradient-based methods. Due to
the linearity of quantum mechanics and the unitary evolution constraint, for
certain cases, the acquisition of gradients can be elegantly performed using
the parameter-shift rule.
Theorem 4.9 (Parameter-shift rule (Crooks, 2019)). Suppose the gate Gj (θj )
in a VQC V (θ) has a unitary Hamiltonian Hj , then the corresponding gra-
dient could be obtained as
∂f 1h  π   π i
(θ) = f θ + e(j) − f θ − e(j) ,
∂θj 2 2 2
4.3. NEAR-TERM QUANTUM NEURAL NETWORKS 133

where the function f follows the Eqn. (4.21) and the one-hot vector e(j) has
the same dimension with θ with the j-th element being 1.

Proof of Theorem 4.9. For convenience, we denote the detailed structure of

VQC as
1
Y
V (θ) = Gi (θi )Wi ,
i=L

where L is the number of parameters in VQC, Gi is the parameterized gate,

and Wi is the fixed gate. By assumption, the gate takes the form as

Gj (θj ) = exp(−iHj θj /2),

where the Hamiltonian Hj is a unitary. For convenience, unnecessary param-

eterized and fixed gates can be merged into the state ρin and the observable
O, i.e.,

  !
1
Y j−1
Y
ρ′in = Wj  Gi (θi )Wi ρin Wi† Gi (θi )† Wj† ,
i=j−1 i=1
  !
L
Y j
Y
O′ =  Wi† Gi (θi )† O Gi (θi )Wi .
i=j i=L

It can be shown that

h i
f (θ) = Tr OV (θ)ρin V (θ)†
h i
= Tr O′ Gj (θj )ρ′in Gj (θj )†
 
= Tr O′ exp(−iHj θj /2)ρ′in exp(iHj θj /2)
θj  ′ ′  i   θj  
= cos2 Tr O ρin + sin θj [Hj , O′ ]ρ′in + sin2 Tr Hj O′ Hj ρ′in ,
2 2 2
(4.22)

where [A, B] := AB − BA denotes the commutator.

134 CHAPTER 4. QUANTUM NEURAL NETWORKS

After some calculations from Eqn. (4.22), it can be shown that

 π  1 − sin θ   i  
j
f θ + e(j) = Tr O′ ρ′in + cos θj [Hj , O′ ]ρ′in
2 2 2
1 + sin θj  
+ Tr Hj O Hj ρ′in
′
2
 π (j)  1 + sin θj  ′ ′  i  
f θ− e = Tr O ρin − cos θj [Hj , O′ ]ρ′in
2 2 2
1 − sin θj  
+ Tr Hj O′ Hj ρ′in
2
∂f 1   i  
(θ) = − sin θj Tr O′ ρ′in + cos θj [Hj , O′ ]ρ′in
∂θj 2 2
1  
+ sin θj Tr Hj O′ Hj ρ′in .
2
Comparing the above equations, Theorem 4.9 is proved.

4.3.2 Discriminative learning with QNNs

In this section, we present an example in which a QNN is employed for
discriminative learning. Specifically, we focus on binary classification, where
the label y (i) = ±1 corresponds to the input state ρ(i) . In the case of classical
data, the state ρ(i) = |ψ(x(i) )⟩⟨ψ(x(i) )| can be generated from the classical
vector x(i) using a read-in approach

|ψ(x(i) )⟩ = Uϕ (x(i) )|0⟩, (4.23)

where a simple feature map can be constructed via angle encoding, as in-
troduced in Chapter 2.3.1,
N
O N
O
(i)
Uϕ (x ) = RY(x(i)
n ) = exp(−iY x(i)
n /2). (4.24)
n=1 n=1

Denote by O and V (θ) the quantum observable and the VQC, respectively.
The prediction function of the QNN is given by

ŷ (i) (θ) = Tr[OV (θ)ρ(i) V (θ)† ]. (4.25)

In the binary classification task, the QNN learns by training the param-
eter θ to minimize the distance between the label y (i) and the prediction
4.3. NEAR-TERM QUANTUM NEURAL NETWORKS 135

ŷ (i) (θ). Specifically, the mean square error (MSE) is used as the loss func-
tion:

1 X (i) 2
n
X n
∗ (i) (i)
θ = argminL(θ), where L(θ) = ℓ(θ, x , y ) = ŷ (θ) − y (i) .
2
i=1 i=1
(4.26)
The gradient of the loss in Eqn. (4.26) can be calculated via the chain rule,
i.e.,
Xn  
∇θ L(θ) = ŷ (i) (θ) − y (i) ∇θ ŷ (i) (θ), (4.27)
i=1

where the gradient of the prediction ŷ (i) can be obtained by using the
parameter-shift rule in Theorem 4.9. Consequently, a variety of gradient-
based optimization algorithms, such as stochastic gradient descent (Amari,
1993), Adagrad (Duchi et al., 2011), and Adam (Kingma, 2014), can be
employed to train QNNs.

Remark
The QNN binary classification framework can be naturally extended
to multi-label classification using the one-vs-all strategy. Specifi-
cally, we train k QNN binary classifiers for k classes, with each clas-
sifier distinguishing a specific class from the others.

Remark
The QNN classification framework presented in this section can be
extended to quantum regression learning by incorporating continuous
labels.

4.3.3 Generative learning with QNNs

In this section, we introduce a quantum generative model implemented by
QNNs, namely quantum generative adversarial network (QGAN) (Lloyd and
Weedbrook, 2018). Similar to its classical counterparts, QGAN learns to
generate samples by employing a discriminator and a generator, which are
engaged in a two-player minimax game. Specifically, both the discriminator
D and the generator G can be implemented using QNNs. By leveraging
the expressive power of QNNs, QGAN has the potential to exhibit quantum
advantages in certain tasks (Bravyi et al., 2018; Zhu et al., 2022).
136 CHAPTER 4. QUANTUM NEURAL NETWORKS

|0⟩ (α1 ) U (θℓ,1 )

Ancillary
for G |0⟩ (α2 ) U (θℓ,2 )

|0⟩ (α3 ) U (θℓ,3 )

|0⟩ (α4 ) U (θℓ,4 )

Sample
Register
|0⟩ (α5 ) U (θℓ,5 )

|0⟩ (α6 ) U (θℓ,6 )

Uz UGt (θ), repeat for ℓ ∈ [L]

Figure 4.7: The quantum generator used in the quantum patch

GAN, where each U (θℓ,n ) ∈ U(2) is a trainable single-qubit unitary.

To illustrate the training and sampling processes of QGAN, we present

two examples based on the quantum patch and batch GANs proposed by
Huang et al. (2021b). Let N denote the number of qubits and M the num-
ber of training samples. The patch and batch strategies are designed for the
cases where N < ⌈log M ⌉ and N > ⌈log M ⌉, respectively. Specifically, the
patch strategy enables the generation of high-dimensional images with lim-
ited quantum resources, while the batch strategy facilitates parallel training
when sufficient quantum resources are available.

Quantum patch GAN

We begin by introducing the quantum patch GAN, which consists of a quan-

tum generator, as illustrated in Figure 4.7, a classical discriminator, and a
classical optimizer. Both the learning and sampling processes of an image
are performed in patches, involving T sub-generators. For the t-th sub-
generator, the model takes a latent state z as input and generates a sample
Gt (z). Specifically, the latent state is prepared from the initial state |0⟩⊗N
using a single-qubit rotation layer, where the parameters {αn }N n=1 are sam-
pled from the uniform distribution over [0, 2π). The latent state is then
processed through an N -qubit hardware-efficient circuit UGt (θ), which leads
to the state
|ψt (z)⟩ = UGt (θ)|z⟩. (4.28)
4.3. NEAR-TERM QUANTUM NEURAL NETWORKS 137

To perform non-linear operations, partial measurements are conducted,

and a subsystem A (ancillary qubits) is traced out from the state |ψt (z)⟩.
The resulting mixed state is

TrA [Π ⊗ I|ψt (z)⟩⟨ψt (z)|]

ρt (z) = , (4.29)
Tr[Π ⊗ I|ψt (z)⟩⟨ψt (z)|]

where Π is the projective operator acting on the subsystem A. Subsequently,

the mixed state ρt (z) is measured in the computational basis to obtain
the sample Gt (z). Specifically, let Pr(J = j) := Tr[|j⟩⟨j|ρt (z)], where the
probabilities of the outcomes can be estimated by the measurement. The
sample Gt (z) is then defined as

Gt (z) = [Pr(J = 0), · · · , Pr(J = j), · · · , Pr(J = 2N −NA − 1)], (4.30)

where NA is the number of qubits in A. Finally, the complete image is re-

constructed by aggregating these samples from all sub-generators as follows:

G(z) = [G1 (z), · · · , GT (z)]. (4.31)

In principle, the discriminator D in a quantum patch GAN can be any

classical neural network that takes the training data x or the generated
sample G(z) as input, with the output

D(x), D(G(z)) ∈ [0, 1]. (4.32)

Let γ and θ denote the parameters of the discriminator D and the generator
G, respectively. The optimization problem for the quantum patch GAN can
be formulated as:

min max L(Dγ (Gθ (z)), Dγ (x)) := E[log Dγ (x)] + E[log(1 − Dγ (Gθ (z)))].
θ γ x z
(4.33)

Similar to quantum discriminative learning, the quantum patch GAN can

be trained using gradient-based optimization algorithms.

Quantum batch GAN

As illustrated in Figure 4.8, the quantum batch GAN differs from the quan-
tum patch GAN by employing a quantum discriminator. In a quantum
batch GAN, all qubits are divided into two registers: the index register,
consisting of NI qubits, and the feature register, consisting of NF qubits.
138 CHAPTER 4. QUANTUM NEURAL NETWORKS

|0⟩
Index
Register
|0⟩

|0⟩
Ancillary
Uz
for G |0⟩
UG (θ)
|0⟩
Sample
Register
|0⟩
UD (γ)
|0⟩
Ancillary
for D |0⟩

Figure 4.8: The main structure of the quantum batch GAN. The
figure illustrates the process of generation and training using fake data.
The oracle Uz for encoding latent vectors, the quantum generator UG (θ),
and the quantum discriminator UD (γ) are applied sequentially to the initial
state |0⟩⊗N . Both UG and UD share the same hardware-efficient structure as
shown in Figure 4.7. In the case of real data, the operations Uz and UG (θ)
are replaced by the oracle Ux .

The qubits in the feature register are further partitioned into three parts:
ND qubits for generating quantum samples, NAG qubits for implementing
non-linear operations in the generator Gθ , and NAD qubits for implement-
ing non-linear operations in the discriminator Dγ . For a batch with size
|Bk | = 2NI , two oracles are used to encode the information of latent vectors
and training samples:

U 1 X
z
|0⟩I ⊗ |0⟩F −−→ |i⟩I ⊗ |z (i) ⟩F , (4.34)
2NI
i
U 1 X
x
|0⟩I ⊗ |0⟩F −−→ |i⟩I ⊗ |x(i) ⟩F . (4.35)
2NI
i
4.3. NEAR-TERM QUANTUM NEURAL NETWORKS 139

Remark
For data with M features, state preparation for amplitude encoding
in Ux requires Õ(2NI M ) multi-controlled quantum gates, which is in-
feasible for current quantum devices. This challenge can be addressed
by employing pre-trained shallow circuit approximations of the given
oracle (Benedetti et al., 2019a).

After the encoding stage, a PQC UG (θ) and the corresponding partial
measurement are employed as the quantum generator. Thus, the generated
state corresponding to |Bk | fake samples is obtained as follows:

1 X
|i⟩I ⊗ |z (i) ⟩F
2NI
i
UG (θ) 1 X  
−−−−→ |i⟩I ⊗ UG (θ) ⊗ I2NAD |z (i) ⟩F := |ψ(z)⟩
2NI
i
ΠAG
I2NI ⊗ ΠAG ⊗ I2ND +NAD |ψ(z)⟩
−−−→ h i := |Gθ (z)⟩,
Tr I2NI ⊗ ΠAG ⊗ I2ND +NAD |ψ(z)⟩⟨ψ(z)|

where the partial measurement ΠAG = (|0⟩⟨0|)⊗NAG serves as the non-linear

operation. In the sampling stage, the reconstructed image is generated sim-
ilarly to the quantum patch GAN. Specifically, the i-th image Gθ (z (i) ) in
the batch is

 
Gθ (z (i) ) = Pr(J = 0|I = i), · · · , Pr(J = 2ND − 1|I = i) , (4.36)

where

Pr(J = j|I = i) = Tr[|i⟩I |j⟩F ⟨i|I ⟨j|F |G(z)⟩⟨G(z)|]. (4.37)

Finally, we introduce the training stage. A quantum discriminator is

applied to either the fake generated state |Gθ (z)⟩ or the real data state |x⟩.
Similar to the quantum generator, the quantum discriminator Dγ consists
of a PQC UD (γ), followed by the corresponding partial measurement. In
140 CHAPTER 4. QUANTUM NEURAL NETWORKS

the case of the real state, the state evolution proceeds as follows:
1 X
|i⟩I ⊗ |x(i) ⟩F
2NI
i
UD (γ) 1 X  
−−−−→ N |i⟩I ⊗ I2NAG ⊗ UD (γ)|x(i) ⟩F := |ψ(x)⟩
2 I
i
ΠA I N −NAD ⊗ ΠAG |ψ(x)⟩
−−−D
→ h 2 i := |Dγ (x)⟩,
Tr I2N −NAD ⊗ ΠAG |ψ(x)⟩⟨ψ(x)|

where the partial measurement is ΠAG = (|0⟩⟨0|)⊗NAD . The classical de-

scription Dγ (x) is generated similarly to Eqn. (4.36). The generated state
Gθ |z⟩ undergoes the same procedure to obtain the description Dγ (Gθ (z)).
These classical vectors are then used in the loss function in Eqn. (4.33) to
train parameters θ and γ.

4.4 Theoretical Foundations of Quantum Neural

Networks
The primary goal of QNNs is to make accurate predictions on unseen data.
Achieving this goal depends on three key factors: expressivity, generalization
ability, and trainability, as illustrated in Figure 4.9. A thorough analysis of
these factors is crucial for understanding the potential advantages and lim-
itations of QNNs compared to classical counterparts. Instead of providing
an exhaustive review of all theoretical results, this section focuses on em-
phasizing key conceptual insights of QNNs.
As explained in Chapter 3.3, expressivity refers to a model’s ability to
represent a wide range of functions, determining the smallest achievable
training error. In Chapter 4.4.1, we will characterize the expressivity of
QNNs using the covering number, an advanced tool from statistical learning
theory. This analysis will reveal the relationship between the expressivity of
QNNs and their structural factors, such as the size of the quantum system
and the number of exploited quantum gates. Understanding this connection
helps clarify how QNNs’ expressivity scales with their architecture.
Generalization ability evaluates the discrepancy between a model’s per-
formance on the training data and on unseen test data. In Chapter 4.4.1, we
will further explore the relationship between the generalization ability and
expressivity of QNNs by deriving a generalization error bound in terms of
the covering number. This bound provides insights into how the expressiv-
ity of QNNs–specifically their structural factors–may impact their ability to
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS141

𝛁ℒ ℋ
𝜽(𝟎) Grad info
𝝐 Target function

Optimal Optimal ⋯
𝜽∗
𝜽∗
𝜽(𝑻) Optimization path

Figure 4.9: Overview of the expressivity, generalization ability, and

trainability of QNNs. The expressivity of the employed QNNs determines
its hypothesis space H (solid blue ellipse). When H has a moderate size and
encompasses the target concept (solid red star), QNNs can achieve good
performance. Conversely, if H fails to cover the target concept (solid gray
star) due to limited expressivity, the performance of QNNs deteriorates.
During QNN optimization, a significant challenge arises from the vanishing
gradient problem, commonly referred to as the barren plateau. This issue
prohibits a good estimation near the target parameters θ ∗ .

generalize and offers a framework to assess their potential advantages over

classical ML models.

While expressivity and generalization ability are crucial for both quan-
tum kernels and QNNs, trainability emerges as an additional consideration
for QNNs due to the introduction of trainable parameters in quantum cir-
cuits. This leads to fundamentally different optimization challenges, where
many existing results from classical ML models no longer apply. Specifi-
cally, trainability refers to a model’s ability to efficiently converge to a good
solution during training, directly influencing the computational cost of train-
ing. In Chapter 4.4.2, we will introduce a well-known challenge in training
QNNs, referred to as the barren plateau problem, where gradients vanish
exponentially as the system size increases, making optimization intractable.
Additionally, we will discuss various strategies to address this issue, offering
practical insights into enhancing the trainability of QNNs.
142 CHAPTER 4. QUANTUM NEURAL NETWORKS

4.4.1 Expressivity and generalization of quantum neural net-

works
The expressivity and generalization are deeply interconnected within the
framework of statistical learning theory for understanding the prediction
ability of any learning model. To better understand these two terms in
the context of quantum neural networks, we first review the framework
of empirical risk minimization (ERM), which is a popular framework for
analyzing these abilities in statistical learning theory.
Consider the training dataset D = {(x(i) , y (i) )}ni=1 ∈ X × Y sampled
independently from an unknown distribution P, a learning algorithm A aims
to use the dataset D to infer a hypothesis hθ∗ : X → Y from the hypothesis
space H that could accurately predict all labels of x ∈ X following the
distribution P. This amounts to identifying an optimal hypothesis in H
minimizing the expected risk

R(h) = E(x,y)∼P ℓ(hθ∗ (x), y), (4.38)

where ℓ(·, ·) refers to the per-sample loss predefined by the learner. Unfortu-
nately, the inaccessible distribution P forbids us to assess the expected risk
directly. In practice, A alternatively learns an empirical hypothesis hθ̂ ∈ H,
as the global minimizer of the (regularized) loss function
n
1X
L(θ, D) = ℓ(hθ (x(i) ), y (i) ) + R(θ), (4.39)
n
i=1

where R(θ) refers to an optional regularizer, as will be detailed in the follow-

ing. Moreover, the first term on the right-hand side refers to the empirical
risk
n
1X
RERM (hθ̂ ) = ℓ(hθ̂ (x(i) ), y (i) ), (4.40)
n
i=1

which is also known as the training error. To address the intractability of

R(hθ̂ ), one can decompose it into two measurable terms,

R(hθ̂ ) = RERM (hθ̂ ) + RGene (hθ̂ ), (4.41)

where RGene (hθ̂ ) = R(hθ̂ ) − RERM (hθ̂ ) refers to the generalization error. In
this regard, achieving a small prediction error requires the learning model
to achieve both a small training error and a small generalization error.
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS143

An overview

Before moving to analyze the training error (ERM) and generalization error
of QNNs rigorously, we first delve into better understanding the meaning of
expressivity and generalization ability of the learning models with the ERM
framework and try to give an intuition about the necessitates and benefits
of exploring such theoretical aspects of QNNs as a special learning model.
In particular, the expressivity could be directly understood as the size
of the hypothesis space H = {hθ : θ ∈ Θ} related to the learning model.
Intuitively, the achievable smallest empirical risk is determined by the ex-
pressivity of learning models. Specifically, a learning model with low ex-
pressivity may not fit the training data with complex patterns, e.g., the
hypothesis space of linear model H = {hθ = θ · x} cannot fit the nonlinear
data {x(i) , (x(i) )2 } perfectly.
In general, the cardinality of the hypothesis space is infinity, as the pa-
rameters θ are continuous. This makes it hard to compare the expressivity
of different learning models. An alternative measure is model complexity,
which measures the richness of the hypothesis space through the structural
factors of the specific learning models, such as the number of parameters,
depth, or architectural design. Remarkably, model complexity is measur-
able and bounded. In this tutorial, we will employ the covering number to
measure the model complexity of QNNs later.
The generalization capability of learning models is directly measured by
the generalization error RGene in Eqn. (4.41). A good generalization ability
means that the learning model predicts well on unseen data as well as on
the training data. In this regard, a small generalization error with a small
training error implicates a small prediction error, as a small generalization
error guarantees that the prediction performance is as well as the training
performance.
In statistical learning theory, it has been well-established that a bias-
variance trade-off governs the interplay between model complexity and gen-
eralization performance for any learning model, highlighting the delicate
balance required for a model to generalize well to unseen data. The rela-
tionship is often depicted by a U-shaped curve, as shown in Figure 4.10.
This curve suggests that there exists an optimal level of model complexity
for improving the generalization ability of any learning model. When under
the point related to optimal expressivity, increasing model complexity im-
proves performance on training data and enhances generalization. However,
beyond a certain point, higher complexity leads to overfitting, resulting in
poor generalization on test data. For QNNs, identifying this optimal level
144 CHAPTER 4. QUANTUM NEURAL NETWORKS

Underfitting Overfitting

Best fit

Error

Model Complexity

Figure 4.10: Influence of model complexity on generalization error.

of complexity is crucial for achieving the best balance between training per-
formance and generalization.

Expressivity of QNNs
In this chapter, we analyze the generalization error of QNNs through a spe-
cific measure of model complexity: the covering number. By leveraging this
measure, we aim to understand better and characterize the generalization
performance of QNNs.
To elucidate the specific definition of the covering number, we first re-
N N
view the general structures of QNNs. Define ρ ∈ C2 ×2 as the N -qubit
N N
input quantum states, O ∈ C2 ×2 as the quantum observable, U (θ) =
QN g N
l=1 ul (θ) ∈ U(2 ) as the applied ansatz, where θ ∈ Θ are the trainable
parameters living in the parameter space Θ, ul (θ) ∈ U(2k ) refers to the
l-th quantum gate operated with at most k-qubits with k ≤ N , and U(2N )
stands for the unitary group in dimension 2N . In general, U (θ) is formed by
Ngt trainable gates and Ng − Ngt fixed gates, e.g., Θ ⊂ [0, 2π)Ngt . Under the
above definitions, the explicit form of the output of QNN under the ideal
scenarios is  
h(θ, O, ρ) := Tr U (θ)† OU (θ)ρ . (4.42)

Given the training data set D = {(ρ(i) , y (i) )}ni=1 and loss function L(θ, D)
defined in Eqn. (4.39), QNN is optimized to find a good approximation
h∗ (θ, O, ρ) = arg minh(θ,O,ρ)∈H L(θ, D) that can well approximate the target
concept, where H refers to the hypothesis space of QNNs with
n   o
H = Tr U (θ)† OU (θ)ρ θ ∈ Θ . (4.43)
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS145

An intuition about how the hypothesis space H affects the performance

of QNNs is depicted in Figure 4.9. When H has a modest size and covers
the target concepts, the estimated hypothesis could well approximate the
target concept. By contrast, when the complexity of H is too low, there
exists a large gap between the estimated hypothesis and the target concept.
An effective measure to evaluate the complexity of H is covering number,
an advanced tool broadly used in statistical learning theory, to bound the
complexity of H and measure the expressivity of QNNs.

Figure 4.11: The geometric intuition of covering number. Covering

number concerns the minimum number of spherical balls with radius ϵ that
occupy the whole space.

Definition 4.10 (Covering number). The covering number N (U, ϵ, ∥ · ∥)

denotes the least cardinality of any subset V ⊂ U that covers U at scale ϵ
with a norm ∥ · ∥, i.e., supA∈U minB∈V ∥A − B∥ ≤ ϵ. Here we use this notion
to measure the expressivity of QNNs.

The geometric interpretation of the covering number is depicted in Fig-

ure 4.11, which refers to the minimum number of spherical balls with radius
ϵ that are required to completely cover a given space with possible overlaps.
This notion has been employed to study other crucial topics in quantum
physics such as Hamiltonian simulation and entangled states. Note that ϵ
is a predefined hyper-parameter, i.e., a small constant with ϵ ∈ (0, 1), and
is independent of any factor. This convention has been broadly adopted in
the regime of machine learning to evaluate the model capacity of various
learning models.
Following the convention of Du et al. (2022c), we now give a step-by-
step analysis of the model complexity of the hypothesis space H of QNNs
defined in Eqn. (4.43). We will show that the covering number of QNNs is
controlled by their structural factors, including the number of parameterized
146 CHAPTER 4. QUANTUM NEURAL NETWORKS

gates Ngt , the number of qubits k the gates acting on, and the type of the
quantum observable O. In the end, we first look at a simpler hypothesis
space consisting of the operator group
n o
Hcirc := U (θ)† OU (θ) θ ∈ Θ , (4.44)

where we remove the factor of input states ρ compared to the hypothesis

space H related to QNNs. Actually, the covering number of H under the
metric d could be connected to the covering number of Hcirc under the
related metric dcirc through employing their Lipschitz properties, which is
encapsulated in the following Fact.

Fact 4.11. Let (H1 , d1 ) and (H2 , d2 ) be two metric spaces satisfying f :
H1 → H2 be bi-Lipschitz such that

cl d1 (x, z) ≤ d2 (f (x), f (z)) ≤ cr d1 (x, z), ∀x, z ∈ H1 . (4.45)

Then their covering number obey

N (H1 , 2ϵ/cl , d1 ) ≤ N (H2 , ϵ, d2 ) ≤ N (H1 , ϵ/cr , d1 ), (4.46)

where the left inequality requires ϵ ≤ cl cu /2 with cu being the upper bound
of the distance between any two points in H1 , namely, d1 (x, z) ≤ cu for
x, z ∈ H1 .

Fact 4.11 indicates that we can derive the covering number of the metric
space (H, d) by analyzing the covering number of the metric space (Hcirc , dcirc )
and the Lipschitz constants of the mapping between H and Hcirc . Intuitively,
a quantum circuit consisting of a large number of multi-qubit parameterized
gates leads to a complicated QNN with a large model complexity. These in-
tuitions are formalized into Theorem 4.13. Specifically, the result of the cov-
ering number of the metric space (Hcirc , dcirc ) is encapsulated in Lemma 4.12.

Lemma 4.12. Suppose that the employed N -qubit quantum circuit contain-
ing in total Ng gates with Ng > N , each gate ui (θ) acting on most k qubits,
and Ngt ≤ Ng gates in U (θ) are trainable. The ϵ-covering number for the
operator group Hcirc in Eqn. (4.44) with respect to the operator-norm dis-
tance obeys
  2k
7Ngt ∥O∥ 2 Ngt
N (Hcirc , ϵ, ∥ · ∥) ≤ , (4.47)
ϵ
where ∥O∥ denotes the operator norm of O.
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS147

Proof of Lemma 4.12. To measure the covering number the operator group
of Hcirc = {U (θ)† OU (θ) θ ∈ Θ}, one could first consider a fixed ϵ-covering
S for the set N (U (2k ), ϵ, ∥ · ∥) of all possible gates and define the set
 
 Y Y 
S̃ := ui (θi ) uj ui (θi ) ∈ S , (4.48)
 
i∈{Ngt } j∈{Ng −Ngt }

where ui (θi ) and uj specify the trainable and fixed quantum gates in the
employed quantum circuit, respectively. Note that for any circuit U (θ) =
QNg
i=1 ui (θi ), one can always find a Uϵ (θ) ∈ S̃ where each ui (θi ) of trainable
gates is replaced with the nearest element in the covering set S, and the
discrepancy ∥U (θ)† OU (θ) − Uϵ (θ)† OUϵ (θ)∥ satisfies
∥U (θ)† OU (θ) − Uϵ (θ)† OUϵ (θ)∥
≤∥U − Uϵ ∥∥O∥
≤Ngt ∥O∥ϵ, (4.49)
where the first inequality uses the triangle inequality, and the second in-
equality follows from ∥U − Uϵ ∥ ≤ Ngt ϵ.
Therefore, by Definition 4.10, S̃ forms an Ngt ∥O∥ϵ-covering set for Hcirc .
An upper bound for the group S, as established by Barthel and Lu (2018,

22k
Lemma 1), gives |S| ≤ 7ϵ . Since there are |S|Ngt combinations for the

22k Ngt
gates in S̃, it follows that |S̃| ≤ 7ϵ and the covering number for Hcirc
satisfies  22k Ngt
7
N (Hcirc , Ngt ∥O∥ϵ, ∥ · ∥) ≤ . (4.50)
ϵ
An equivalent representation of the above inequality is
  2k
7Ngt ∥O∥ 2 Ngt
N (Hcirc , ϵ, ∥ · ∥) ≤ . (4.51)
ϵ

With the established covering number of operator group Hcirc , one could
directly analyze the covering number of the hypothesis space H related to
QNNs, which is encapsulated in the following theorem.
Theorem 4.13. For 0 < ϵ < 1/10, the covering number of the hypothesis
space H in Eqn. (4.43) yields
  2k
7Ngt ∥O∥ 2 Ngt
N (H, ϵ, | · |) ≤ , (4.52)
ϵ
148 CHAPTER 4. QUANTUM NEURAL NETWORKS

where ∥O∥ denotes the operator norm of O.

Proof of Theorem 4.13. The intuition of the proof is as follows. Recall the
definition of the hypothesis space H in Eqn. (4.43) and Lemma 4.11. When
H1 refers to the hypothesis space H and H2 refers to the unitary group
U(2N ), the upper bound of the covering number of H, i.e., N (H1 , d1 , ϵ),
can be derived by first quantifying cr Eqn. (4.45), and then interacting
with N (Hcirc , ϵ, ∥ · ∥) in Lemma 4.12. Based on the above observations, the
following addresses the upper bound of the covering number N (H, ϵ, | · |).
The Lipschitz constant cr in Eqn. (4.45) is derived as a prerequisite
for establishing the upper bound of N (H, ϵ, | · |). Define U ∈ U(2N ) as
QN g
the employed quantum circuit composed of Ng gates, i.e., U = i=1 ul .
Let Uϵ be the quantum circuit where each of the Ng gates is replaced by
the nearest element in the covering set. The relation between the distance
d2 (Tr(Uϵ† OUϵ ρ), Tr(U † OU ρ)) and the distance d1 (Uϵ , U ) yields

d2 (Tr(Uϵ† OUϵ ρ), Tr(U † OU ρ))

=| Tr(Uϵ† OUϵ ρ) − Tr(U † OU ρ)|
 
= Tr (Uϵ† OUϵ − U † OU )ρ

≤ Uϵ† OUϵ − U † OU Tr(ρ)

=d1 (Uϵ† OUϵ , U † OU ), (4.53)

where the first equality comes from the explicit form of the hypothesis, the
first inequality uses the Cauchy-Schwartz inequality, and the last inequality
employs Tr(ρ) = 1 and

Uϵ† OUϵ − U † OU = d1 (Uϵ† OUϵ , U † OU ). (4.54)

The above equation indicates cr = 1. Combining the above result with

Lemma 4.11 (i.e., Eqn. (4.45)) and Lemma 4.12, we obtain
 22k Ngt
7Ngt ∥O∥
N (H, ϵ, | · |) ≤ N (Hcirc , ϵ, ∥ · ∥) ≤ . (4.55)
ϵ
This relation ensures
 22k Ngt
7Ngt ∥O∥
N (H, ϵ, | · |) ≤ . (4.56)
ϵ
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS149

Theorem 4.13 indicates that the most decisive factor, which controls the
complexity of H, is the employed quantum gates in U (θ). This claim is
k
ensured by the fact that the term 22 Ngt exponentially scales the complexity
N (H, ϵ, | · |). Meanwhile, the qubits count N and the operator norm ∥O∥
polynomially scale the complexity of N (H, ϵ, |·|). These observations suggest
a succinct and direct way to compare the expressivity of QNNs with different
quantum circuits. Moreover, the dependence of the expressivity of QNNs on
the type of quantum gates (denoted by the term k) demonstrated that the
expressivity of QNNs depends on the structure information of ansatz such
as the location of different quantum gates and the types of the employed
quantum gates. The expressivity measured by the covering number could
provide practical guidance for designing the circuit structure of QNNs.

Generalization error of QNNs

As the relation between generalization error and covering number is well-
established in statistical learning theory, we can directly obtain the gener-
alization error bound with the above bounds of covering number following
the same conventions.
Theorem 4.14. Assume that the loss function ℓ defined in Eqn. (4.38) is
L1 -Lipschitz and upper bounded by a constant C, the QNN-based learning
algorithm outputs a hypothesis hθ̂ from the training dataset S of size n.
Following the notations of risk RGene (hθ̂ ) = R(hθ̂ ) − RERM (hθ̂ ) defined in
Eqn. (4.41), for 0 < ϵ < 1/10, with probability at least 1 − δ with δ ∈ (0, 1),
we have p !
8L + c + 24L Ngt · 2k
RGene (hθ̂ ) ≤ O √ . (4.57)
n
Proof sketch of Theorem 4.14. Recall that the bound of generalization error
in terms of Rademacher complexity has been established by Kakade et al.
(2008) as follows
r
ln(2/δ)
RGene (hθ̂ ) ≤ 2L1 R(HQN N ) + 3C , (4.58)
2n
where R(HQN N ) represents the empirical Rademacher complexity of the hy-
pothesis space of QNNs. Furthermore, the relationship between Rademacher
complexity and covering number can be derived using the Dudley entropy
integral bound Dudley (1967), which is given by
 Z 
12 1 q
R(H) ≤ inf 4α + √ ln N (H|S , ϵ, ∥ · ∥2 )dϵ , (4.59)
α>0 n α
150 CHAPTER 4. QUANTUM NEURAL NETWORKS

where H|S denotes the set of vectors formed by the hypothesis with n ex-
amples in the dataset S. In this regard, the generalization error bound in
Eqn. (4.57) could be obtained by combining the Eqn. (4.58) and Eqn. (4.59)
with direct but tedious calculations, which is omitted here. For details of the
calculations, please refer to the proof of Theorem 2 in Du et al. (2022c).
The assumption used in this analysis is quite mild, as the loss functions
in QNNs are generally Lipschitz continuous and can be bounded above by
a constant C. This property has been broadly employed to understand the
capability of QNNs. The results obtained have three key implications. First,
the generalization bound exhibits an exponential dependence on the term k
and a sublinear dependence on the number of trainable quantum gates Ngt .
This observation reflects the quantum version of Occam’s razor (Haussler
and Warmuth, 1987), where the parsimony of the output hypothesis implies
greater predictive power. Second, increasing the number of training exam-
ples n improves the generalization bound. This suggests that incorporating
more training data is essential for optimizing complex quantum circuits.
Lastly, the sublinear dependence on Ngt may limit the ability to accurately
assess the generalization performance of overparameterized QNNs (Larocca
et al., 2023). Together, these implications provide valuable insights for de-
signing more powerful QNNs.

4.4.2 Trainability of quantum neural networks

The parameters in QNNs are often trained using gradient-based optimizers.
As such, the magnitude of the gradient plays a crucial role in the trainabil-
ity of QNNs. Specifically, large gradients are desirable, as they allow the
loss function to decrease rapidly and consistently. However, this favorable
property does not hold across a wide range of problem settings. In contrast,
training QNNs usually encounters the barren plateau (BP) problem (Mc-
Clean et al., 2018), i.e., the variance of the gradient, on average, decreases
exponentially as the number of qubits increases. In this section, we first
introduce an example demonstrating how quantum circuits that form uni-
tary 2-designs (Dankert et al., 2009) lead to BP, and then discuss several
techniques to avoid or mitigate this issue.
We begin by introducing some basic notations. For convenience, let
L denote the number of parameters in the QNN V (θ). Consider the loss
function defined as the measurement outcome of an N -qubit quantum state
ρ after applying the QNN operation, i.e.,
h i
f (θ) = Tr OV (θ)ρV (θ)† , (4.60)
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS151

Then, the mathematical formulation of the BP phenomenon is given by

   
∂f ∂f
EP = 0, VarP = exp(−αN ) · β, (4.61)
∂θk ∂θk

where P represents the probability distribution of the quantum circuit, and

α, β > 0 are constants. In the case where the circuit V (θ) has a random
structure with a polynomial number of single-qubit rotations and CNOT or
CZ gates in N , a uniform distribution over the parameter space can approx-
imate a 2-design for the unitary V (θ) (Harrow and Low, 2009; Haferkamp,
2022). Moreover, a unitary sampled from an exact 2-design exhibits the
following statistical properties.

Fact 4.15 ( Cerezo et al. (2021b)). Let {Wy }y∈Y ⊂ U(d) form a unitary
2-design, and let A, B, C, D : Hw → Hw be arbitrary linear operator. Then

1 X Tr[A] Tr[B]
Tr[Wy AWy† B] = , (4.62)
|Y | d
y∈Y
1 X
Tr[Wy AWy† B] Tr[Wy CWy† D]
|Y |
y∈Y
1
= (Tr[AC] Tr[BD] + Tr[A] Tr[B] Tr[C] Tr[D])
d2 − 1
1
− 2
(Tr[A] Tr[C] Tr[BD] + Tr[AC] Tr[B] Tr[D]), (4.63)
d(d − 1)
1 X
Tr[Wy AWy† BWy CWy† D]
|Y |
y∈Y
1
= 2 (Tr[A] Tr[C] Tr[BD] + Tr[AC] Tr[B] Tr[D])
d −1
1
− (Tr[AC] Tr[BD] + Tr[A] Tr[B] Tr[C] Tr[D]). (4.64)
d(d2 − 1)

Fact 4.15 can be derived from Facts C.4 and C.5 in Appendix C, which
provides a more detailed discussion of unitary designs, potentially of inde-
pendent interest. By applying Fact 4.15, it can be shown that QNNs with
quantum circuits forming 2-designs exhibit barren plateau loss landscapes.

Theorem 4.16 (Adapted from McClean et al. (2018)). Q Consider the loss
function given in Eqn. (4.60), where the QNN V (θ) = L j=1 Vj (θj )Wj with
fixed gate Wj and variational gate Vj (θj ) = exp(−iθj Hj /2). Suppose all
hermitian matrices {Hj } are traceless. For a integer k ∈ [1, L], denote
152 CHAPTER 4. QUANTUM NEURAL NETWORKS

Q QL
U− = k−1j=1 Vj (θj )Wj and U+ = j=k+1 Vj (θj )Wj . Then, if both U− and
U+ form 2-designs, there is

   
∂f ∂f 1      
E = 0, Var ≈ 3N +1 Tr O2 Tr ρ2 Tr Hj2 . (4.65)
∂θk ∂θk 2

Proof of Theorem 4.16. By using notations U− and U+ , the function f (θ)

in Eqn. (4.60) can be expressed as:

h i
f = Tr OV ρV †
h i
= Tr OU− Vk Wk U+ ρU+† Wk† Vk† U−†
h i
† † † †
= Tr U− OU− Vk Wk U+ ρU+ Wk Vk
 
= Tr O′ exp(−iθk Hk /2)ρ′ exp(iθk Hk /2) ,

where O′ := U−† OU− and ρ′ := Wk U+ ρU+† Wk† . Thus, the gradient could be
calculated as

∂f i h h ii
= Tr O′ Vk ρ′ Vk† , Hk .
∂θk 2

The expectation of the gradient is zero since

∂f i h h ii
E = E Tr O′ Vk ρ′ Vk† , Hk
U+ ,U− ∂θk 2
i h † h ii
= E Tr U− OU− Vk ρ′ Vk† , Hk
U+ ,U− 2
i hh ii
= E N +1 Tr[O] Tr Vk ρ′ Vk† , Hk (4.66)
U+ 2

= 0, (4.67)

where Eqn. (4.66) follows from Eqn. (4.62), and Eqn. (4.67) is derived by
noticing Tr[[A, B]] = Tr[AB − BA] = 0. Therefore, the variance of the
4.4. THEORETICAL FOUNDATIONS OF QUANTUM NEURAL NETWORKS153

gradient equals to the expectation of its square, i.e.,

   2
∂f ∂f
Var = E
U+ ,U− ∂θk U+ ,U− ∂θk
1 h h ii2
= − EU+ ,U− Tr U−† OU− Vk ρ′ Vk† , Hk
4 h
1  2 i2 
′ †
= − E Tr O Tr Vk ρ Vk , Hk
4 × (22N − 1) U+
h i2 
1 2 ′ †
+ N +2 2N E Tr[O] Tr Vk ρ V k , Hk (4.68)
2 (2 − 1) U+
h i2 
1  2 ′ †
= − Tr O E Tr Vk ρ Vk , Hk , (4.69)
4 × (22N − 1) U+

where Eqn. (4.68) follows from Eqn. (4.63), and Eqn. (4.69) follows from
Tr[O] = 0. Further, it can be shown that

h i2 
′ †
E Tr Vk ρ Vk , Hk
U+
 2   2 
′ † ′ † 2
= 2 E Tr Vk ρ Vk Hk − 2 E Tr Vk ρ Vk (Hk )
U+ U+
 2 
† † †
= 2 E Tr Vk Wk U+ ρU+ Wk Vk Hk
U+
 2 
† † † 2
−2 E Tr Vk Wk U+ ρU+ Wk Vk (Hk )
U+
2  2 2
 2
= Tr[ρ] Tr[Hk ] + Tr ρ Tr[Hk ]2
22N − 1
2   2  2
− N 2N Tr ρ Tr Hk + Tr[ρ]2 Tr[Hk ]2
2 (2 − 1)
2    
− N Tr Hk2 Tr ρ2 (4.70)
2
2N +1    
≈ − 2N Tr Hk2 Tr ρ2 , (4.71)
2 −1

where Eqn. (4.70) follows from Eqn. (4.62) and Eqn. (4.64). Eqn. (4.71)
is derived by ignoring minor terms and using Tr[Hk ] = 0. Combining
154 CHAPTER 4. QUANTUM NEURAL NETWORKS

Eqn. (4.69) and Eqn. (4.71), it can be shown that

 
∂f 2N      
Var ≈ 2 Tr O2 Tr Hk2 Tr ρ2
U+ ,U− ∂θk 2 × (22N − 1)
1      
≈ 3N +1 Tr O2 Tr ρ2 Tr Hk2 .
2
Thus, Theorem 4.16 is proved.

Remark
The influence of barren plateau can be categorized into three folds.

1. Training efficiency. Exponentially small gradients imply that

the training of QNNs with gradient-based optimizers may re-
quire exponential numbers of iterations to converge.

2. Optimization effectiveness. The calculation of the gradient

via the parameter-shift rule would introduce unbiased statisti-
cal noise due to finite shot numbers. A small gradient could
be vulnerable to these measurement noises, which may induce
additional barriers in optimizations.

3. Quantum advantage. QNNs are expected to exhibit quan-

tum advantages by employing intermediate to large numbers of
qubits. However, the barren plateau phenomenon may induce
exponential training steps, which can offset potential quantum
advantages.

Since the barren plateau could seriously affect the trainability of scaled
QNNs and raise concerns about the utility of QNNs for achieving quan-
tum advantages, researchers have been focused on developing techniques
to address this problem. Existing efforts including specific architecture de-
sign (Cerezo et al., 2021b; Pesah et al., 2021; Zhang et al., 2021b), parameter
initialization schemes (Grant et al., 2019; Zhang et al., 2022b), and advanced
training protocols (Skolik et al., 2021; Haug and Kim, 2021). Here we briefly
introduce two related results with theoretical guarantees.
Fact 4.17 (Shallow hardware-efficient circuits are BP-free, informal ver-
sion adapted from Cerezo et al. (2021b)). Suppose the observable has a local
form in the Pauli basis decomposition. For QNNs employing N -qubit shal-
low hardware-efficient circuits with logarithmic depths, the variance of the
 4.5. CODE DEMONSTRATION 155

gradient has the lower bound

   
∂f 1
Var ≥Ω . (4.72)
∂θk poly(N )

Fact 4.18 (Gaussian initializations help to escape the BP region, informal

version adapted from Zhang et al. (2022b)). Suppose the observable is the
tensor product of Pauli matrices σi = σi1 ⊗ · · · ⊗ σiN , where the number of
non-identity matrices in {σi1 , · · · , σiN } is S. For QNNs employing N -qubit
shallow hardware-efficient circuits with the depth L, the gradient norm has
the lower bound
L
2
E ∥∇θ f ∥ ≥ Tr[σj ρin ]2 , (4.73)
θ S S (L + 2)S+1

where S is the number of non-zero elements in i, and the index j = (j1 , j2 , · · · , jN )

such that jm = 0, ∀im = 0 and jm  = 3, ∀im ̸= 0. The expectation is taken
1
with the Gaussian distribution N 0, 4S(L+2) for the parameters θ.

4.5 Code Demonstration

This section provides hands-on demonstrations of QNNs for both discrim-
inative and generative tasks, where we will illustrate practical implemen-
tations of quantum classifiers and quantum patch GAN. Each subsection
corresponds to a specific application, offering a step-by-step explanation
and code walkthrough.

4.5.1 Quantum classifier

We now demonstrate how to utilize QNN to solve discriminative tasks,
specifically a binary classification problem based on the Wine dataset. Be-
low, we outline the major steps in the pipeline:

Step 1 Load and preprocess the dataset.

Step 2 Implement a quantum read-in protocol to encode classical data into

quantum states.

Step 3 Construct a parameterized quantum circuit model to process the input

quantum states.

Step 4 Train and test the QNN to evaluate its performance.

 156 CHAPTER 4. QUANTUM NEURAL NETWORKS

We first import all the necessary libraries:

1 import sklearn
2 import sklearn . datasets
3 import pennylane as qml
4 from pennylane import numpy as np
5 from pennylane . optimize import AdamOptimizer
6 import matplotlib . pyplot as plt

Step 1: Dataset preparation. We prepare the Wine dataset for the

classification task. For simplicity, we focus on the first two classes of the
Wine dataset. The dataset consists of 13 attributes per sample, each with
a distinct range. We apply normalization to rescale these attributes to the
interval [0, π]. Furthermore, the labels are remapped from {0, 1} to {−1, 1}
to align with the output range of the quantum circuit model. The dataset
is split into training and test sets to fairly evaluate the classifier.
1 def load_wine ( split_ratio = 0.5) :
2 feat , label = sklearn . datasets . load_wine ( return_X_y =
True )
3
4 # normalization
5 feat = np . pi * ( feat - np . min ( feat , axis =0 , keepdims =
True ) ) / np . ptp ( feat , axis =0 , keepdims = True )
6
7 index_c0 = label == 0
8 index_c1 = label == 1
9
10 label = label * 2 - 1
11
12 n_c0 = sum ( index_c0 )
13 n_c1 = sum ( index_c1 )
14
15 X_train = np . concatenate (( feat [ index_c0 ][: int (
split_ratio * n_c0 ) ] , feat [ index_c1 ][: int (
split_ratio * n_c1 ) ]) , axis =0)
16 y_train = np . concatenate (( label [ index_c0 ][: int (
split_ratio * n_c0 ) ] , label [ index_c1 ][: int (
split_ratio * n_c1 ) ]) , axis =0)
17 X_test = np . concatenate (( feat [ index_c0 ][ int (
split_ratio * n_c0 ) :] , feat [ index_c1 ][ int (
split_ratio * n_c1 ) :]) , axis =0)
18 y_test = np . concatenate (( label [ index_c0 ][ int (
split_ratio * n_c0 ) :] , label [ index_c1 ][ int (
split_ratio * n_c1 ) :]) , axis =0)
 4.5. CODE DEMONSTRATION 157

19
20 return X_train , y_train , X_test , y_test
21 X_train , y_train , X_test , y_test = load_wine ()

To better understand the dataset, we apply t-SNE to visualize its dis-

tribution. As shown in Figure 4.12, each data point is projected into a 2D
space for visualization, with distinct colors representing different classes.

1 def v isuali ze_dat aset (X , y ) :

2 from sklearn . manifold import TSNE
3
4 tsne = TSNE ( n_components =2 , random_state =42 ,
perplexity =30)
5
6 wine_tsne = tsne . fit_transform ( X )
7 for label in np . unique ( y ) :
8 indices = y == label
9 plt . scatter ( wine_tsne [ indices , 0] , wine_tsne [
indices , 1] , edgecolor = ’ black ’ , cmap = ’
coolwarm ’ , s =20 , label = f ’ Class ␣ { label } ’)
10
11 # Add labels and legend
12 plt . title ( "t - SNE ␣ Visualization ␣ of ␣ Wine ␣ dataset ␣ ( two ␣
classes ) " )
13 plt . xlabel ( "t - SNE ␣ Dimension ␣ 1 " )
14 plt . ylabel ( "t - SNE ␣ Dimension ␣ 2 " )
15 plt . legend ()
16
17 plt . tight_layout ()
18 plt . show ()
19 visu alize_ datase t ( X_train , y_train )
 158 CHAPTER 4. QUANTUM NEURAL NETWORKS

t-SNE Visualization of Wine dataset (two classes)

Class 0
2 Class 1

0
t-SNE Dimension 2

6
1 0 1 2 3
t-SNE Dimension 1

Figure 4.12: T-SNE visualization of Wine dataset of the first two

classes.

Step 2: Data encoding. To encode the 13 attributes of the Wine dataset

into a quantum system, we use angle encoding introduced in Section 2.3.1,
followed by a layer of CNOT gates acting on neighboring qubits to introduce
entanglement.
1 def data_encoding ( x ) :
2 n_qubit = len ( x )
3 qml . AngleEmbedding ( features = x , wires = range (
n_qubit ) , rotation = " X " )
4 for i in range ( n_qubit ) :
5 if i +1 < n_qubit :
6 qml . CNOT ( wires =[ i , i +1])

Step 3: Building quantum classifier. With the data encoding in place,

we construct a quantum binary classifier. The circuit model is composed
of multiple layers, where each layer includes parameterized single-qubit ro-
tation gates with trainable angles, followed by a block of non-parametric
CNOT gates to introduce entanglement among qubits. To read-out the cat-
egory information of each input sample from the prepared quantum state,
we compute the expectation value of the Pauli-Z operator on the first qubit.
1 def classifier ( param , x = None ) :
2 data_encoding ( x )
 4.5. CODE DEMONSTRATION 159

3 n_layer , n_qubit = param . shape [0] , param . shape [1]

4 for i in range ( n_layer ) :
5 for j in range ( n_qubit ) :
6 qml . Rot ( param [i , j , 0] , param [i , j , 1] , param
[i , j , 2] , wires = j )
7 for j in range ( n_qubit ) :
8 if j +1 < n_qubit :
9 qml . CNOT ( wires =[ j , j +1])
10 return qml . expval ( qml . PauliZ (0) )
11

12 n_qubit = X_train . shape [1]

13 dev = qml . device ( ’ default . qubit ’ , wires = n_qubit )
14 circuit = qml . QNode ( classifier , dev )

We visualize the whole quantum circuit of 2 layers by drawing the dia-

gram, as shown in Figure 4.13.

1 fig , ax = qml . draw_mpl ( circuit ) ( np . pi * np . random . randn

(2 , n_qubit , 3) , X_train [0])
2 fig . show ()
 160 CHAPTER 4. QUANTUM NEURAL NETWORKS

0 Rot Rot

1 Rot Rot

2 Rot Rot

3 Rot Rot

4 Rot Rot

5 Rot Rot
AngleEmbedding

6 Rot Rot

7 Rot Rot

8 Rot Rot

9 Rot Rot

10 Rot Rot

11 Rot Rot

12 Rot Rot

Figure 4.13: The circuit diagram of the quantum classifier.

Step 4: Training and evaluation of quantum classifier. With the data

and circuit model ready, we now move to the optimization of the quantum
classifier. The mean squared error (MSE) is used as the loss function. The
goal is to minimize the difference between the predicted and actual labels
over the training set.
1 def mse_loss ( predict , label ) :
2 return np . mean (( predict - label ) **2)
3
4 def cost ( param , circuit , X , y ) :
5 exp = []
6 for i in range ( len ( X ) ) :
7 pred = circuit ( param , x = X [ i ])
8 exp . append ( pred )
 4.5. CODE DEMONSTRATION 161

9 return mse_loss ( np . array ( exp ) , y )

To evaluate the performance of the quantum classifier, we use classi-

fication accuracy as the metric. Specifically, if the sign of the read-out
result matches the corresponding label, the prediction is considered correct;
otherwise, it is deemed incorrect. The accuracy is then calculated as the
proportion of correctly classified samples out of the total.
1 def accuracy ( predicts , labels ) :
2 assert len ( predicts ) == len ( labels )
3 return np . sum (( np . sign ( predicts ) * labels +1) /2) / len (
predicts )

The Adam optimizer is utilized to minimize the loss function. To en-

sure efficient computation, the dataset is divided into smaller batches for
each training iteration. At the end of each epoch, both the training and
test losses, along with the classification accuracy, are recorded to track the
model’s performance.
1 lr = 0.01
2 opt = AdamOptimizer ( lr )
3 batch_size = 4
4
5 n_epoch = 50
6 cost_train , cost_test , acc_train , acc_test = [] , [] , [] ,
[]
7 for i in range ( n_epoch ) :
8 index = np . random . permutation ( len ( X_train ) )
9 feat_train , label_train = X_train [ index ] , y_train [
index ]
10 for j in range (0 , len ( X_train ) , batch_size ) :
11 feat_train_batch = feat_train [ j * batch_size :( j +1) *
batch_size ]
12 lab el_tra in_bat ch = label_train [ j * batch_size :( j
+1) * batch_size ]
13 param = opt . step ( lambda v : cost (v , circuit ,
feat_train_batch , labe l_trai n_batc h ) , param )
14

15 # compute cost
16 cost_train . append ( cost ( param , circuit , X_train ,
y_train ) )
17 cost_test . append ( cost ( param , circuit , X_test , y_test )
)
18

19 # compute accuracy
 162 CHAPTER 4. QUANTUM NEURAL NETWORKS

20 pred_train = []
21 for j in range ( len ( X_train ) ) :
22 pred_train . append ( circuit ( param , x = X_train [ j ]) )
23 acc_train . append ( accuracy ( np . array ( pred_train ) ,
y_train ) )
24
25 pred_test = []
26 for j in range ( len ( X_test ) ) :
27 pred_test . append ( circuit ( param , x = X_test [ j ]) )
28 acc_test . append ( accuracy ( np . array ( pred_test ) , y_test )
)

After training the QNN, the training and test cost, as well as the accu-
racy over epochs, can be visualized using the following code.

1 plt . figure ( figsize =(12 , 6) )

2
3 plt . subplot (1 , 2 , 1)
4 epochs = np . arange ( n_epoch ) + 1
5 plt . plot ( epochs , cost_train , label = ’ Training ␣ Cost ’ ,
marker = ’o ’)
6 plt . plot ( epochs , cost_test , label = ’ Test ␣ Cost ’ , marker = ’o ’
)
7 plt . title ( ’ Cost ␣ Over ␣ Epochs ’)
8 plt . xlabel ( ’ Epochs ’)
9 plt . ylabel ( ’ Cost ’)
10 plt . legend ()
11 plt . grid ()
12
13 # Plot training and test accuracy
14 plt . subplot (1 , 2 , 2)
15 plt . plot ( epochs , acc_train , label = ’ Training ␣ Accuracy ’ ,
marker = ’o ’)
16 plt . plot ( epochs , acc_test , label = ’ Test ␣ Accuracy ’ , marker =
’o ’)
17 plt . title ( ’ Accuracy ␣ Over ␣ Epochs ’)
18 plt . xlabel ( ’ Epochs ’)
19 plt . ylabel ( ’ Accuracy ’)
20 plt . legend ()
21 plt . grid ()
22
23 plt . tight_layout ()
24 plt . show ()
 4.5. CODE DEMONSTRATION 163

Cost Over Epochs Accuracy Over Epochs

Training Cost
1.4 Test Cost

0.8
1.2

1.0 0.6

Accuracy
Cost

0.8
0.4

0.6
0.2

Training Accuracy
0.4 Test Accuracy
0 10 20 30 40 50 0 10 20 30 40 50
Epochs Epochs

Figure 4.14: The training curve of the quantum classifier.

As demonstrated in Figure 4.14, this QNN achieves a test accuracy ex-

ceeding 0.8. The performance of the QNN could potentially be further
enhanced by employing more advanced read-in protocols, as discussed in
Chapter 2.3.1, which could enable more efficient and expressive representa-
tions of the input data. Additionally, optimizing the circuit design, such as
adjusting the arrangement of layers or introducing more complex parame-
terized gates to increase the model’s capacity, as highlighted in Chapter 4.6,
could further improve the QNN’s ability to capture intricate patterns in the
dataset.

4.5.2 Quantum patch GAN

We next demonstrate how to implement a quantum patch GAN introduced
in Chapter 4.3.3 for the generation of hand-written digits of five. The whole
pipeline includes the following steps:

Step 1 Load and pre-process the dataset.

Step 2 Build the classical discriminator.

Step 3 Build the quantum generator.

Step 4 Train the quantum patch GAN.

Step 5 Visualize the generated images.

 164 CHAPTER 4. QUANTUM NEURAL NETWORKS

We begin by importing the required libraries:

1 import torch
2 import torch . nn as nn
3 import torch . optim as optim
4 from torch . utils . data import Dataset , DataLoader
5
6 import numpy as np
7 import matplotlib . pyplot as plt
8 import pennylane as qml
9 import math

Step 1: Dataset preparation. We will use the Optical Recognition of

Handwritten Digits dataset (optdigits), where each data point represents
an 8 × 8 grayscale image. The following code defines a custom dataset class
to load and process the data.
1 class OptdigitsData ( Dataset ) :
2 def __init__ ( self , data_path , label ) :
3 """
4 Dataset class for Optical Recognition of
Handwritten Digits .
5 """
6 super () . __init__ ()
7
8 self . data = []
9 with open ( data_path , ’r ’) as f :
10 for line in f . readlines () :
11 if int ( line . strip () . split ( ’ , ’) [ -1]) ==
label :
12 # Normalize image pixel values from
[0 ,16) to [0 , 1)
13 image = [ int ( pixel ) /16 for pixel in
line . strip () . split ( ’ , ’) [: -1]]
14 image = np . array ( image , dtype = np .
float32 ) . reshape (8 , 8)
15 self . data . append ( image )
16 self . label = label
17
18 def __len__ ( self ) :
19 return len ( self . data )
20
21 def __getitem__ ( self , index ) :
22 return torch . from_numpy ( self . data [ index ]) , self .
label
 4.5. CODE DEMONSTRATION 165

After defining the dataset, we can visualize a few examples to better

understand the structure of the dataset.
1 def v isuali ze_dat aset ( data_path ) :
2 """
3 Visualizes the dataset by displaying examples for
each digit label .
4 """
5 plt . figure ( figsize =(10 , 5) )
6 for i in range (10) :
7 plt . subplot (1 , 10 , i + 1)
8 data = OptdigitsData ( data_path , label = i )
9 plt . imshow ( data [0][0] , cmap = ’ gray ’)
10 plt . title ( f " Label : ␣ { i } " )
11 plt . axis ( ’ off ’)
12 plt . tight_layout ()
13 plt . show ()
14
15 visu alize_ datase t ( ’ code / chapter5_qnn / data / optdigits . tra ’)

Label: 0 Label: 1 Label: 2 Label: 3 Label: 4 Label: 5 Label: 6 Label: 7 Label: 8 Label: 9

Figure 4.15: Samples in the dataset optdigits.

Step 2: Building the classical discriminator. The discriminator is a

classical neural network responsible for distinguishing real images from fake
ones. It consists of fully connected layers with ReLU activations. The final
output is passed through a Sigmoid function, which scales the output to the
range (0, 1), serving as a probabilistic indicator of whether the input image
is real or fake.
1 class C l a s s i c a l D i s c r i m i n a t o r ( nn . Module ) :
2 """
3 A classical discriminator for classifying real and
fake images .
4 """
5 def __init__ ( self , input_shape ) :
6 super () . __init__ ()
7 self . model = nn . Sequential (
8 nn . Flatten () ,
9 nn . Linear ( int ( np . prod ( input_shape ) ) , 256) ,
10 nn . ReLU () ,
 166 CHAPTER 4. QUANTUM NEURAL NETWORKS

11 nn . Dropout () ,
12 nn . Linear (256 , 128) ,
13 nn . ReLU () ,
14 nn . Dropout () ,
15 nn . Linear (128 , 1) ,
16 nn . Sigmoid ()
17 )
18
19 def forward ( self , img ) :
20 return self . model ( img )

Step 3: Defining the quantum patch generator. The generator in the

quantum patch GAN consists of parameterized quantum circuits (PQC).
These circuits are responsible for generating patches of the target image.
Specifically, the PQC follows the layout in Figure 4.7, which applies layers
of single-qubit rotation gates and entangling gates to the latent state.
1 def PQC ( params ) :
2 n_layer , n_qubit = params . shape [0] , params . shape [1]
3 for i in range ( n_layer ) :
4 for j in range ( n_qubit ) :
5 qml . Rot ( params [i , j , 0] , params [i , j , 1] ,
params [i , j , 2] , wires = j )
6 # Control Z gates
7 for j in range ( n_qubit - 1) :
8 qml . CZ ( wires =[ j , j + 1])

Then, we implement the quantum generator for each patch of an im-

age, i.e., sub-generators. The sub-generator transforms the latent variable
z into a latent quantum state |z⟩, applies a PQC, performs partial mea-
surements on the ancillary system A, and outputs the probabilities of each
computational basis state in the remaining system, which correspond to the
generated pixel values.
1 def QuantumGenerator ( params , z = None , n_qubit_a =1) :
2 n_qubit = params . shape [1]
3
4 # angle encoding of latent state z
5 for i in range ( n_qubit ) :
6 qml . RY ( z [ i ] , wires = i )
7
8 PQC ( params )
9
10 # partial measurement on the ancillary qubits
11 qml . measure ( wires = n_qubit -1)
 4.5. CODE DEMONSTRATION 167

12 return qml . probs ( wires = range ( n_qubit - n_qubit_a ) )

Using the sub-generators, the quantum patch generator combines the

output patches from multiple sub-generators to construct the complete im-
age.
1 class P a t c h Q u a n t u m G e n e r a t o r ( nn . Module ) :
2 """
3 Combines patches generated by quantum circuits into
full images .
4 """
5 def __init__ ( self , qnode_generator , n_generator ,
n_qubit , n_qubit_a , n_layer ) :
6 super () . __init__ ()
7

8 self . params_generator = nn . ParameterList ([

9 nn . Parameter ( torch . rand (( n_layer , n_qubit , 3)
) , requires_grad = True ) for _ in range (
n_generator )
10 ])
11 self . qnode_generator = qnode_generator
12 self . n_qubit_a = n_qubit_a
13
14 def forward ( self , zs ) :
15 images = []
16 for z in zs :
17 patches = []
18 for params in self . params_generator :
19 patch = self . qnode_generator ( params , z =z ,
n_qubit_a = self . n_qubit_a ) . float ()
20
21 # post - processing : min - max scaling
22 patch = ( patch - patch . min () ) / ( patch .
max () - patch . min () + 1e -8)
23
24 patches . append ( patch . unsqueeze (0) )
25 patches = torch . cat ( patches , dim =0)
26 images . append ( patches . flatten () . unsqueeze (0) )
27 return torch . cat ( images , dim =0)

Step 4: Training the quantum patch GAN. With the dataset and
models ready, we initialize the quantum generator, classical discriminator,
and their optimizers.
1 # Hyperparameters
2 torch . manual_seed (0)
 168 CHAPTER 4. QUANTUM NEURAL NETWORKS

3 image_width = 8
4 image_height = 8
5 n_generator = 4
6 n_qubit_d = int ( np . log2 (( image_width * image_height ) //
n_generator ) )
7 n_qubit_a = 1
8 n_qubit = n_qubit_d + n_qubit_a
9 n_layer = 6
10
11 # Quantum device
12 dev = qml . device ( " lightning . qubit " , wires = n_qubit )
13 qnode_generator = qml . QNode ( QuantumGenerator , dev )
14
15 # Initialize generator and discriminator
16 discriminator = C l a s s i c a l D i s c r i m i n a t o r ([ image_height ,
image_width ])
17 discriminator . train ()
18 generator = P a t c h Q u a n t u m G e n e r a t o r ( qnode_generator ,
n_generator , n_qubit , n_qubit_a , n_layer )
19 generator . train ()
20
21 # Optimizers
22 lr_generator = 0.3
23 lr_discriminator = 1e -2
24 opt _discr iminat or = optim . SGD ( discriminator . parameters () ,
lr = lr_discriminator )
25 opt_generator = optim . SGD ( generator . parameters () , lr =
lr_generator )
26
27 # Construct dataset and dataloader
28 batch_size = 4
29 dataset = OptdigitsData ( ’ code / chapter5_qnn / data / optdigits
. tra ’ , label =5)
30 dataloader = DataLoader ( dataset , batch_size = batch_size ,
shuffle = True , drop_last = True )
31
32 # Loss function
33 loss_fn = nn . BCELoss ()
34 labels_real = torch . ones ( batch_size , dtype = torch . float )
35 labels_fake = torch . zeros ( batch_size , dtype = torch . float )
36
37 # Testing setup
38 n_test = 10
39 z_test = torch . rand ( n_test , n_qubit ) * math . pi
 4.5. CODE DEMONSTRATION 169

The GAN training process involves alternating updates for the discrimi-
nator and the generator. The discriminator is trained to distinguish between
real and fake images, while the generator learns to create images that can
successfully deceive the discriminator. To track the generator’s progress
during training, the generated images are saved at the end of each epoch.
1 n_epoch = 10
2 record = {}
3 for i in range ( n_epoch ) :
4 for data , _ in dataloader :
5
6 zs = torch . rand ( batch_size , n_qubit ) * math . pi
7 image_fake = generator ( zs )
8

9 # Training the discriminator

10 discriminator . zero_grad ()
11 pred_fake = discriminator ( image_fake . detach () )
12 pred_real = discriminator ( data )
13
14 l oss _d is cr im in at or = loss_fn ( pred_fake . squeeze () ,
labels_fake ) + loss_fn ( pred_real . squeeze () ,
labels_real )
15 l oss _d is cr im in at or . backward ()
16 opt _discr iminat or . step ()
17
18 # Training the generator
19 generator . zero_grad ()
20 pred_fake = discriminator ( image_fake )
21 loss_generator = loss_fn ( pred_fake . squeeze () ,
labels_real )
22 loss_generator . backward ()
23 opt_generator . step ()
24
25 print ( f ’ The ␣ { i } - th ␣ epoch : ␣ discriminator ␣ loss ={
lo ss _d is cr im in at or : ␣ 0.3 f } , ␣ generator ␣ loss ={
loss_generator : ␣ 0.3 f } ’)
26
27 # test
28 generator . eval ()
29 image_generated = generator ( z_test ) . view ( n_test ,
image_height , image_width ) . detach ()
30
31 record [ str ( i ) ] = {
32 ’ l os s_ di sc ri mi na to r ’: l os s_ di sc ri mi na to r . item () ,
33 ’ loss_generator ’: loss_generator . item () ,
 170 CHAPTER 4. QUANTUM NEURAL NETWORKS

34 ’ image_generated ’: image_generated . numpy () . tolist

()
35 }
36 generator . train ()

Step 5: Visualizing the generated images. After training, we visualize

the images generated by the quantum generator to evaluate its performance.
These visualizations allow us to see how well the model has learned to pro-
duce realistic image patches.

1 n _ e p o c h s _ t o _ v i s u a l i z e = len ( record ) // 2
2 n_ im ag es _p er _e po ch = 10
3
4 fig , axes = plt . subplots ( n_epochs_to_visualize ,
n_images_per_epoch , figsize =( n_images_per_epoch ,
n_epochs_to_visualize ))
5
6 # Iterate through the recorded epochs and visualize
generated images
7 for epoch_idx , ( epoch , data ) in enumerate ( record . items () )
:
8 if epoch_idx % 2 == 1:
9 continue
10 images = np . array ( data [ ’ image_generated ’ ])
11
12 for img_idx in range ( n_ im ag es _p er _ep oc h ) :
13 ax = axes [ epoch_idx // 2 , img_idx ]
14 ax . imshow ( images [ img_idx ] , cmap = ’ gray ’)
15 ax . axis ( ’ off ’)
16
17 # Add epoch information to the title of each row
18 if img_idx == 0:
19 ax . set_title ( f " Epoch ␣ { epoch } " , fontsize =10)
20
21 plt . tight_layout ()
22 plt . show ()
4.6. BIBLIOGRAPHIC REMARKS 171

Epoch 0

Epoch 2

Epoch 4

Epoch 6

Epoch 8

Figure 4.16: The images generated by quantum patch GAN during

training.

4.6 Bibliographic Remarks

Quantum neural networks (QNNs) have emerged as a prominent paradigm
in quantum machine learning, demonstrating potential in both discrimina-
tive and generative learning tasks. For discriminative tasks, QNNs utilize
high-dimensional Hilbert spaces to efficiently capture and represent complex
intrinsic relationships. In generative tasks, QNNs leverage variational quan-
tum circuits to generate complex probability distributions that may exceed
the capabilities of classical models. While these approaches share common
learning strategies, they each introduce unique challenges and opportunities
in terms of model design, theoretical exploration, and practical implemen-
tation. In the remainder of this section, we briefly review recent advances
in QNNs. Interested readers can refer to Ablayev et al. (2019); Li and Deng
(2022); Massoli et al. (2022); Tian et al. (2023); Wang and Liu (2024) for a
more comprehensive review.

4.6.1 Discriminative learning with QNN

QNNs for discriminative tasks have emerged as one of the most active
research areas in quantum machine learning, demonstrating potential ad-
vantages in feature representation and processing efficiency. The quantum
learning approach leverages the high-dimensional Hilbert space and quan-
tum parallelism to potentially handle complex classification boundaries more
172 CHAPTER 4. QUANTUM NEURAL NETWORKS

effectively than classical neural networks. Research has shown particular

promise in handling datasets with inherent quantum properties and prob-
lems where quantum entanglement can be meaningfully exploited (Huang
et al., 2022).

Model designs
In the realm of quantum discriminative models, researchers have developed
various quantum neural architectures. In general, variational quantum clas-
sifiers (Havlı́ček et al., 2019; Mitarai et al., 2018) could employ parame-
terized quantum circuits for classification tasks. Subsequently, quantum
convolutional neural networks (Cong et al., 2019) are designed for process-
ing structured data. Hybrid quantum-classical architectures (Arthur et al.,
2022) are proposed to combine quantum layers with classical neural net-
works. Other notable works include the development of quantum versions of
popular classical architectures like recurrent neural networks (Bausch, 2020)
and attention mechanisms (Shi et al., 2024). Finally, Pérez-Salinas et al.
(2020); Fan and Situ (2022) have explored quantum re-uploading strategies
for encoding classical data, achieving QML models with more expressive
feature maps.
In addition to manually designed architectures, various lightening strate-
gies have been explored to enhance the efficiency of quantum neural net-
works. For example, quantum architecture search methods have been de-
veloped by (Du et al., 2022a; Zhang et al., 2022c; Linghu et al., 2024) to
automatically discover optimal quantum circuit designs with reduced gate
complexity. Sim et al. (2021); Wang et al. (2022b) introduced quantum prun-
ing techniques that systematically identify and remove redundant quantum
gates while preserving the performance. In the realm of knowledge dis-
tillation, researchers have demonstrated how to transfer knowledge from
the teacher model given as quantum (Alam et al., 2023) or classical (Li
et al., 2024) neural networks to more compact quantum circuit architec-
tures that are more robust against quantum noises. These optimization
approaches have collectively contributed to improving the practical perfor-
mance of QNNs on real quantum devices, particularly in the NISQ era.

Theoretical foundations
To gain a deeper understanding of the potential advantages and limitations
of QNNs, a crucial research topic is analyzing their learnability. More con-
cisely, the learnability is determined by the interplay of three key aspects:
4.6. BIBLIOGRAPHIC REMARKS 173

expressivity, trainability, and generalization, as preliminarily introduced in

Chapter 4.4 with essential theoretical results. Beyond these foundational
insights, an extensive body of research has conducted more comprehensive
and detailed investigations into these three aspects, which will be reviewed
individually in the following.
Expressivity. The expressivity of QNNs refers to their ability to represent
complex functions or quantum states efficiently. Universal approximation
theorems (UAT) incorporating data re-uploading strategies have been estab-
lished by Pérez-Salinas et al. (2020) firstly with subsequent works (Schuld
et al., 2021; Yu et al., 2022a) in various problem settings. Beyond the UAT,
Sim et al. (2019), Nakaji and Yamamoto (2021), and Holmes et al. (2022)
analyze the expressivity of QNNs by investigating how well the parameter-
ized quantum circuits used in QNNs can approximate the Haar distribution,
a critical measure of expressive capacity in quantum systems. Moreover,
Yu et al. (2022b) analyze the non-asymptotic error bounds of variational
quantum circuits for approximating multivariate polynomials and smooth
functions.
Trainability. The trainability of QNNs corresponds to two aspects during
the optimization of QNNs: the gradient magnitude and the convergence rate.
For the first research line, McClean et al. (2018) first found the phe-
nomenon of vanishing gradients, dubbed as the barren plateau, where the
gradient magnitude scales exponentially small with the quantum system size.
Since then, a series of studies explored the cause of barren plateau, including
global measurements (Cerezo et al., 2021b), highly entanglement (Ortiz Mar-
rero et al., 2021), and quantum system noise (Wang et al., 2021b).
Efforts to address the barren plateau problem, a major challenge in train-
ing deep quantum circuits, have yielded strategies such as proper circuit and
parameter initialization techniques (Grant et al., 2019; Zhang et al., 2022b),
cost function design (Cerezo et al., 2021b), and proper circuits (Pesah et al.,
2021). Quantum-specific regularization techniques have also been developed
to mitigate these effects (Larocca et al., 2022).
Another research line on the trainability of QNNs focuses on the conver-
gence of QNNs, which is not introduced in this Chapter. In particular, Kiani
et al. (2020) and Wiersema et al. (2020) experimentally found that overpa-
rameterized QNNs embrace a benign landscape and permit fast convergence
towards near optimal local minima. Afterward, initial attempts have been
made to theoretically explain the superiority of over-parameterized QNNs.
Specifically, Larocca et al. (2023) and Anschuetz (2021) utilized tools from
dynamical Lie algebra and random matrix theory, respectively, to quantify
174 CHAPTER 4. QUANTUM NEURAL NETWORKS

the critical points in the optimization landscape of overparameterized QNNs.

Moreover, You et al. (2022) extended the classical convergence results of Xu
et al. (2018) to the quantum domain, proving that overparameterized QNNs
achieve an exponential convergence rate. Additionally, Liu et al. (2023) and
Wang et al. (2023a) introduced the concept of the quantum neural tangent
kernel (QNTK) to further demonstrate the exponential convergence rate
of overparameterized QNNs. Besides the overparameterization theory, (Du
et al., 2021b, 2022b; Qi et al., 2023; Qian et al., 2024) investigated the re-
quired conditions to ensure the convergence of QNNs towards local minima.
Generalization. Research has also focused on understanding the sample
complexity and generalization error bounds of quantum machine learning
algorithms by using different statistical learning tools. In particular, Ab-
bas et al. (2021) compared the generalization power of QNNs and classical
learning models based on an information geometry metric. Caro et al. (2022)
and Du et al. (2022c) established generalization error bounds using cover-
ing numbers, revealing the impact of circuit structural factors—such as the
number of gates and types of observables—on generalization ability. Simi-
larly, Bu et al. (2022) analyzed the generalization ability of QNNs from the
perspective of quantum resource theory, emphasizing the role of quantum
resources such as entanglement and magic in influencing generalization.
Furthermore, frameworks for demonstrating quantum advantage in spe-
cific learning scenarios have been proposed (Huang et al., 2021c, 2022),
providing insights into the conditions under which quantum models out-
perform their classical counterparts. Zhang et al. (2024a) investigate the
training-dependent generalization abilities of QNNs, while Du et al. (2023)
study problem-dependent generalization, highlighting key factors that en-
able QNNs to achieve strong generalization performance.
Beyond analyses focused on specific datasets and problems, the general-
ization ability of QNNs has also been examined through the lens of the No-
Free-Lunch theorem. Poland et al. (2020) explore the average performance
of QNNs across all possible datasets and problems, providing a broader per-
spective on their generalization potential. Extending this work, Sharma
et al. (2022) and Wang et al. (2024a) adapt the No-Free-Lunch theorem to
scenarios involving entangled data, demonstrating the potential benefits of
entanglement in certain settings. Additionally, Wang et al. (2024b) estab-
lish a No-Free-Lunch framework for various learning protocols, considering
different quantum resources used in these protocols.
Potential advantages. A critical challenge in quantum learning theory
is identifying tasks where QNNs demonstrate provable computational ad-
4.6. BIBLIOGRAPHIC REMARKS 175

vantages over classical approaches when solving classical problems. While

recent studies have explored unconditional quantum advantage, most focus
on synthetic tasks. For instance, polynomial advantages over commonly used
classical models have been demonstrated through quantum contextuality in
sequential learning (Anschuetz et al., 2023; Anschuetz and Gao, 2024). Ad-
ditionally, quantum entanglement has been shown to reduce communication
requirements in non-local machine-learning tasks (Zhao and Deng, 2024).
Despite these advancements, a significant issue remains: most QNNs, with-
out careful design, can be efficiently simulated or approximated by classical
surrogate models. The review (Cerezo et al., 2023) presented strong evidence
that commonly used models with provable absence of barren plateaus are
also classically simulable. Concrete algorithms in this research line include
Pauli path simulators (Bermejo et al., 2024; Angrisani et al., 2024; Lerch
et al., 2024), tensor-network simulators (Shin et al., 2024), and learning
protocols (Landman et al., 2022; Schreiber et al., 2023; Du et al., 2024).

Applications

Practical applications of quantum neural networks for discriminative learn-

ing have spanned multiple domains. In computer vision, researchers have
demonstrated quantum approaches to image classification (Henderson et al.,
2020) and pattern recognition (ALRikabi et al., 2022). In quantum chem-
istry, QNNs have been applied to proton affinity predictions (Jin and
Merz Jr, 2024) and catalyst developments (Roh et al., 2024). Financial
applications include market trend classification (Li et al., 2023a) and fraud
detection (Innan et al., 2024). Medical applications encompass drug discov-
ery (Batra et al., 2021) and disease diagnosis (Enad et al., 2023).

4.6.2 Generative learning with QNNs

QNNs for generative tasks represent a promising avenue in quantum ma-

chine learning, offering new methodologies for generating complex data dis-
tributions. By leveraging variational quantum circuits, these models aim
to generate potentially more complex probability distributions compared to
classical counterparts, particularly in domains where high-dimensional data
or quantum properties are prominent. We refer the readers to Tian et al.
(2023) for a survey of QNNs in generative learning.
176 CHAPTER 4. QUANTUM NEURAL NETWORKS

Model designs
Researchers have developed various QNN architectures tailored for gener-
ative tasks. Quantum circuit Born machines (QCBMs) (Benedetti et al.,
2019a) are one of the pioneering models, utilizing parameterized quantum
circuits to generate discrete probability distributions. Quantum generative
adversarial networks (Lloyd and Weedbrook, 2018) extend the adversarial
framework to the quantum domain, where quantum generators and discrim-
inators compete to learn complex distributions. Quantum Boltzmann ma-
chines (Amin et al., 2018) are another notable model, employing quantum
devices to prepare Boltzmann distributions for estimating target discrete
distributions. Additionally, quantum autoencoders (Romero et al., 2017)
have been proposed for tasks like quantum state compression and recon-
struction, offering potential advantages in quantum information processing.
Recently, quantum diffusion models (Zhang et al., 2024b; Kölle et al., 2024)
have been proposed for generating quantum state ensembles or classical im-
ages. These models showcase the versatility of QNNs in addressing diverse
generative tasks.

Theoretical foundations
The theoretical understanding of generative quantum neural networks has
advanced in several directions. Similar to QNNs for discriminative tasks,
quantum generative models like QCBMs face the barren plateau issue with
additional mechanisms from the Kullbach-Leibler (KL) divergence loss func-
tion (Rudolph et al., 2024). In parallel, QCBMs are more efficient in the
data-limited regime than the other classical generative models (Hibat-Allah
et al., 2024). Besides, Gao et al. (2018) proved the existence of quantum
generative model that is more capable of representing probability distri-
butions compared with classical generative models, which has exponential
speedup in learning and inference. Similarly, Gao et al. (2022) proved the
separation in expressive power between a class of widely used generative
models, known as Bayesian networks, and its minimal quantum-inspired ex-
tension. Du et al. (2022d) analyzed the generalization bounds of QCBMs
and QGANs under the maximum mean discrepancy loss.

Applications
Generative QNNs have shown potential in various practical applications. In
finance, they have been used to model complex financial data distributions
and generate synthetic financial datasets, demonstrating better performance
4.6. BIBLIOGRAPHIC REMARKS 177

than classical models in certain scenarios (Alcazar et al., 2020; Zhu et al.,
2022). In the domain of quantum physics, quantum generative models have
been applied for quantum state tomography and quantum simulation, aid-
ing in the understanding of quantum systems (Benedetti et al., 2019b). In
image generation, QGANs have been employed to produce high-quality im-
ages, showcasing their capability in handling complex visual data (Huang
et al., 2021b). Furthermore, quantum generative models have been explored
for drug discovery, where they can potentially accelerate the process by effi-
ciently exploring large chemical spaces (Li et al., 2021). These applications
highlight the broad potential of QNNs in generative tasks across different
domains.
178 CHAPTER 4. QUANTUM NEURAL NETWORKS
Chapter 5

Quantum Transformer

Transformers, introduced by Vaswani (2017), have become one of the most

important and widely adopted deep learning architectures in modern AI.
Transformers were first developed to improve previous architectures for nat-
ural language processing on the ability to handle long-range dependencies
and capture intricate relationships in data. Unlike previous sequential mod-
els, such as recurrent neural networks, which process information in a step-
by-step manner, transformers use a mechanism called self-attention to cap-
ture correlations among all elements in a sequence simultaneously. This par-
allel processing capability significantly reduces training time and improves
learning performance.
Despite its many advantages, the transformer architecture has several
drawbacks, particularly the required computational resources. As discussed
in previous chapters, quantum computing provides unique advantages over
classical computing in certain applications by leveraging quantum phenom-
ena such as superposition, entanglement, and interference. These capa-
bilities have inspired researchers to explore whether integrating quantum
computing with Transformers could lead to superior performance compared
to their classical counterparts in specific tasks.
To figure out this question, in this chapter, we start by introducing
the mechanism of Transformers in Chapter 5.1. We then illustrate how to
construct a quantum Transformer on a fault-tolerant quantum computer in
Chapter 5.2. We also analyze the runtime of quantum transformers com-
bined with numerical observations in Chapter 5.3, demonstrating a quadratic
speedup over the classical counterpart.

179
180 CHAPTER 5. QUANTUM TRANSFORMER

5.1 Classical Transformer

The transformer architecture is designed to predict the next token (formally
present in Chapter 5.1.1) in a sequence by leveraging sophisticated neural
network components. Its modular design—including residual connections,
layer normalization, and feed-forward networks (FFNs) as introduced in
Chapter 4.1—makes it highly scalable and customizable. This versatility
has enabled its successful application in large-scale foundation models across
diverse domains, including natural language processing, computer vision,
reinforcement learning, robotics, and beyond.
The full architecture of Transformer is illustrated in Figure 5.1. Note
that while the original paper by Vaswani (2017) introduced both encoder and
decoder components, contemporary large language models primarily adopt
decoder-only architectures, which have demonstrated superior practical per-
formance. Therefore, in the remainder of this section, we focus on detailing
the implementation of each building block and discussing the optimization
of decoder-only Transformer architectures. To deepen the understanding,
a toy example of a classical Transformer with the code demonstration is
provided in Chapter 5.4.

5.1.1 Tokenization and embedding

To handle sequential data, such as natural language, Transformers employ
tokenization to convert it into discrete units. This preprocessing step makes
the data compatible with computational models and optimizes it for paral-
lel processing, particularly on GPUs. More concisely, Tokenization breaks
a sentence into smaller pieces called tokens, which could be words, sub-
words, or even characters, depending on the tokenization strategy. For ex-
ample, the sentence “Transformers are amazing!” might become tokens like
(“Transform”, “ers”, “are”, “amazing”, “!”) if subwords are used. Modern
tokenization methods (Sennrich et al., 2016; Kudo and Richardson, 2018;
Mielke et al., 2021) enable sophisticated mapping of complex inputs into
token spaces.
For Transformer, tokens are mapped to high-dimensional real vector rep-
resentations via embedding (Vaswani, 2017), as highlighted by the solid box
“Embeddings/Projections” in Figure 5.1. Let dtoken denote the dictionary’s
token count and dmodel represent the embedding vector dimension. We de-
fine the set containing all token embedding vectors in the dictionary as

W := {Wj ∈ Rdmodel : Wj is the embedding of token j ∈ [dtoken ]}.

5.1. CLASSICAL TRANSFORMER 181

Figure 5.1: A standard Transformer architecture, showing an en-

coder on the left, and a decoder on the right. Image by Daniel Voigt
Godoy under CC BY. The encoder processes the source sequence through
multiple layers of multi-headed self-attention and feed-forward networks,
augmented with residual connections, layer normalization, and positional
encodings. The decoder incorporates masked multi-headed self-attention to
process the target sequence and multi-headed cross-attention to integrate
information from the encoder. The output is passed through a feed-forward
network and a final linear layer to generate predictions.

An ℓ-length sentence is represented as a sequence of vectors {Sj }ℓj=1 , where

Sj ∈ W. Mathematically, this sequence can be interpreted as a real matrix
S ∈ Rℓ×dmodel whose j-th row Sj representing the j-th token.
182 CHAPTER 5. QUANTUM TRANSFORMER

5.1.2 Self-attention
Self-attention is a core building block of the transformer architecture, which
captures intrinsic correlations among tokens. By allowing each token in a
sequence to attend to every other token, Transformer generates attention
matrices via the inner-product operations, encoding complex inter-token
relationships into a transformative vector representation, colloquially termed
“scaled dot-product attention”. The generated attention matrices highlight
how relevant each part of the input is to every other part. This allows
Transformers to handle contextual dependencies across a variety of data
structures.
The self-attention mechanism, as highlighted by the blue or red box
in Figure 5.1, involves three parameterized weight matrices: Wq , Wk ∈
Rdmodel ×dk and Wv ∈ Rdmodel ×dv .

Remark
Following conventions (Vaswani, 2017), we use the notation d to spec-
ify dmodel , dk , and dv in the rest of this chapter, i.e., d := dmodel =
dk = dv . This is a widely used setting in practice.

Given a sequence S ∈ Rℓ×d , we define the three new matrices after

interacting it with three parameterized weight matrices Wq , Wk , Wv , i.e.,

• Query matrix: Q := SWq ;

• Key matrix: K := SWk ;

• Value matrix: V := SWv .

The attention block computes the matrix Gsoft ∈ Rℓ×d via

Attention(Q, K, V ) = softmax(QK ⊤ /α0 )V =: Gsoft , (5.1)

where α0 > 0 is a scaling factor, and softmax(·)

P is a zrow-wise nonlinear
transformation such that softmax(z)j := e /( k∈[ℓ] e k ) for z ∈ Rℓ and
zj

j ∈ [ℓ]. The row-wise softmax application

√ ensures the controlled attention
distribution. The scaling factor α0 = d empirically prevents excessive
value amplification, particularly when input matrix rows have zero mean
and unit standard deviation.
5.1. CLASSICAL TRANSFORMER 183

For decoder-only architectures, masked self-attention is employed, strate-

gically hiding tokens subsequent to the current query token, i.e.,
(
0 k ≤ j,
Mjk = (5.2)
−∞ k > j.

Conceptually, the mask M is applied to the scaled dot product QK ⊤ /α0

in Eq. (5.1) before the softmax operation. Specifically, the matrix in the
softmax operation is modified as QK ⊤ /α0 + M .
Another crucial technique in Transformer is the multi-head attention,
which further extends the self-attention mechanism by computing and con-
catenating multiple attention matrices, enabling parallel representation learn-
ing across different subspaces. In practice, the embedding dimensions are
often much larger (e.g., d = 512 or d = 768), with multiple attention heads
working simultaneously, each capturing distinct relationships between words
in the sequence. This mechanism plays a crucial role in modern AI, as it
allows words to dynamically interact with one another within the context of
the sequence.
While multi-head attention is a pivotal advancement in Transformer ar-
chitectures, we will not delve into its details here, as the quantum Trans-
former implementations presented below primarily support single-head at-
tention. Nonetheless, these techniques remain essential in classical AI and
are promising directions for future developments in quantum Transformers.

5.1.3 Residual connection

Residual connections (the arrows bypassing the main components, such as
the attention and feed-forward layers in Figure 5.1), paired with layer nor-
malization (green box in the figure), provide crucial architectural flexibility
and robustness. By enabling direct information flow between layers, they
mitigate challenges in training deep neural networks (He et al., 2015; Ba
et al., 2016).
For the j-th token in an ℓ-length sentence, the residual connection gen-
erates Gsoft
j + Sj ∈ Rd for ∀j ∈ [ℓ], which is subsequently normalized to
standardize the vector representation. Let

d d
1 X soft X
s̄j := ( (Gjk + Sjk ), . . . , jk + Sjk )) ∈ R ,
(Gsoft d
d
k=1 k=1
184 CHAPTER 5. QUANTUM TRANSFORMER
q P
1 d soft + S − s̄ ) )2 . The complete residual connec-
where ς := d k=1 ((Gj j j k
tion with the layer normalization LN(·, ·) can be expressed as

Gsoft
j + Sj − s̄j
LNγ,β (Gsoft
j , Sj ) = γ + β, (5.3)
ς
where γ and β denote the scale and bias parameters, respectively.

5.1.4 Feed-forward network

Recall the definitions of fully-connected neural networks (FFN) in Chap-
ter 4.1. Transformers employ a two-layer fully connected transformation
(yellow box in Figure 5.1) to proceed with the output of residual connec-
tion, i.e.,

FFN(LN(zj , Sj )) = σ(LN(Gsoft
j , Sj )M1 + b1 )M2 + b2 , (5.4)
′ ′
where M1 ∈ Rd×d , M2 ∈ Rd ×d are linear transformation matrices, and b1 , b2
are vectors. In most practical cases, d′ = 4d. Here σ(x) is an activation
function, such as tanh(x) and ReLU(x) = max(0, x). Another activation
function that has been widely used in Transformers is the Gaussian Error
Linear Units function (GELU), i.e.,
  
1 x
GELU(x) = x · 1 + erf √ .
2 2

Single-head and single-block Transformer

By integrating all ingredients introduced in Chapters 5.1.1, we reach

out the explicit form of single-head and single-block Transformer, i.e.,

Transformer(S, j) := LN(FFN(LN(Attention(S, j)))). (5.5)

For the final output, i.e., to predict the next token, one can imple-
ment the softmax function to make the vector into a distribution
Pr(·|S1 , . . . , Sj−1 ), where the dimension is the size of the token dic-
tionary dtoken , and sample from this distribution.

In modern architectures, multiple computational blocks are applied it-

eratively. Similar to multi-head attention, we will not explore this in detail
here, as the quantum Transformer implementations introduced below pri-
marily support single-head attention.
5.1. CLASSICAL TRANSFORMER 185

5.1.5 Optimization and inference

Upon the architecture of Transformer, its optimization involves training

the model to achieve high performance on a given task. When applied
to language processing tasks, a feasible loss function of the Transformer is
the cross entropy between the predicted probability distribution and the
correct distribution. Mathematically, given a ℓ-length sequence {S1 , . . . , Sℓ }
as input, the loss function can be written as

ℓ
1X
L=− Pr(Sj |S1 , . . . , Sj−1 ), (5.6)
ℓ
j=1

where Pr(Sj |S1 , . . . , Sj−1 ) is the predicted probability of the correct Sj com-
ing out of the softmax layer, based on the previous tokens.
This process of training Transformers can be achieved by using Adam
optimizer (Kingma and Ba, 2015). Learning rate schedules, such as warm-up
followed by decay, can provide stable and effective convergence.
After optimization, we could use the trained Transformer for inference,
which refers to making predictions on new data. Given a new initial sequence
′
S ′ = {S1′ , . . . , Sj−1 }, we feed it to the trained Transformer and obtain the
′
distribution Pr(Sj′ |S1′ , . . . , Sj−1 ). Then we can use a decoding strategy (e.g.,
greedy decoding or sampling) to select the token based on the highest prob-
ability or a sampling approach.
Efficient inference is crucial for deploying models in real-world appli-
cations. Speed optimization techniques, such as quantization, reduce the
precision of weights and activations to accelerate inference with minimal
accuracy loss (Jacob et al., 2018). Pruning removes redundant weights or
attention heads to reduce the model size and computational cost (Han et al.,
2015). Batching and parallelism are also critical, with batched inference al-
lowing the processing of multiple inputs simultaneously and GPU or TPU
acceleration enabling parallel computations. Efficient attention at inference,
such as caching key and value tensors, reduces redundant computations in
autoregressive tasks like text generation (Shoeybi et al., 2019).
The inference cost is up to 10 times the training cost as large language
models (LLMs) are trained once and applied millions of times (McDonald
et al., 2022; Desislavov et al., 2023). For this reason, in the next section, we
explore how to harness quantum computing to address this issue, which is
crucial from both scientific and societal perspectives.
186 CHAPTER 5. QUANTUM TRANSFORMER

5.2 Fault-tolerant Quantum Transformer

In this section, we move on to show an end-to-end transformer architecture
implementable on a quantum device, which includes all the key building
blocks introduced in Chapter 5.1, and a discussion of the potential runtime
speedups of this quantum model. In particular, here we focus on the infer-
ence process in which a classical Transformer has already been trained and
is queried to predict the single next token.
Recall that in Chapter 5.1, we suppose that the three parameterized ma-
trices in the self-attention mechanism have the same size, i.e., Wq , Wk , Wv ∈
Rd×d . Besides, the input sequence S and the matrix returned by the atten-
tion block Gsoft has the size ℓ × d. Here, we further suppose the length of
the sentence and the dimension of hidden features exponentially scale with
2, i.e., ℓ = 2N and log d ∈ N+ . This setting aligns with the scaling of quan-
tum computing, making it easier to understand. For other cases, padding
techniques can be applied to expand the matrix and vector dimensions to
conform to this requirement.
Since the runtime speedups depend heavily on the capabilities of the
available input oracles, it is essential to specify the input oracles used in
the quantum Transformer before detailing the algorithms. For the classical
Transformers, the memory access to the inputs such as the sentence and the
query, key, and value matrices is assumed. In the quantum version, we as-
sume the access of several matrices via block encoding techniques introduced
in Chapter 2.4.
Assumption 5.1 (Input oracles). Following the explicit form of the single-
head and single-layer Transformer in Eqn. (5.5), there are five parameterized
weight matrices, i.e., Wq , Wk , Wv ∈ Rd×d in the attention block, as well
′ ′
as M1 ∈ Rd ×d and M2 ∈ Rd×d in FFN. Note that here, M1 and M2 are
actually the transpose of parameterized matrices in the classical transformer.
Quantum Transformer assumes access to these five parameterized weight
matrices, as well as the input sequence S ∈ Rℓ×d via block encoding.
Mathematically, given any A ∈ {Wq , Wk , Wv , M1 , M2 , S} corresponding
to an N -qubit operator, α, ε ≥ 0 and a ∈ N, there exists a (a + N )-qubit
unitary UA referring to the (α, a, ε)-block-encoding of A with
∥A − α(⟨0|⊗a ⊗ I2N )UA (|0⟩⊗a ⊗ I2N )∥ ≤ ε, (5.7)
where ∥ · ∥ represents the spectral norm.
Under this assumption, we know that the quantum Transformer can ac-
cess US , UWq , UWk , and UWv corresponding to the (αs , as )-encoding of S and
5.2. FAULT-TOLERANT QUANTUM TRANSFORMER 187

(αw , aw )-encodings of Wq , Wk and Wv , respectively. Moreover, the quantum

Transformer can access (αm , am )-encodings UM1 and UM2 corresponding two
′ ′
weight matrices M1 ∈ Rd ×d and M2 ∈ Rd×d in FFN.

Remark
For simplicity and clarity, in the following, we consider the perfect
block encoding of input matrices without errors, i.e., ε = 0. As such,
we will not explicitly write the error term of the block encoding, and
use (α, a) instead of (α, a, 0). The output of the quantum transformer
is a quantum state corresponding to the probability distribution of
the next token. The complete single-layer structure is described in
Figure 5.2.

Under the above assumptions about access to the read-in protocols, the
following theorem indicates how to implement a single-head and single-block
transformer architecture in Eqn. (5.5) on the quantum computer.

Theorem 5.2 (Quantum Transformer, informal). For a single-head and

single-block Transformer depicted in Figure 5.2, suppose its embedding di-
mension is d and its input sequence S has the length ℓ = 2N . Under As-
sumption 5.1 about the input oracles, for the index j ∈ [ℓ], one can construct
an ϵ-accurate quantum circuit for the quantum state proportional to

d
X
Transformer(S, j)k |k⟩ , (5.8)
k=1

by using Õ(dN 2 αs αw log2 (1/ϵ)) times of the input block encodings.

We show this theorem by explicitly designing the quantum circuit for

each computation block of the transformer architecture in a coherent way,
i.e., without intermediate measurement. In addition, a subsequent trans-
formation of the amplitude-encoded state, followed by measurement in the
computational basis, yields the index of the next predicted token based on
the probabilities modeled by the Transformer architecture.
Roadmap. In the remainder of this section, we detail the implementation
of quantum Transformers, proceeding from the bottom to the top as illus-
trated in Figure 5.2. Specifically, we first demonstrate how to quantize the
attention block Attention(S, j) in Chapter 5.2.1. Next, we present the quan-
tization of residual connections and layer normalization operations (i.e., the
188 CHAPTER 5. QUANTUM TRANSFORMER

Quantum feed-forward network with an activation function

Layer Norm 𝜎 and an input vector 𝜓
<latexit sha1_base64="4du6gqwST5Q0LAsMEYC/GPRvMsU=">AAACWHicbZDPThRBEMZrR4VdFFjwyKUjMVkuywwH9EJCYqJcTDBxgWRnnfT09Ayd6T+T7hrCZtwn8RV8Gm+oR98CD/bsYuKClXTy5VdV+bq+tJLCYRjedIJHj5+srHZ7a0+frW9s9re2z5ypLeMjZqSxFyl1XArNRyhQ8ovKcqpSyc/T8k3bP7/i1gmjP+K04hNFCy1ywSh6lPTfxq5WSVMeRbNPGYlTUcjB++SAxCwzSGInCkWJJ9FfUjmx147ZvaQkn8vYUl1InvR3w2E4L/JQRHdi93g//f3u1xdymvRv48ywWnGNTFLnxlFY4aShFgWTfLYW145XlJW04GMvNVXcTZr5vTPy0pOM5Mb6p5HM6b8bDVXOTVXqJxXFS3e/18L/9cY15q8njdBVjVyzhVFeS4KGtOGRTFjOUE69oMwK/1fCLqmlDH3ESy7XuadLZzStHRoj3cynFd3P5qE4OxhGh8PDDz62ASyqCzvwAgYQwSs4hhM4hREw+Arf4Af87HwPIFgNeovRoHO38xyWKtj+AwMeuVU=</latexit>

X d
M2 · (M1 · ) k |ki
k=1
Feed-Forward Network
Quantum residual connection with layer normalization for
the 𝑗-th token <latexit sha1_base64="C54unuoyOhuDss2m+vMy2PsmPT4=">AAACJHicbVA9SyRBEO3xvFPXu3PV0KRRDvbg2JsxUEEE4QINRBRvVdhZh57emrWdnp6hu0ZcxvklRib+FRMDPzAwMfJnXHC9uwZ+PSh4/V4VXfXCTAqDrvvgDH0a/vxlZHSsMv712/eJ6uTUrklzzaHBU5nq/ZAZkEJBAwVK2M80sCSUsBfGf3r+3jFoI1L1F7sZtBLWUSISnKGVguqyb/IkKOIVrzxoUx/hBIuNzbK2dlAMHiaNsCyDo190Jzj6GcT0lMa+ZqojIajOuXW3D/qeeM9kbvV3+G/t6YxuBdVbv53yPAGFXDJjmp6bYatgGgWXUFb83EDGeMw60LRUsQRMq+gfWdIfVmnTKNW2FNK++nKiYIkx3SS0nQnDQ/PW64kfec0co6VWIVSWIyg++CjKJcWU9hKjbaGBo+xawrgWdlfKD5lmHG2uFRuC9/bk92R3vu4t1Be2bRo1MsAomSGzpEY8skhWyTrZIg3CyTm5JNfkxrlwrpw7537QOuQ8z0yTV3Ae/wM5TajJ</latexit>

Xd
Layer Norm LN(Gsoft
j , Sj )k |ki
k=1

(Masked) Self Attention Quantum self-attention matrix

<latexit sha1_base64="v2fGDNa3BOsOpWjhHpBSFWSOLbQ=">AAACQ3icbVC7bhNBFJ0NARyHgIGSZpQIyWmc3RSB0pKLRKKxhe1E8jrW3fFsPMo81jN3o5jVfhAfQkVBh8gnIDpEi8Ss7SIPjjTS0Tn3NSfJpHAYhjfBxqPNx0+e1rbq2892nr9ovHw1dCa3jA+YkcaeJeC4FJoPUKDkZ5nloBLJT5PLTuWfXnHrhNF9XGR8rOBCi1QwQC9NGp3j8yJWgDOrCmdSLEsaV1M1n8/pbUPBddnsfTjvH8QgsxlMwn1fOTVIh5PGXtgKl6APSbQme+3ap+9fP3a3upPGz3hqWK64RibBuVEUZjguwKJgkpf1OHc8A3YJF3zkqQbF3bhYfrakb70ypamx/mmkS/V2RwHKuYVKfGV1vrvvVeL/vFGO6ftxIXSWI9dstSjNJUVDq+ToVFjOUC48AWaFv5WyGVhg6PO9s6WajcZIV9Z9NtH9JB6S4WErOmod9XxITbJCjbwhu6RJIvKOtMkJ6ZIBYeQz+UZ+kJvgS/Ar+B38WZVuBOue1+QOgr//AD/HtY8=</latexit>

Gsoft := softmax(QK T /↵0 ) · V

Block Encoding
Block encoding of the input matrices
" # " # " # "
<latexit sha1_base64="xJizW/lvUxlTt70q/Zo7Q+r/hGk=">AAAC3nicnZJBaxNBFMdnV2vbtWqqRy+DwVKKrLu2tB4LXgQvLZq0kA3x7eQlGTozu8y8bRuWHLx4UEqv/Vze/CDenaRBtBEKfTDMn/97P+bNm8lLJR0lyc8gvHd/6cHyymr0cO3R4yeN9adtV1RWYEsUqrDHOThU0mCLJCk8Li2CzhUe5SfvpvmjU7ROFuYTjUvsahgaOZACyFu9xq/MosEzUWgNpl9nYC2MHVkkMZrUabw9ibIch9LUuQay8nwSfXydgSpHwDf4VpZFW9M9ytDTf0peLUCHd4E+3AVq3w7FvUYziZNZ8EWRzkWTzeOg1/iR9QtRaTQkFDjXSZOSujVYkkKhn1HlsARxAkPseGlAo+vWs+eZ8Jfe6fNBYf0yxGfu30QN2rmxzn2l73Dkbuam5v9ynYoGb7u1NGVFaMT1QYNKcSr49K15X1oUpMZegLDS98rFCCwI8j8i8kNIb155UbTfxOluvHu409zfnI9jhT1nL9gmS9ke22fv2QFrMRF0gi/Bt+B7+Dn8Gl6El9elYTBnnrF/Irz6DaNh3uA=</latexit>

#
S/↵ ⇤ Q/↵ ⇤ K/↵ ⇤ V /↵ ⇤
, , , .
Input sequence Weight matrices ⇤ ⇤ ⇤ ⇤ ⇤ ⇤ ⇤ ⇤
Wq , Wk , Wv 2 Rd⇥d
<latexit sha1_base64="fFKNJu8fRJYkhs8SafCmd5s3XAU=">AAACDnicbVC7TsMwFHXKo6XlUWBksagqdUBVwlAYK1gYC6IPqQmR4zitVccJtlOpivoFMPArLAwgxMrMxm8wM+A+Bmg50pWOzrlX997jxYxKZZqfRmZldW09m9vIFza3tneKu3stGSUCkyaOWCQ6HpKEUU6aiipGOrEgKPQYaXuD84nfHhIhacSv1SgmToh6nAYUI6Ult1huu7dHbXega2hTDu0Qqb7npVfjm9S3FQ2JhP7YLZbMqjkFXCbWnJTqha+zbOH+u+EWP2w/wklIuMIMSdm1zFg5KRKKYkbGeTuRJEZ4gHqkqylHeo+TTt8Zw7JWfBhEQhdXcKr+nkhRKOUo9HTn5Fq56E3E/7xuooJTJ6U8ThTheLYoSBhUEZxkA30qCFZspAnCgupbIe4jgbDSCeZ1CNbiy8ukdVy1atXapU6jAmbIgQNwCCrAAiegDi5AAzQBBnfgETyDF+PBeDJejbdZa8aYz+yDPzDefwAVYp8S</latexit>

<latexit sha1_base64="8CBtkLGuEFB1brlPUmdPFf2FYsY=">AAACBHicbVC7TsMwFHXKq5RXgbGLRYXUqUoYChNUYmFC5dGH1ITKcZzWquNEtoNURR1Y+BUWBhBi5QfY2Nj6BSz8AE7bAVqOdKWjc+7Vvfe4EaNSmeankVlYXFpeya7m1tY3Nrfy2zsNGcYCkzoOWShaLpKEUU7qiipGWpEgKHAZabr909Rv3hIhaciv1SAiToC6nPoUI6WlTr5wZVMO7QCpnusml8Ob5NxWNCASesNOvmiWzTHgPLGmpHgy+hp9vx83a538h+2FOA4IV5ghKduWGSknQUJRzMgwZ8eSRAj3UZe0NeVI73GS8RNDuK8VD/qh0MUVHKu/JxIUSDkIXN2ZXitnvVT8z2vHyj9yEsqjWBGOJ4v8mEEVwjQR6FFBsGIDTRAWVN8KcQ8JhJXOLadDsGZfnieNg7JVKVcuzGK1BCbIggLYAyVggUNQBWegBuoAgzvwAJ7As3FvPBovxuukNWNMZ3bBHxhvP7d0nUY=</latexit>

N ⇥d
S2R
0 0
<latexit sha1_base64="NMDQE8ww6vmGdJj1DX5d3rFZ6CA=">AAACVHicbVDLSsNAFJ2mvp9Vl24GRXQhJelCXYpu3AgqVoWmhslkooOTmTBzI5YQ3PgTLt35BX6GSx/fogsnrYi1XrhwOPdczr0nTAU34LrvFac6NDwyOjY+MTk1PTNbm5s/MSrTlDWpEkqfhcQwwSVrAgfBzlLNSBIKdhpe7Zbz02umDVfyGDopayfkQvKYUwKWCmo7+4GHfS6xnxC4DMP8qDjPo1XsA0+YwVGxjveDxqDiR7BaBLVlt+52Cw8C7xssb1dXbp/u7x4OgtqHHymaJUwCFcSYluem0M6JBk4FKyb8zLCU0CtywVoWSmKN2nn31wKvWCbCsdK2JeAu+3sjJ4kxnSS0yvJe83dWkv/NWhnEW+2cyzQDJmnPKM4EBoXL4HDENaMgOhYQqrm9FdNLogkFG2+fy01s2b438tIOlBKmTMv7m80gOGnUvY36xqGNbQ31agwtoiW0hjy0ibbRHjpATUTRI3pGr+it8lL5dKrOcE/qVL53FlBfOTNfT5m4bg==</latexit>

M1 2 Rd ⇥d , M2 2 Rd⇥d

Figure 5.2: Overview of the single-layer decoder-only quantum

transformer. A quantum transformer consists of a self-attention and
a feed-forward network sub-layer, incorporating residual connections with
layer normalization. The inputs of the quantum transformer are block en-
codings of matrices for the input sequence and pre-trained weights, from
which the relevant matrices for the transformer are constructed (query Q,
key K, and value V ). Each of the components accepts the block encoding
from the prior component as the input and prepares a block encoding of the
target matrix using quantum linear algebra as the output.

operation LN(Attention(S, j)) in Eqn. (5.5)) in Chapter 5.2.2. Last, we ex-

hibit the quantization of the fully connected neural network to complete the
computation LN(FFN(LN(Attention(S, j)))) in Chapter 5.2.3. This end-to-
end approach ensures that the generated quantum state corresponds to the
one described in Eqn. (5.8).

5.2.1 Quantum self-attention

We now describe how to achieve the quantum self-attention block, aiming
to complete the computation

Attention(Q, K, V ) = softmax(QK ⊤ /α0 )V =: Gsoft

5.2. FAULT-TOLERANT QUANTUM TRANSFORMER 189

in Eqn. (5.1) on quantum computers. More specifically, under Assump-

tion 5.1, the quantum self-attention block outputs a block encoding of a
matrix G whose j-th row is the same as the output of the classical attention
block, as described in the following theorem.
Theorem 5.3 (Quantum self-attention). Let α0 = αs2 αw 2 . For the index

j ∈ [ℓ], one can construct a
block encoding of a matrix G such that Gj⋆ =
Gsoft
j := (softmax QK ⊤ /α0 V )j⋆ .

Remark
For quantum self-attention, we make a slight change by setting the
scaling factor α0 = αs2 αw2 for the following reasons. The first is that
√
the usual setting α0 = 1/ d is chosen somehow in a heuristic sense,
and there are already some classical works considering different scal-
ing coefficients which may even achieve better performance (Yang
et al., 2022; Ma et al., 2024). The second, which is more impor-
tant, is that the quantum input assumption using the block encoding
format naturally contains the normalization factor α which plays a
similar role to the scaling factor. Therefore, for the quantum case in
the context of our work, it suffices to use α directly.

The implementation of the quantum self-attention block can be decom-

posed into three steps:
1. Construction of the block encoding of the matrix QK ⊤ and the matrix
V given access to US , UWq , UWk , and UWv ;
2. Implementation of the quantum algorithm to compute the softmax
function softmax(QK ⊤ /α0 ) given access to UKQ ;
3. Multiply with V via the product of block encodings.
In what follows, we iteratively detail the implementation of each step.
Step I. The construction of the block encoding of matrix QK ⊤ and V builds
upon the employment of Fact 2.23. That is, given access to (α, a)-encoding
UA of matrix A and (β, b)-encoding UB of matrix B, an (αβ, a + b)-encoding
can be constructed for the matrix AB. This result leads to the efficient
construction of the block encodings of QK ⊤ and V , i.e.,
- For the matrix V = Wv S, it is straightforward to set A = Wv and
B = S to construct the (αv , av )-encoding UV , where αv = αs αw and
av = as + aw .
190 CHAPTER 5. QUANTUM TRANSFORMER

- For the matrix QK ⊤ , we first use Fact 2.23 to construct the (αq , aq )-
encoding UQ and (αk , ak )-encoding UK with Q = Wq S and K = Wk S,
respectively. Then, we use Fact 2.23 again to construct the (α0 , a0 )-
encoding UQK ⊤ of QK ⊤ , where α0 = αs2 αw2 and a = 2a + 2a . Note
0 s w
†
that for a real matrix M and its block encoding unitary UM , UM is
the block encoding of M .⊤

Step II. Once the unitary UQK ⊤ is prepared, we move to implement the
quantum algorithm corresponding to the softmax function, i.e., softmax(QK ⊤ /α0 ).
Note that the softmax function relies on the exponential function, which is
generally resource-intensive to implement on quantum computers. To cir-
cumvent this bottleneck, the quantum Transformer uses polynomial func-
tions to approximate the softmax function, as supported by the following
fact.

Fact 5.4. For x ∈ [−1, 1], the function f (x) := ex can be approximated with
error bound ϵ with an O(log(1/ϵ))-degree polynomial function.

The insight provided by Fact 5.4 is to use polynomial functions to ap-

proximate the softmax function, i.e., we first approximate exp ◦(QK ⊤ /α0 )
using polynomial functions, then multiply with different coefficients (nor-
malization) for each row.

Remark
The notation exp ◦(A) indicates that the exponential operation is ap-
plied elementwise to each entry of the matrix A, rather than repre-
senting a matrix exponential.
Moreover, the element-wise functions mean that functions are imple-
mented on each matrix element.

In this context, the challenge of implementing a quantized softmax func-

tion reduces to the implementation of a quantized polynomial function. The
key technique for achieving this lies in applying polynomial functions to each
element of block-encoded matrices, as detailed in the following lemma.

Lemma 5.5 (Element-wise polynomial function of block-encoded matrix).

Let N, k ∈ N. Given access to an (α, a)-encoding 2N ×2N
Pr of a jmatrix A ∈ C
and an r-degree polynomial function fr (x) = j=1 cj x , cj ∈ C for j ∈ [r],
one can construct a (C, b)-encoding
Pr of fr ◦ (A/α) by using O(r2 ) times the
input unitary, where C := j=1 |cj |, b := ra + (r − 1)N + ⌈log(r + 1)⌉.
5.2. FAULT-TOLERANT QUANTUM TRANSFORMER 191

Pr j
Moreover, for a polynomial function gr (x) = j=0 cj x with constant
term c0 , one can construct a (C ′ , b)-encoding of gr ◦ (A/α), where C ′ =
rc0 + C.

Proof of Lemma 5.5. To achieve this implementation, we construct two state-

preparation unitaries PL and PR , which act on ⌈log(r + 1)⌉ qubits such that
r q
⌈log(r+1)⌉ 1 X
PL : |0 ⟩→ √ |cj | |j⟩ , (5.9)
C j=1
r q
1 X
PR : |0⌈log(r+1)⌉ ⟩ → √ |cj |eiθj |j⟩ , (5.10)
C j=1
Pr iθj = c . These two unitaries encode the
where C = j=1 |cj | and |cj |e j
polynomial coefficients {cj } into the quantum circuit, which is needed for
block encoding via the linear combination of unitaries indicated in fact 2.21.
Note that the construction of PL and PR is efficient for small r, as the
corresponding circuit is O(r)-depth with only elementary quantum gates
(Sun et al., 2023; Zhang et al., 2022a).
For j ∈ [r], let UAj be the (1, ja + (j − 1)N )-encoding of

(A/α)◦j := (A/α) ◦ (A/α) ◦ · · · ◦ (A/α),

| {z }
j−1 times of Hadamard product

which is constructed by iteratively applying lemma 2.25. For simplicity,

these block encodings UAj can also be considered as (1, ra + (r − 1)N )-
encoding of (A/α) ◦j . Then, we construct a (ra + rN + ⌈log(r + 1)⌉)-qubit
Pr P
unitary W = j=1 |j⟩⟨j|⊗UAj +(I2⌈log(r+1)⌉ − rj=1 |j⟩⟨j|)⊗I2(ra+rN ) . Taking
the linear combination of block encodings via fact 2.21, we can implement
a (C, ra + (r − 1)N + ⌈log(r + 1)⌉)-encoding of fr ◦ (A/α).
To implement element-wise functions including constant terms, we also
need access to the block encoding of a matrix whose elements are all 1.
Notice that this matrix can be written as the linear combination of the
identity matrix and the reflection operator, i.e.,
 
X 2 N 2 X
|k⟩⟨k ′ | = I2N − (I2N − |k⟩ ⟨k ′ |) (5.11)
2 2 N
′ N
k,k ∈[2 ] ′ N
k,k ∈[2 ]
 
2 N
⊗N

⊗N
= I2N − H I2N − 2 |0 ⟩ ⟨0 | H
N N
, (5.12)
2
192 CHAPTER 5. QUANTUM TRANSFORMER

where H is the Hadamard gate. Define Uref = |0⟩⟨0| ⊗ I2N + |1⟩⟨1| ⊗

(H ⊗N (I2N − 2|0N ⟩⟨0N |)H ⊗N ). By direct computation, oneP can show that
U0 = (XH ⊗ I2N )Uref (H ⊗ I2N ) is an (2N , 1)-encoding of k,k′ |k⟩⟨k ′ |. One
can achieve the element-wise function by following the same steps as above
and taking linear combinations among U0 , . . . , UAr . One point to notice is
that we can only construct (2N , 1)-encoding of the matrix whose elements
are all 1 since the spectral norm of this matrix is 2N . Therefore, we encode
2N c0 into the state instead of c0 to amplify the constant term.

Supported by the above lemma, we can complete Step II (i.e., the quan-
tum softmax for self-attention), as shown in the following theorem.
Theorem 5.6 (Quantum softmax for self-attention, informal). Given an
(α, a)-encoding UA of a matrix A ∈ Rℓ×ℓ , a positive integer d, and an index
j ∈ [ℓ], one can prepare a state-encoding of
Xℓ q ℓ A
1 X
|Aj ⟩ := softmax(A/α)jk |k⟩ = p exp ◦ |k⟩ ,
Zj k=1 2α jk
k=1
Pℓ
where Zj = k=1 exp ◦(A/α)jk .
A
Proof sketch of Theorem 5.6. We first construct the block encoding of exp ◦( 2α ).
Note that Taylor expansion of exp(x) contains a constant term 1. This can
be achieved with lemma 5.5 and fact 5.4. Here, since we are only focusing
on the j-th row, instead of taking linear combination with the matrix whose
elements are all 1, we take sum with the matrix whose j-th row elements
are all 1 and else
√ are 0. This enables us to have a better dependency on ℓ,
i.e., from ℓ to ℓ. For index j ∈ [ℓ], let Uj : |0⟩ → |j⟩. One can achieve this
by changing Eqn. (5.12) to the following,
√
X ℓ

|j⟩⟨k| = (Uj H ⊗N − Uj I2N − 2 |0N ⟩ ⟨0N | H ⊗N ). (5.13)
2
k

Following the same steps in lemma 5.5, one can achieve the construction.
There are two error terms in this step. Denote Uf ◦(A) as the constructed
block encoding unitary. By lemma 5.5 and some additional calculation,
A
one can show that Uf ◦(A) is a block-encoding of exp ◦( 2α ). Note that
A A ⊤ †
exp ◦( 2α )jk = exp ◦( 2α )kj . With unitary Uf ◦(A) (I ⊗ Uj ) and amplitude
amplification, one can prepare a state-encoding of the target state

1 X
ℓ A
|Aj ⟩ := p exp ◦ |k⟩ , (5.14)
Zj k=1 2α jk
5.2. FAULT-TOLERANT QUANTUM TRANSFORMER 193

P
where Zj = ℓk=1 exp ◦(A/α)jk is the normalization factor of softmax func-
tion for the j-th row.

Step III. Finally, we implement the matrix multiplication with V . This can
be easily achieved by using Fact 2.23, with Uf†(QK ⊤ ) and UV . Consequently,
we obtain an encoded quantum state analogous to

ℓ
X
(softmax(QK ⊤ /α0 )V )jk |k⟩ . (5.15)
k

Combining the results of Steps I, II, and III, we are now ready to present
the proof of Theorem 5.3.

Proof of Theorem 5.3. In the first step, we construct the block encoding
of matrix QK ⊤ and V . Note that for a real matrix M and its block en-
†
coding unitary UM , UM is the block encoding of M ⊤ . By Fact 2.23, one
can construct an (α0 , a0 )-encoding UQK ⊤ of QK ⊤ , where α0 := αs2 αw 2 and

a0 = 2as + 2aw . One can also construct an (αv , av )-encoding UV of V , where

αv = αs αw and av = as + aw .
By theorem 5.6, using UQK ⊤ one can prepare a state-encoding of the
state
X ℓ q
softmax(QK ⊤ /α0 )jk |k⟩ ,
k=1
Pℓ
where Zj = k=1 exp ◦(QK ⊤ /α0 )jk . Remember that state encoding is also
a block encoding. By lemma 2.25, one can construct a block encoding of a
matrix whose j-th column is

[softmax(QK ⊤ /α0 )j1 , . . . , softmax(QK ⊤ /α0 )jℓ ]

ignoring other columns. Let this block-encoding unitary be Uf (QK ⊤ ) .

Last, by exploiting Fact 2.23 again, with Uf†(QK ⊤ ) and UV , we obtain an
encoded quantum state analogous to

ℓ
X
(softmax(QK ⊤ /α0 )V )jk |k⟩ .
k
194 CHAPTER 5. QUANTUM TRANSFORMER

Extension to implement quantum masked self-attention

Now we consider how to implement the masked self-attention, which is es-
sential for the decoder-only structure. This can be achieved by slightly
changing some steps as introduced in previous theorems.
Corollary 5.7 (Quantum masked self-attention). For the index j ∈ [ℓ],
one can construct a block encoding of a matrix Gmask such that Gmask
j⋆ =
⊤
(softmax( QK
α0 + M )V )j⋆ , where M is the masked matrix as Eqn. (5.2),
Pℓ ⊤
Zj = k=1 exp ◦( QK
α0 + M )jk .

Proof of Corollary 5.7. To achieve masked self-attention, we slightly change

the steps mentioned in theorem 5.6.
First, to approximate the exponential function, we move beyond using
a matrix where all elements in the j-th row are set to 1 while other rows
remain 0. Instead, we refine this approach by considering only the first
2⌈log(j+1)⌉ elements in the j-th row to be 1. Note that this matrix can be
achieved similarly to the original one. The encoding factor of this matrix is
2⌈log(j+1)⌉/2 .
Second, after approximating the function,
P for index j ∈ [ℓ], we multiply
the block encoding withP a projector k,k≤j |k⟩ ⟨k| to mask the elements.
Though the projector k∈S |k⟩ ⟨k| for S ⊆ [ℓ] is not unitary in general, one
can construct a block encoding of the projector by noticing that it can be
written by the linear combination of two unitaries:
X 1 1 X 
|k⟩ ⟨k| = I + 2 |k⟩ ⟨k| − I . (5.16)
2 2
k∈S k∈S
P
I). One can easily verify
Define Uproj := |0⟩ ⟨0| ⊗ I + |1⟩⟨1| ⊗ (2 k∈S |k⟩⟨k| −P
that (H ⊗ I)Uproj (H ⊗ I) is a (1, 1, 0)-encoding of k∈S |k⟩⟨k|, where H is
the Hadamard gate. The following steps follow the same with theorem 5.6
and theorem 5.3.

One may further achieve the multi-head self-attention case by using the
linear combination of unitaries.

5.2.2 Quantum residual connection and layer normalization

In this subsection, we discuss how to implement the residual connection
with layer normalization on a quantum computer. We continue based on
the result in theorem 5.3 to implement the Layer Norm block shown in
Figure 5.2.
5.2. FAULT-TOLERANT QUANTUM TRANSFORMER 195

Theorem 5.8 (Quantum residual connection with layer normalization).

Given access to the block encoding of the matrix G in Theorem 5.3, One can
construct a quantum-encoded state
d
X d
1 X soft
LN(Gsoft
j , Sj )k |k⟩ = (Gjk + Sjk − s̄j ) |k⟩ ,
ς
k=1 k=1

Pd qP
1 soft d soft
where s̄j := d k=1 (Gjk + Sjk ) and ς := k=1 (Gjk + Sjk − s̄j )2 .

Proof of sketch of Theorem 5.8. As shown in theorem 5.3, we can construct

a block-encoding of a matrix G whose j-th row is the same row as that of
Gsoft . By Assumption 5.1, we are given Us which is an (αs , as )-encoding of
S. By Lemma 2.24 with the state preparation pair (P, P ) such that
1 √ √
P |0⟩ = √ ( αg |0⟩ + αs |1⟩), (5.17)
αg + αs

one can construct a quantum circuit Ures which is an (αg + αs , ag + 1)-

encoding of an ℓ × d matrix whose j-th row is the same as that of Gsoft + S.
Now we consider how to create a block encoding of a diagonal matrix s̄j ·I,
P
where s̄j := d1 dk=1 (Gsoft jk + Sjk ). Let us define a unitary H
log d := H ⊗ log d .

Note that H log d is a (1, 0, 0)-encoding of itself, and the first column of H log d
is √1d (1, . . . , 1)⊤ . By fact 2.23, one can multiply Gsoft + S with H log d to
√
construct a block encoding of an ℓ × d matrix, whose (j, 1)-element is ds̄i .
One can further move this element to (1, 1) by switching the first row with
the j-th row. By tensor product √ with the identity I of log d qubits, one can
construct a block encoding of ds̄i · I.
With Uj : |0⟩ → |j⟩, one can prepare the state
s P 2
d
X
† 1 k ψk
Ures (I ⊗ Uj ) |0⟩ |0⟩ = |0⟩ ψk |k⟩ + 1 − |1⟩ |bad⟩ .
αg + αs (αg + αs )2
k=1
(5.18)

By the diagonal block encoding of amplitudes mentioned as fact 2.28, this

can be converted to a block encoding of the diagonal matrix diag(Gj1 +
Sj1 , . . . , Gjd + Sjd ).
By taking the linear combination as fact 2.24 with state preparation pair
(P1 , P2 ), where
1 1
P1 |0⟩ = q √ (|0⟩ + √d |1⟩) (5.19)
1 + 1/ d
196 CHAPTER 5. QUANTUM TRANSFORMER

and
1 1
P2 |0⟩ = q √ (|0⟩ − √d |1⟩), (5.20)
1 + 1/ d

one can construct a block encoding of diag(Gj1 +Sj1 − s̄j , . . . , Gjd +Sjd − s̄j ),
and we call it ULN . Then the unitary ULN (I ⊗ H log d ) is an state-encoding
of the state
d
1 X soft
(Gjk + Sjk − s̄j ) |k⟩ ,
ς
k=1
qP
d soft
where ς := k=1 (Gjk + Sjk − s̄j )2 .

5.2.3 Quantum feedforward neural network

We turn our attention to the third main building block of the transformer
architecture, the feed-forward neural network. This block often is a rela-
tively shallow neural network with linear transformations and ReLU acti-
vation functions (Vaswani, 2017). More recently, activation functions such
as the GELU have become popular, being continuously differentiable. We
highlight that they are ideal for quantum Transformers, since the QSVT
framework requires functions that are well approximated by polynomial
functions. Functions like ReLU(x) = max(0, x) can not be efficiently ap-
proximated. The GELU is constructed from the error function, which is
efficiently approximated as follows.

Fact 5.9 (Polynomial approximation of error function (Low, 2017)). Let

R kx 2
ϵ > 0. For every k > 0, the error function erf(kx) := √2π 0 e−t dt can
be approximated with error up to ϵ by a polynomial function with degree
O(k log( 1ϵ )).

This lemma implies the following efficient approximation of the GELU

function with polynomials.

Corollary 5.10 (Polynomial approximation of GELU function). Let ϵ > 0

and λ ∈ O(1). For every k > 0 and x ∈ [−λ, λ], the GELU function
GELU(kx) := kx · 21 (1 + erf( √
kx
2
)) can be approximated with error up to ϵ by
a polynomial function with degree O(k log( kλ
ϵ )).

Proof of Cororllary 5.10. It suffices to approximate the error function with

ϵ
precision kλ by fact 5.9.
5.2. FAULT-TOLERANT QUANTUM TRANSFORMER 197

In the following theorem, we consider how to implement the two-layer

feedforward network on quantum computers. As mentioned, the GELU func-
tion is widely used in transformer-based models and we explicitly consider
it as the activation function in the theorem. Cases for other activation func-
tions like sigmoid follow the same analysis. An example is the tanh(x) func-
tion, which can be well approximated by a polynomial for x ∈ [−π/2, π/2]
(Guo et al., 2024b).

Theorem 5.11 (Two-layer feedforward network with GELU function, in-

formal). Assume we have access to (α, a)-state encoding of an N -qubit state
PN
|ψ⟩ = 2k=1 ψk |k⟩, where {ψk } are real and ∥ψ∥2 = 1. Further, assume ac-
′
cess to (αm , am )-encodings UM1 and UM2 of weight matrices M1 ∈ Rd ×d and
′
M2 ∈ Rd×d . Let the activation function be GELU(x) := x · 12 (1 + erf( √x2 )).
One can prepare a state-encoding of the state

1 X 
d
|ϕ⟩ = M2 · GELU(M1 · ψ) |k⟩ , (5.21)
C k
k=1

where C is the normalization factor.

Proof of sketch of Theorem 5.11. We have

1 e ,
(I2a ⊗ UM1 )(I2am ⊗ Uψ ) |0a+am +N ⟩ = |0a+am ⟩ M1 |ψ⟩ + |⊥⟩ (5.22)
ααm

where |⊥⟩e is an unnormalized orthogonal state. For the case d′ ≥ ℓ, this can
be achieved by padding ancilla qubits to the initial state. By fact 2.28, one
can construct a block encoding of the diagonal matrix diag((M1 ψ)1 , . . . , (M1 ψ)d′ ).
Note that the GELU function does not have a constant term, and is suit-
able to use the importance-weighted amplitude transformation as in Rat-
tew and Rebentrost (2023). Instead of directly implementing the GELU
function, we first implement the function f (x) = 21 (1 + erf( √x2 )). Note
that the value of |erf(x)| is upper bounded by 1. By fact 2.28 with func-
tion 14 (1 + erf(ααm √x2 )), one can construct a block encoding of matrix
diag(f (M1 ψ)1 , . . . , f (M1 ψ)d′ ).
Let the previously constructed block-encoding unitary be Uf (x) . We have

1 X
Uf (x) (I ⊗ UM1 )(I ⊗ Uψ ) |0⟩ |0⟩ = |0⟩ f′ ⟩ ,
GELU(M1 ψ)k |k⟩ + |⊥
2ααm
k
(5.23)
198 CHAPTER 5. QUANTUM TRANSFORMER

f′ ⟩ is an unnormalized orthogonal state. Finally, by implementing

where |⊥
the block-encoding unitary UM2 , we have
(I ⊗ UM2 )(I ⊗ Uf (x) )(I ⊗ UM1 )(I ⊗ Uψ ) |0⟩ |0⟩
d 
X 
C f′′ ⟩ ,
= 2
|0⟩ M 2 · GELU(M 1 · ψ) |k⟩ + |⊥ (5.24)
2ααm k
k=1

e ′′ ⟩ is an unnormalized orthogonal
where C is the normalization factor, and |⊥
state.

Remark
The quantum feedforward network discussed in this subsection is a
quantum implementation of the classical feedforward network under
the input assumption of block encoding, which is essentially different
from the quantum analog of neural networks introduced in chapter 4.

5.3 Runtime Analysis with Quadratic Speedups

In this section, we provide a combined analytical and numerical analysis to
explore the potential of a quantum speedup in time complexity.

5.3.1 Overview
Having the quantum implementation of self-attention, residual connection,
layer normalization, and feed-forward networks, we are able to construct the
quantum transformer by combining these building blocks as in theorem 5.2.
We obtain this final complexity on the basis of the following consider-
ations: the single-head and single-block transformer architecture includes
one self-attention, one feed-forward network, and two residual connections
with layer normalization, as shown in Figure 5.2.
Starting from the input assumption as Assumption 5.1, for the index
j ∈ [ℓ], we first construct the block encoding of self-attention matrix, as de-
scribed in Section 5.2.1. This output can be directly the input of the quan-
tum residual connection and layer normalization, as Section 5.2.2, which
output is a state encoding. Remind the definition of state encoding as def-
inition 2.22. The state encoding can directly be used as the input of the
feed-forward network, as section 5.2.3. Finally, we put the output of the
feed-forward network, which is a state encoding, into the residual connec-
tion block. This is possible by noticing that state encoding is a specific
5.3. RUNTIME ANALYSIS WITH QUADRATIC SPEEDUPS 199

kind of block encoding. Multiplying the query complexity of these compu-

tational blocks, one can achieve final result. The detailed analysis of runtime
is referred to Guo et al. (2024a)
As theorem 5.2 shows, the quantum transformer uses O(dN e 2 α α ) times
s w
the input block encodings, where αs and αw are encoding factors. By ana-
lyzing naive matrix multiplication, the runtime of classical single-head and
single-block Transformer during the inference stage is O(ℓd + d2 ), where d
is the embedding dimension and ℓ = 2N is the input sequence length. From
the comparison, we can see that αs and αw are the dominant factors that
affect the potential quantum speedup. We will explore the properties of
these two factors via numerical studies.

5.3.2 Numerical evidence

The encoding factors αs and αw appear in the block encodings of matrices
S and Wq , Wk , Wv . Recall that the encoding factor α is lower bounded
by the spectral norm of a block-encoded matrix A, i.e., α ≥ ∥A∥. Given
access to quantum Random Access Memory (QRAM) and a quantum data
structure (Lloyd et al., 2014; Kerenidis and Prakash, 2016), there are well-
known implementations that enable the construction of a block encoding for
an arbitrary matrix A where the encoding factor is upper bounded by the
Frobenius norm ∥A∥F . Based on these considerations, we numerically study
these two norms of the input matrices of several open-source large language
models1 to provide upper and lower bound of αs and αw .
We first investigate the input sequence matrix S, which introduces the
dependency on ℓ. We consider input data in real-world applications sampled
from the widely-used Massive Multitask Language Understanding (MMLU)
dataset (Hendrycks et al., 2021) covering 57 subjects across science, tech-
nology, engineering, mathematics, the humanities, the social sciences, and
more. The scaling of the spectral norm and Frobenius norm of S on the
MMLU dataset is demonstrated in Figure 5.3. We can find√that the matrix
norms of the input matrix of all LLMs scale at most as O( ℓ).
As additional interest, this analysis of the matrix norm provides new
insights for the classical tokenization and embedding design. We also observe
that comparatively more advanced LLM models like Llama2-7b and Mistral-
7b have large variances of matrix norms. This phenomenon is arguably the
consequence of the training in those models; the embeddings that frequently
appear in the real-world dataset are actively updated at the pre-training
stage, and therefore, are more broadly distributed.
We then compute the spectral and Frobenius norms of weight matrices
200 CHAPTER 5. QUANTUM TRANSFORMER

y x bert roberta distilgpt gpt2 gpt llama2-7b tinyllama mistral7b

103

Frobenius Norm
102 101

100
102

101 102 101 102 101 102 103

102
101
Spectral Norm

102 100

101
101 102 101 102 101 102 103
Input Sequence Length N Input Sequence Length N Input Sequence Length N

Figure 5.3: Scaling of the spectral norm ∥S∥ and the Frobenius norm ∥S∥F
with ℓ for each model, displayed on logarithmic scales for both axes. For
√
reference, the line y ∝ x is also shown. We use tokens in MMLU dataset
and convert them to S.

(Wq , Wk , Wv ) for the large language models. The result can be seen in Fig-
ure 5.4. Many of the LLMs below a dimension d of 103 that we have checked
have substantially different norms. We observe that for larger models such
as Llama2-7b and Mistral-7b, which are close to the current state-of-the-art
open-source models, the norms do not change dramatically. Therefore, it is
reasonable to assume that the spectral
√ norm and the Frobenius norm of the
weight matrices are at most O( d) for advanced LLMs.

√Given these numerical

√ experiments it is reasonable to assume that αs =
O( ℓ) and αw = O( d), and we obtain a query complexity of the quantum
√
transformer in O(de 32 ℓ). We continue with a discussion of the possible time
complexity. With the QRAM assumption, the input block encodings can
be implemented in a polynomially logarithmic time of ℓ. Even without a
QRAM assumption, there can be cases when the input sequence is generated
efficiently, for example when the sequence is generated from a differential
equation, see additional discussions in the supplementary material. In these
cases, we demonstrate that a quadratic speedup of the runtime of a single-
head and single-block Transformer can be expected.
 5.4. CODE DEMONSTRATION 201

bert roberta distilgpt gpt2 gpt1 llama2-7b tinyllama mistral-7b

175 175 40
150 150
Frobenius Norm

125 125 30
100 100
75 75 20
50 50
10
25 25
0
1000 2000 3000 4000 1000 2000 3000 4000 1000 2000 3000 4000
30 10
40
25 8
Spectral Norm

30
20 6
15 20
4
10 10 2
5 0
1000 2000 3000 4000 1000 2000 3000 4000 1000 2000 3000 4000
Dimension of the weight matrix Wq Dimension of the weight matrix Wk Dimension of the weight matrix Wv

Figure 5.4: Norms of weight matrices across open-source LLMs.

The figure shows the maximum Frobenius norm and spectral norm values
among weight matrices Wq , Wk , and Wv across the eight LLM models.

5.4 Code Demonstration

We explain how self-attention works with a simple concrete example. Con-
sider a short sequence of three words: “The cat sleeps”.
First, we convert each word into an embedding vector. For this toy
example, we use very small 4-dimensional embeddings:
1 The = [1 , 0 , 1 , 0]
2 cat = [0 , 1 , 1 , 1]
3 sleeps = [1 , 1 , 0 , 1]

In self-attention, each word needs to “attend” to all other words in the

sequence. This happens through three key steps using learned weight ma-
trices (Wq , Wk , Wv ) to transform the embeddings into queries, keys, and
values. When we multiply our word embeddings by these matrices, we get
1 import numpy as np
2
3 # Input tokens (3 tokens , each with 3 features )
4 S = np . array ([
 202 CHAPTER 5. QUANTUM TRANSFORMER

5 [1 , 0 , 1 , 0] , # for " The "

6 [0 , 1 , 1 , 1] , # for " cat "
7 [1 , 1 , 0 , 1] # for " sleeps "
8 ])
9
10 # Initialize weights for Query , Key , and Value (4 x3
matrices )
11 W_q = np . array (
12 [
13 [0.2 , 0.4 , 0.6 , 0.8] ,
14 [0.1 , 0.3 , 0.5 , 0.7] ,
15 [0.9 , 0.8 , 0.7 , 0.6] ,
16 [0.5 , 0.4 , 0.3 , 0.2] ,
17 ]
18 )
19

20 W_k = np . array (
21 [
22 [0.1 , 0.3 , 0.5 , 0.7] ,
23 [0.6 , 0.4 , 0.2 , 0.1] ,
24 [0.8 , 0.9 , 0.7 , 0.6] ,
25 [0.2 , 0.1 , 0.3 , 0.4] ,
26 ]
27 )
28
29 W_v = np . array (
30 [
31 [0.3 , 0.5 , 0.7 , 0.9] ,
32 [0.6 , 0.4 , 0.2 , 0.1] ,
33 [0.8 , 0.9 , 0.7 , 0.6] ,
34 [0.5 , 0.4 , 0.3 , 0.2] ,
35 ]
36 )
37
38 # Compute Query , Key , and Value matrices
39 Q = S @ W_q
40 K = S @ W_k
41 V = S @ W_v

Next, we compute attention scores by multiplying Q and K ⊤ , then ap-

plying softmax.
1 # Compute scaled dot - product attention
2 d = Q . shape [1] # Feature dimension
3 attention_scores = Q @ K . T / np . sqrt ( d )
 5.5. BIBLIOGRAPHIC REMARKS 203

4
5 def softmax ( x ) :
6 """ Compute softmax values for each set of scores in x
. """
7 return np . exp ( x ) / np . sum ( np . exp ( x ) , axis =1 , keepdims
= True )
8
9 atte ntion_ weight s = softmax ( attention_scores )

The attention weight would be:

 
 ⊤
 0.324 0.467 0.209
Q·K
softmax √ = 0.305 0.515 0.180.
4 0.346 0.432 0.222

The final output captures how each word relates to every other word in the
sentence. In this case, “sleeps” pays most attention to “cat” (0.432), some
attention to “The” (0.346), and less attention to itself (0.222). Finally, we
use these scores to create a weighted sum of the values:
1 output = at tentio n_weig hts @ V

The final output is

 
1.536 1.519 1.265 1.157
output = 1.566 1.536 1.261 1.137.
1.512 1.507 1.269 1.174

5.5 Bibliographic Remarks

Transformer architecture has profoundly revolutionized AI and has broad
impacts. As classical computing approaches its physical limitations, it is
important to ask how we can leverage quantum computers to advance Trans-
formers with better performance and energy efficiency. Besides the fault-
tolerant quantum Transformers introduced in Chapter 5.2, multiple works
are advancing this frontier from various perspectives.
One aspect is to design novel quantum neural network architectures in-
troduced in Chapter 4 with the intuition from the Transformer, especially
the design of the self-attention block. In particular, Li et al. (2023b) proposes
the quantum self-attention neural networks and verifies their effectiveness
with the synthetic data sets of quantum natural language processing. There
are several follow-up works along this direction (Cherrat et al., 2024; Evans
et al., 2024; Widdows et al., 2024).
204 CHAPTER 5. QUANTUM TRANSFORMER

Another research direction is exploring how to utilize quantum proces-

sors to advance certain parts of the transformer architecture. Specifically,
Gao et al. (2023) considers how to compute the self-attention matrix un-
der sparse assumption and shows a quadratic quantum speedup. Liu et al.
(2024b) harnesses quantum neural networks to generate weight parameters
for the classical model. In addition, Liu et al. (2024a) devises a quantum al-
gorithm for the training process of large-scale neural networks, implying an
exponential speedup under certain conditions. There are several other works
that consider machine learning related optimization problems (Yang et al.,
2023; Zhang and Li, 2024; Wang et al., 2024c; Rebentrost et al., 2018b).
Despite the progress made, several important questions remain unre-
solved. Among them, one key challenge is devising efficient methods to
encode classical data or parameters onto quantum computers. Currently,
most quantum algorithms can only implement one or at most constant lay-
ers of Transformers (Guo et al., 2024a; Liao and Ferrie, 2024; Khatri et al.,
2024) without quantum tomography. Are there effective methods that can
be generalized to multiple layers, or is achieving this even necessary? More-
over, given the numerous variants of the classical Transformer architecture,
can these variants also benefit from the capabilities of quantum computers?
Lastly, if one considers training a model directly on a quantum computer, is
it possible to do so in a “quantum-native” manner—avoiding excessive data
read-in and read-out operations?
Chapter 6

Conclusion

In this tutorial, we systematically explored the landscape of quantum ma-

chine learning, covering foundational principles, the adaptation of classical
models to quantum frameworks, and the theoretical underpinnings of quan-
tum algorithms. By providing practical implementations and discussing
emerging research directions, we aimed to bridge the gap between classical
AI and quantum computing for researchers and practitioners.
The insights gained from this tutorial highlight how quantum machine
learning has the potential to revolutionize various domains, from funda-
mental scientific research to practical applications in industry. As quantum
hardware continues to evolve, quantum machine learning will likely play a
central role in harnessing the computational advantages of quantum systems.
In the meantime, the field of quantum machine learning faces challenges, as
discussed at the end of each chapter. Overcoming these barriers will be
critical for unlocking the full potential of quantum machine learning.
Moving forward, interdisciplinary collaboration between quantum com-
puting and AI researchers will be essential for addressing these challenges
and realizing the transformative potential of QML. All in all, we hope this
tutorial serves as a valuable resource for those eager to contribute to this
rapidly evolving discipline.

205
206 CHAPTER 6. CONCLUSION
Appendix A

Notations Summary

Notation Concept
a, b, aj , bj , α, β Scalars
x, y Vectors
W, A Matrices
R Real Euclidean space
C Complex Euclidean space
N The set of natural numbers
[a] The set of integers {1, 2, · · · , a}
E[·] Expectation value of a random variable
Var[·] Variance of a random variable
O Asymptotic upper bound notation
Ω Asymptotic lower bound notation
⊤ Transpose operation
a∗ complex conjugate of the number a
† Conjugate Transpose operation
|·⟩ ⟨·| Outer product operation
A⊙B element-wise multiplication (Hadamard product) of matrices
A and B
f ◦g composition of functions f and g
|0⟩ , |1⟩ , |ψ⟩ Pure quantum state in Dirac notation
N Number of qubits
|0N ⟩ , |0⟩⊗N Zero state with N -qubits
Id Identity matrix with the size d × d
ρ Quantum state in density matrix representation
H Hamiltonian

207
208 APPENDIX A. NOTATIONS SUMMARY

U, V Unitary operator
X, Y, Z Pauli operators
RX, RY, RZ Rotation gates along the x, y and z axes, respectively
CX, CZ Controlled-X gate and controlled-Z gate
E, N Quantum channel
O Observable
⟨O⟩ Expectation of observable O
∥·∥op Operator norm
n Number of training examples
D Dataset
Tr(Oρ) Expectation value of an observable O
U (θ) Parameterized quantum circuit
L(θ) Loss function
∇θ L(θ) Gradient of loss function L w.r.t parameters θ
Table A.1: Notations used in this work.
Appendix B

Concentration Inequality

In this section, we introduce some of the most common concentration in-

equalities in statistical learning theory. These inequalities are widely used
in deriving generalization error bounds for learning models. In practical
scenarios, one often needs to infer properties of an unknown distribution
based on finite data samples drawn from that distribution. Concentration
inequalities address the deviations of functions of independent random vari-
ables from their expectations. They provide tools to analyze the difference
between the empirical mean (or some estimate) and the true expectation of
random variables that follow a probability distribution.
We begin by recalling some basic tools that will be used throughout this
section. For any nonnegative random variable X following the probability
distribution p(x), its expectation can be written as

Z ∞
EX = xp(x)dx. (B.1)
0

This leads directly to a fundamental building block for concentration in-

equalities, namely Markov’s inequality.

Lemma B.1 (Markov’s inequality). For any nonnegative random variable

X, and a positive constant t > 0, we have

EX
P{X ≥ t} ≤ . (B.2)
t

209
210 APPENDIX B. CONCENTRATION INEQUALITY

Proof. Employing the definition of cumulative distribution function, we have

Z ∞
P{X ≥ t} = p(x)dt
t
Z ∞
x
≤ p(x) dt
t
R t∞
p(x)xd
≤ 0
t
EX
≤ , (B.3)
t
where the first inequality follows that x/t > 1 in the interval x ∈ [t, ∞], and
the second inequality employs the positiveness of integral term p(x)x/t.

Using Markov’s inequality, it follows that if ϕ is a strictly monotonically

increasing, nonnegative function, then for any random variable X and real
number t > 0, we have
Eϕ(X)
P{X ≥ t} = P{ϕ(X) ≥ ϕ(t)} ≤ . (B.4)
ϕ(t)

An application of this result with ϕ(x) = x2 leads to the simplest concen-

tration inequality, i.e., Chebyshev’s inequality.
Lemma B.2. Let X be an arbitrary random variable and the real number
t > 0, then
Var(X)
P{|X − EX| ≥ t} ≤ . (B.5)
t2
Proof. Utilizing the extention of Markov’s inequality in Eqn. (B.4) with
setting ϕ(x) = x2 yields

P{|X − EX| ≥ t} =P{|X − EX|2 ≥ t2 }

E(X − EX)2
≤
t2
Var(X)
= . (B.6)
t2

More generally, by taking ϕ(x) = xq (x ≥ 0), then for any q > 0, we

obtain the following moment-based inequality
E(X − EX)q
P{|X − EX| ≥ t} ≤ . (B.7)
tq
 211

Here, the parameter q can be chosen to optimize the upper bound in spe-
cific examples. Such moment bounds often provide sharp estimates for tail
probabilities. A related idea forms the basis of Chernoff’s bounding method.
In particular, by setting ϕ(x) = esx for some s > 0, we can derive a useful
upper bound for any random variable X and t > 0,

EesX
P{X ≥ t} = P{esX ≥ est } ≤ . (B.8)
est
In Chernoff’s method, the goal is to choose an appropriate s > 0 to minimize
the upper bound or make it as small as possible.
Now, we turn to concentration inequalities for sums of independent ran-
dom variables. Specifically, we aim to bound probabilities
P of deviations from
the mean, i.e., P{|Sn − ESn | ≥ t}, where Sn = ni=1 Xi , and X1 , · · · , Xn
are independent real-valued random variables.
By applying Chebyshev’s inequality to Sn , we obtain
Pn
Var(Sn ) Var(Xi )
P{|Sn − ESn | ≥ t} ≤ 2
= i=1 2 . (B.9)
t t
In terms of the sample mean, this can be rewritten as,
( n
)
1X σ2
P Xi − EXi ≥ ε ≤ 2 , (B.10)
n nε
i=1
Pn
where σ 2 = n1 i=1 Var(Xi ). Chernoff’s bounding method is particularly
useful for bounding tail probabilities of sums of independent random vari-
ables. By exploiting the independence property (i.e., the expected value
of a product of independent random variables equals the product of their
expected values), Chernoff’s bound can be expressed as
" n
!#
X
P{Sn − ESn ≥ t} ≤e−st E exp s (Xi − EXi )
i=1
n
Y
=e−st E[exp(s(Xi − EXi ))] (by independence).
i=1
(B.11)

Now, the challenge then becomes finding a good upper bound for the
moment generating function of the random variables Xi −EXi . For bounded
random variables, one of the most elegant results is Hoeffding’s inequality
Hoeffding (1994).
212 APPENDIX B. CONCENTRATION INEQUALITY

Lemma B.3 (Hoeffding’s inequality). Let X be a random variable with

EX = 0, a ≤ X ≤ b. Then for s > 0,
 2 
s (b − a)2
E[e ] ≤ exp
sx
(B.12)
8

This lemma, combined with Eqn. (B.11) immediately implies Hoeffding’s

tail inequality (Hoeffding, 1994).

Theorem B.4. Let X1 , · · · , Xn be independent bounded random variables

such that Xi falls in the interval [ai , bi ] with probability one. Then for any
real number t > 0, we have
 
−2t2
P{Sn − ESn ≥ t} ≤ exp Pn 2
, (B.13)
i=1 (bi − ai )

and  
−2t2
P{Sn − ESn ≤ −t} ≤ exp Pn 2
, (B.14)
i=1 (bi − ai )

Hoeffding’s inequality, first proven for binomial random variables by

Chernoff (1952) and Okamoto (1959), provides a powerful tool for bounding
tail probabilities. However, a limitation is that it does not take into account
the variance of the Xi ’s, which can sometimes yield loose bounds.
Appendix C

Haar Measure and Unitary

t-design

In this section, we introduce some basic knowledge of Haar measure (Haar,

1933) and unitary t-design (Dankert et al., 2009), which are extensively
employed in group representation theory and quantum information (Nagy,
1993; Adam, 2013), especially in the analysis of barren plateaus and the
trainability of variational quantum algorithms (Larocca et al., 2024).
We begin with the Haar measure. Roughly speaking, Haar measure is
a unique probability measure that generates the uniform distribution over
a compact group. In this chapter, we focus on the Haar measure on the
unitary space U(d) for convenience. Mathematically, the Haar measure is
uniform given by invariant properties in Definition C.1.

Definition C.1 (Haar measure on U(d)). A measure µ is the Haar measure

on the unitary space U(d) if and only if µ is

1. left-invariant, i.e. µ(U S) = µ(S) for any measurable set S ⊆ U(d) and
any unitary U ∈ U(d).

2. right-invariant, i.e. µ(SU ) = µ(S) for any measurable set S ⊆ U(d)

and any unitary U ∈ U(d).
R
3. a probability measure, i.e. dµ(U ) = 1.

As provided in Definition C.1, the Haar measure is continuous on the

whole space due to left- and right-invariant properties. Therefore, researchers
are interested in approximating the Haar measure with the uniform distri-
bution over some finite sets. Specifically, the unitary set whose uniform

213
214 APPENDIX C. HAAR MEASURE AND UNITARY T-DESIGN

distribution shares the same t-th moment with the Haar measure is defined
as the unitary t-design.
Definition C.2 (Unitary 2-design). Let µ be the Haar measure on the space
U(d). Then, a finite set S forms a unitary t-design if and only if it fulfills
one of the following equivalent conditions:
1. Z
1 X ⊗t † ⊗t
U ⊗ (U ) = U ⊗t ⊗ (U † )⊗t dµ(U ).
|S| U (d)
U ∈S

2. Let Pt,t (U ) be the polynomial with at most t degrees of elements from

U and at most t degrees of elements from U † . Then
Z
1 X
Pt,t (U ) = Pt,t (U )dµ(U ).
|S| U (d)
U ∈S

Corollary C.3. A unitary t-design is also a unitary (t − 1)-design.

We remark that invariant properties of the Haar measure lead to several
useful formulations of unitary t-designs provided in Facts C.4 and C.5.
Fact C.4 (Average over unitary 1-design (Puchala and Miszczak, 2017)).
Let S be a set of unitary 1-design on U(d) and µ be the corresponding Haar
measure. Then
Z
1 X 1
Uij Ui∗′ j ′ = Uij Ui∗′ j ′ dµ(U ) = δii′ δjj ′ .
|S| U (d) d
U ∈S

Fact C.5 (Average over unitary 2-design (Puchala and Miszczak, 2017)).
Let S be a set of unitary 2-design on U(d) and µ be the corresponding Haar
measure. Then
Z
1 X ∗ ∗
Ui1 j1 Ui2 j2 Ui′ j ′ Ui′ j ′ = Ui1 j1 Ui2 j2 Ui∗′ j ′ Ui∗′ j ′ dµ(U )
|S| 1 1 2 2
U (d)
1 1 2 2
U ∈S
1  
= 2 δ ′ δ ′ δ ′ δ ′ + δi1 i′2 δi2 i′1 δj1 j2′ δj2 j1′
d − 1 i 1 i1 i 2 i2 j1 j1 j2 j2
1  
− δ ′ δ ′ δ ′ δ ′ + δ i1 i2 i2 i1 j1 j1 j2 j2 .
′ δ ′ δ ′ δ ′
d(d2 − 1) i1 i1 i2 i2 j1 j2 j2 j1

How big is a unitary t-design? Roy and Scott (2009) have proved that, for
instance, the size of unitary 1-design and unitary 2-design scale polynomially
to the dimension of the unitary space.
 215

Fact C.6 (The size of a unitary 2-design (Roy and Scott, 2009)). A unitary
1-design on U(d) has no fewer than d2 elements. A unitary 2-design on U(d)
has no fewer than d4 − 2d2 + 2 elements.

For a system with N qubits, the dimension of the unitary space is d = 2N .

Therefore, an exact t-design could involve exponential numbers of ensembles
with increased qubits. Could we obtain an approximation to the unitary
t-design, which can be generated in polynomial times with less degree of
freedom? Haferkamp (2022) has proved that random quantum circuits with
linear depths could form an approximate unitary t-design.

Definition C.7 (Approximate unitary designs). Let µ be the Haar mea-

(t)
sure
R on the space U(d). We denote the moment superoperator Φν (A) :=
⊗t † ⊗t
U (d) U A(U ) . Denote by Mn (C) the n × n complex matrices. Denote
by ∥Φ∥⋄ := maxX;∥X∥1 ≤1 ∥(Φ ⊗ In )X∥1 the diamond norm for the linear
transformation Φ : Mn (C) → Mm (C) and X ∈ Mn2 (C). Then, a probability
distribution ν on U(d) is an ϵ-approximate unitary t-design if
ϵ
Φ(t) (t)
ν − Φµ ≤ .
⋄ dt
Fact C.8 (Random quantum circuits form approximate unitary designs,
informal version from Haferkamp (2022)). For the number of qubits N ≥
O(log t), alternative layered random quantum circuits with Haar-random
unitary gates sampled from U(4) lead to an ϵ-approximate unitary t-design
when the circuit depth
  
4+o(1) 1
k≥O t N t + log ,
ϵ

where the term o(1) → 0 when t → ∞.

216 APPENDIX C. HAAR MEASURE AND UNITARY T-DESIGN
NOTES 217

Notes
1
Parameters are obtained from the Hugging Face website, which is an open-source
platform for machine learning models.
218 NOTES
Bibliography

Richard P Feynman. Quantum mechanical computers. Between Quantum

and Cosmos, pages 523–548, 2017.
John Watrous. Quantum computational complexity. arXiv preprint
arXiv:0804.3401, 2008.
Peter W Shor. Polynomial-time algorithms for prime factorization and dis-
crete logarithms on a quantum computer. SIAM review, 41(2):303–332,
1999.
Craig Gidney and Martin Ekerå. How to factor 2048 bit rsa integers in 8
hours using 20 million noisy qubits. Quantum, 5:433, 2021.
Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan
Wiebe, and Seth Lloyd. Quantum machine learning. Nature, 549(7671):
195–202, 2017.
Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Ben-
jamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and
Dario Amodei. Scaling laws for neural language models. arXiv preprint
arXiv:2001.08361, 2020.
Paul Benioff. Quantum mechanical hamiltonian models of turing machines.
Journal of Statistical Physics, 29:515–546, 1982.
Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quan-
tum Information: 10th Anniversary Edition. Cambridge University Press,
USA, 2 edition, 2011. ISBN 1107002176.
Robert Raussendorf and Hans J Briegel. A one-way quantum computer.
Physical review letters, 86(22):5188, 2001.
Tameem Albash and Daniel A Lidar. Adiabatic quantum computation.
Reviews of Modern Physics, 90(1):015002, 2018.

219
220 BIBLIOGRAPHY

A Yu Kitaev. Fault-tolerant quantum computation by anyons. Annals of

physics, 303(1):2–30, 2003.

Lov K Grover. A fast quantum mechanical algorithm for database search.

In Proceedings of the twenty-eighth annual ACM symposium on Theory of
computing, pages 212–219, 1996.

Dylan Herman, Cody Googin, Xiaoyuan Liu, Yue Sun, Alexey Galda, Ilya
Safro, Marco Pistoia, and Yuri Alexeev. Quantum computing for finance.
Nature Reviews Physics, 5(8):450–465, 2023.

Raffaele Santagati, Alan Aspuru-Guzik, Ryan Babbush, Matthias Degroote,

Leticia Gonzalez, Elica Kyoseva, Nikolaj Moll, Markus Oppel, Robert M
Parrish, Nicholas C Rubin, et al. Drug design on quantum computers.
Nature Physics, 20(4):549–557, 2024.

Amira Abbas, Andris Ambainis, Brandon Augustino, Andreas Bärtschi,

Harry Buhrman, Carleton Coffrin, Giorgio Cortiana, Vedran Dunjko,
Daniel J Egger, Bruce G Elmegreen, et al. Challenges and opportuni-
ties in quantum optimization. Nature Reviews Physics, pages 1–18, 2024.

Andrew W Cross, Lev S Bishop, Sarah Sheldon, Paul D Nation, and Jay M
Gambetta. Validating quantum computers using randomized model cir-
cuits. Physical Review A, 100(3):032328, 2019.

Andrew Wack, Hanhee Paik, Ali Javadi-Abhari, Petar Jurcevic, Ismael Faro,
Jay M Gambetta, and Blake R Johnson. Quality, speed, and scale: three
key attributes to measure the performance of near-term quantum com-
puters. arXiv preprint arXiv:2110.14108, 2021.

Kostyantyn Kechedzhi, Sergei V Isakov, Salvatore Mandrà, Benjamin Villa-

longa, Xiao Mi, Sergio Boixo, and Vadim Smelyanskiy. Effective quantum
volume, fidelity and computational cost of noisy quantum processing ex-
periments. Future Generation Computer Systems, 153:431–441, 2024.

Srinivasan Arunachalam and Ronald De Wolf. Guest column: A survey of

quantum learning theory. ACM Sigact News, 48(2):41–67, 2017.

Anurag Anshu and Srinivasan Arunachalam. A survey on the complexity of

learning quantum states. Nature Reviews Physics, 6(1):59–69, 2024.

Aram W Harrow and Ashley Montanaro. Quantum computational

supremacy. Nature, 549(7671):203–209, 2017.
BIBLIOGRAPHY 221

Youngseok Kim, Andrew Eddins, Sajant Anand, Ken Xuan Wei, Ewout Van
Den Berg, Sami Rosenblatt, Hasan Nayfeh, Yantao Wu, Michael Zaletel,
Kristan Temme, et al. Evidence for the utility of quantum computing
before fault tolerance. Nature, 618(7965):500–505, 2023.
Maria Schuld, Ilya Sinayskiy, and Francesco Petruccione. An introduction to
quantum machine learning. Contemporary Physics, 56(2):172–185, 2015.
Vedran Dunjko and Hans J Briegel. Machine learning & artificial intelligence
in the quantum domain: a review of recent progress. Reports on Progress
in Physics, 81(7):074001, 2018.
Giuseppe Carleo, Ignacio Cirac, Kyle Cranmer, Laurent Daudet, Maria
Schuld, Naftali Tishby, Leslie Vogt-Maranto, and Lenka Zdeborová. Ma-
chine learning and the physical sciences. Reviews of Modern Physics, 91
(4):045002, 2019.
Bin Cheng, Xiu-Hao Deng, Xiu Gu, Yu He, Guangchong Hu, Peihao Huang,
Jun Li, Ben-Chuan Lin, Dawei Lu, Yao Lu, et al. Noisy intermediate-scale
quantum computers. Frontiers of Physics, 18(2):21308, 2023.
He-Liang Huang, Dachao Wu, Daojin Fan, and Xiaobo Zhu. Superconduct-
ing quantum computing: a review. Science China Information Sciences,
63:1–32, 2020a.
Colin D Bruzewicz, John Chiaverini, Robert McConnell, and Jeremy M
Sage. Trapped-ion quantum computing: Progress and challenges. Applied
Physics Reviews, 6(2), 2019.
M Morgado and S Whitlock. Quantum simulation and computing with
rydberg-interacting qubits. AVS Quantum Science, 3(2), 2021.
John Preskill. Quantum computing in the nisq era and beyond. Quantum,
2:79, 2018.
Frank Arute, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C Bardin,
Rami Barends, Rupak Biswas, Sergio Boixo, Fernando GSL Brandao,
David A Buell, et al. Quantum supremacy using a programmable super-
conducting processor. Nature, 574(7779):505–510, 2019.
Yulin Wu, Wan-Su Bao, Sirui Cao, Fusheng Chen, Ming-Cheng Chen, Xi-
awei Chen, Tung-Hsun Chung, Hui Deng, Yajie Du, Daojin Fan, et al.
Strong quantum computational advantage using a superconducting quan-
tum processor. Physical review letters, 127(18):180501, 2021.
222 BIBLIOGRAPHY

Aram W Harrow, Avinatan Hassidim, and Seth Lloyd. Quantum algorithm

for linear systems of equations. Physical review letters, 103(15):150502,
2009.

Ashley Montanaro. Quantum algorithms: an overview. npj Quantum Infor-

mation, 2(1):1–8, 2016.

Alexander M Dalzell, Sam McArdle, Mario Berta, Przemyslaw Bienias,

Chi-Fang Chen, András Gilyén, Connor T Hann, Michael J Kastoryano,
Emil T Khabiboulline, Aleksander Kubica, et al. Quantum algorithms:
A survey of applications and end-to-end complexities. arXiv preprint
arXiv:2310.03011, 2023.

Seth Lloyd, Masoud Mohseni, and Patrick Rebentrost. Quantum princi-

pal component analysis. Nature Physics, 10(9):631–633, September 2014.
ISSN 1745-2481. doi: 10.1038/nphys3029.

Patrick Rebentrost, Masoud Mohseni, and Seth Lloyd. Quantum support

vector machine for big data classification. Physical review letters, 113(13):
130503, 2014.

András Gilyén, Yuan Su, Guang Hao Low, and Nathan Wiebe. Quantum
singular value transformation and beyond: exponential improvements for
quantum matrix arithmetics. In Proceedings of the 51st Annual ACM
SIGACT Symposium on Theory of Computing, STOC ’19. ACM, June
2019. doi: 10.1145/3313276.3316366. URL [Link]
1145/3313276.3316366.

Zherui Chen, Yuchen Lu, Hao Wang, Yizhou Liu, and Tongyang
Li. Quantum langevin dynamics for optimization. arXiv preprint
arXiv:2311.15587, 2023.

Junyu Liu, Minzhao Liu, Jin-Peng Liu, Ziyu Ye, Yunfei Wang, Yuri Alexeev,
Jens Eisert, and Liang Jiang. Towards provably efficient quantum algo-
rithms for large-scale machine-learning models. Nature Communications,
15(1):434, 2024a.

Scott Aaronson. Read the fine print. Nature Physics, 11(4):291–293, 2015.

Vittorio Giovannetti, Seth Lloyd, and Lorenzo Maccone. Quantum random

access memory. Physical review letters, 100(16):160501, 2008.
BIBLIOGRAPHY 223

Vojtěch Havlı́ček, Antonio D Córcoles, Kristan Temme, Aram W Harrow,

Abhinav Kandala, Jerry M Chow, and Jay M Gambetta. Supervised
learning with quantum-enhanced feature spaces. Nature, 567(7747):209–
212, 2019.

Marco Cerezo, Andrew Arrasmith, Ryan Babbush, Simon C Benjamin, Sug-

uru Endo, Keisuke Fujii, Jarrod R McClean, Kosuke Mitarai, Xiao Yuan,
Lukasz Cincio, et al. Variational quantum algorithms. Nature Reviews
Physics, 3(9):625–644, 2021a.

Weikang Li and Dong-Ling Deng. Recent advances for quantum classifiers.

Science China Physics, Mechanics & Astronomy, 65(2):220301, 2022.

Jinkai Tian, Xiaoyu Sun, Yuxuan Du, Shanshan Zhao, Qing Liu, Kaining
Zhang, Wei Yi, Wanrong Huang, Chaoyue Wang, Xingyao Wu, et al.
Recent advances for quantum neural networks in generative learning.
IEEE Transactions on Pattern Analysis and Machine Intelligence, 45(10):
12321–12340, 2023.

Kishor Bharti, Alba Cervera-Lierta, Thi Ha Kyaw, Tobias Haug, Sumner

Alperin-Lea, Abhinav Anand, Matthias Degroote, Hermanni Heimonen,
Jakob S Kottmann, Tim Menke, et al. Noisy intermediate-scale quantum
algorithms. Reviews of Modern Physics, 94(1):015004, 2022.

Marco Cerezo, Guillaume Verdon, Hsin-Yuan Huang, Lukasz Cincio, and

Patrick J Coles. Challenges and opportunities in quantum machine learn-
ing. Nature Computational Science, 2(9):567–576, 2022.

Yuxuan Du, Tao Huang, Shan You, Min-Hsiu Hsieh, and Dacheng Tao.
Quantum circuit architecture search for variational quantum algorithms.
npj Quantum Information, 8(1):62, 2022a.

James Stokes, Josh Izaac, Nathan Killoran, and Giuseppe Carleo. Quantum
natural gradient. Quantum, 4:269, 2020.

Sukin Sim, Jonathan Romero, Jérôme F Gonthier, and Alexander A Ku-

nitsa. Adaptive pruning-based optimization of parameterized quantum
circuits. Quantum Science and Technology, 6(2):025019, 2021.

Xinbiao Wang, Junyu Liu, Tongliang Liu, Yong Luo, Yuxuan Du, and
Dacheng Tao. Symmetric pruning in quantum neural networks. In The
Eleventh International Conference on Learning Representations, 2023a.
URL [Link]
224 BIBLIOGRAPHY

Sirui Lu, Lu-Ming Duan, and Dong-Ling Deng. Quantum adversarial

machine learning. Phys. Rev. Res., 2:033212, Aug 2020. doi: 10.
1103/PhysRevResearch.2.033212. URL [Link]
1103/PhysRevResearch.2.033212.
Wenjie Jiang, Zhide Lu, and Dong-Ling Deng. Quantum continual learn-
ing overcoming catastrophic forgetting. Chinese Physics Letters, 39(5):
050303, may 2022. doi: 10.1088/0256-307X/39/5/050303. URL https:
//[Link]/10.1088/0256-307X/39/5/050303.
Yuxuan Du, Min-Hsiu Hsieh, Tongliang Liu, Dacheng Tao, and Nana Liu.
Quantum noise protects quantum classifiers against adversaries. Physical
Review Research, 3(2):023153, 2021a.
William M. Watkins, Samuel Yen-Chi Chen, and Shinjae Yoo. Quantum
machine learning with differential privacy. Scientific Reports, 13(1):2453,
2023. doi: 10.1038/s41598-022-24082-z. URL [Link]
1038/s41598-022-24082-z.
Yuxuan Du, Yang Qian, Xingyao Wu, and Dacheng Tao. A distributed
learning scheme for variational quantum algorithms. IEEE Transactions
on Quantum Engineering, 3:1–16, 2022b.
Chao Ren, Rudai Yan, Huihui Zhu, Han Yu, Minrui Xu, Yuan Shen, Yan Xu,
Ming Xiao, Zhao Yang Dong, Mikael Skoglund, et al. Towards quantum
federated learning. arXiv preprint arXiv:2306.09912, 2023.
Lirandë Pira and Chris Ferrie. On the interpretability of quantum neural
networks. Quantum Machine Intelligence, 6(2):52, 2024.
Leonardo Banchi, Jason Luke Pereira, Sharu Theresa Jose, and Osvaldo
Simeone. Statistical complexity of quantum learning. Advanced Quantum
Technologies, page 2300311, 2023.
Ville Bergholm, Josh Izaac, Maria Schuld, Christian Gogolin, Shah-
nawaz Ahmed, Vishnu Ajith, M Sohaib Alam, Guillermo Alonso-Linaje,
B AkashNarayanan, Ali Asadi, et al. Pennylane: Automatic differ-
entiation of hybrid quantum-classical computations. arXiv preprint
arXiv:1811.04968, 2018.
Ali Javadi-Abhari, Matthew Treinish, Kevin Krsulich, Christopher J Wood,
Jake Lishman, Julien Gacon, Simon Martiel, Paul D Nation, Lev S Bishop,
Andrew W Cross, et al. Quantum computing with qiskit. arXiv preprint
arXiv:2405.08810, 2024.
BIBLIOGRAPHY 225

Cirq Developers. Cirq, May 2024. URL [Link]

zenodo.11398048.

Michael Broughton, Guillaume Verdon, Trevor McCourt, Antonio J Mar-

tinez, Jae Hyeon Yoo, Sergei V Isakov, Philip Massey, Ramin Halavati,
Murphy Yuezhen Niu, Alexander Zlokapa, et al. Tensorflow quantum:
A software framework for quantum machine learning. arXiv preprint
arXiv:2003.02989, 2020.

Richard Jozsa and Noah Linden. On the role of entanglement in quantum-

computational speed-up. Proceedings of the Royal Society of London.
Series A: Mathematical, Physical and Engineering Sciences, 459(2036):
2011–2032, 2003.

Daniel M Greenberger, Michael A Horne, and Anton Zeilinger. Going beyond

bell’s theorem. In Bell’s theorem, quantum theory and conceptions of the
universe, pages 69–72. Springer, 1989.

Donald P Leach and Albert P Malvino. Digital principles and Applications.

Glencoe/McGraw-Hill, 1994.

Christopher M Dawson and Michael A Nielsen. The solovay-kitaev algo-

rithm. arXiv preprint quant-ph/0505030, 2005.

Mark M Wilde. From classical to quantum shannon theory. arXiv preprint

arXiv:1106.1445, 2011.

Steven T Flammia and Joel J Wallman. Efficient estimation of pauli chan-

nels. ACM Transactions on Quantum Computing, 1(1):1–32, 2020.

John Preskill. Lecture notes for physics 219: Quantum computation. Caltech
Lecture Notes, 7:1, 1999.

K Vogel and H Risken. Determination of quasiprobability distributions in

terms of probability distributions for the rotated quadrature phase. Phys-
ical Review A, 40(5):2847, 1989.

Bo Qi, Zhibo Hou, Li Li, Daoyi Dong, Guoyong Xiang, and Guangcan Guo.
Quantum state tomography via linear regression estimation. Scientific
reports, 3(1):3496, 2013.

Zdenek Hradil. Quantum-state estimation. Physical Review A, 55(3):R1561,

1997.
226 BIBLIOGRAPHY

David Layden, Guglielmo Mazzola, Ryan V Mishmash, Mario Motta, Pawel

Wocjan, Jin-Sung Kim, and Sarah Sheldon. Quantum-enhanced markov
chain monte carlo. Nature, 619(7969):282–287, 2023.
Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. A quantum approxi-
mate optimization algorithm. arXiv preprint arXiv:1411.4028, 2014.
Sergio Boixo, Sergei V Isakov, Vadim N Smelyanskiy, Ryan Babbush, Nan
Ding, Zhang Jiang, Michael J Bremner, John M Martinis, and Hartmut
Neven. Characterizing quantum supremacy in near-term devices. Nature
Physics, 14(6):595–600, 2018.
Adam Bouland, Bill Fefferman, Chinmay Nirkhe, and Umesh Vazirani. On
the complexity and verification of quantum random circuit sampling. Na-
ture Physics, 15(2):159–163, 2019.
Abhinav Kandala, Antonio Mezzacapo, Kristan Temme, Maika Takita,
Markus Brink, Jerry M Chow, and Jay M Gambetta. Hardware-efficient
variational quantum eigensolver for small molecules and quantum mag-
nets. nature, 549(7671):242–246, 2017a.
Jules Tilly, Hongxiang Chen, Shuxiang Cao, Dario Picozzi, Kanav Setia,
Ying Li, Edward Grant, Leonard Wossnig, Ivan Rungger, George H Booth,
et al. The variational quantum eigensolver: a review of methods and best
practices. Physics Reports, 986:1–128, 2022.
Scott Aaronson. Shadow tomography of quantum states. In Proceedings of
the 50th annual ACM SIGACT symposium on theory of computing, pages
325–338, 2018.
Hsin-Yuan Huang, Richard Kueng, and John Preskill. Predicting many
properties of a quantum system from very few measurements. Nature
Physics, 16(10):1050–1057, 2020b.
Naixu Guo, Zhan Yu, Matthew Choi, Aman Agrawal, Kouhei Nakaji, Alán
Aspuru-Guzik, and Patrick Rebentrost. Quantum linear algebra is all you
need for transformer architectures, 2024a. URL [Link]
abs/2402.16714.
Gilles Brassard, Peter Høyer, Michele Mosca, and Alain Tapp. Quantum
amplitude amplification and estimation. In Quantum Computation and
Information (Washington, DC, 2000), volume 305 of Contemporary Math-
ematics, pages 53–74. American Mathematical Society, Providence, RI,
2002. ISBN 978-0-8218-2140-4. doi: 10.1090/conm/305/05215.
BIBLIOGRAPHY 227

Liming Zhao, Zhikuan Zhao, Patrick Rebentrost, and Joseph Fitzsi-

mons. Compiling basic linear algebra subroutines for quantum comput-
ers. Quantum Machine Intelligence, 3(2):21, June 2021. ISSN 2524-
4914. doi: 10.1007/s42484-021-00048-8. URL [Link]
1007/s42484-021-00048-8.

Naixu Guo, Kosuke Mitarai, and Keisuke Fujii. Nonlinear transforma-

tion of complex amplitudes via quantum singular value transformation.
Phys. Rev. Res., 6:043227, Dec 2024b. doi: 10.1103/PhysRevResearch.6.
043227. URL [Link]
6.043227.

Arthur G. Rattew and Patrick Rebentrost. Non-linear transformations of

quantum amplitudes: Exponential improvement, generalization, and ap-
plications, 2023. URL [Link]

Kouhei Nakaji, Shumpei Uno, Yohichi Suzuki, Rudy Raymond, Tamiya

Onodera, Tomoki Tanaka, Hiroyuki Tezuka, Naoki Mitsuda, and Naoki
Yamamoto. Approximate amplitude encoding in shallow parameterized
quantum circuits and its application to financial market indicators. Phys-
ical Review Research, 4(2):023136, 2022.

Adrián Pérez-Salinas, Alba Cervera-Lierta, Elies Gil-Fuster, and José I La-

torre. Data re-uploading for a universal quantum classifier. Quantum, 4:
226, 2020.

Tak Hur, Israel F Araujo, and Daniel K Park. Neural quantum embedding:
Pushing the limits of quantum supervised learning. Physical Review A,
110(2):022411, 2024.

Maria Schuld, Francesco Petruccione, Maria Schuld, and Francesco Petruc-

cione. Information encoding. Supervised Learning with Quantum Com-
puters, pages 139–171, 2018.

Hervé Abdi and Lynne J Williams. Principal component analysis. Wiley

interdisciplinary reviews: computational statistics, 2(4):433–459, 2010.

Seth Lloyd, Maria Schuld, Aroosa Ijaz, Josh Izaac, and Nathan Kil-
loran. Quantum embeddings for machine learning. arXiv preprint
arXiv:2001.03622, 2020.

Minzhao Liu, Junyu Liu, Rui Liu, Henry Makhanov, Danylo Lykov, Anuj
Apte, and Yuri Alexeev. Embedding learning in hybrid quantum-classical
228 BIBLIOGRAPHY

neural networks. In 2022 IEEE International Conference on Quantum

Computing and Engineering (QCE), pages 79–86. IEEE, 2022.

Patrick Rebentrost, Adrian Steffens, Iman Marvian, and Seth Lloyd. Quan-
tum singular-value decomposition of nonsparse low-rank matrices. Phys-
ical review A, 97(1):012327, 2018a.

Kaining Zhang, Min-Hsiu Hsieh, Liu Liu, and Dacheng Tao. Quantum
gram-schmidt processes and their application to efficient state readout
for quantum algorithms. Physical Review Research, 3(4):043095, 2021a.

Ben P Lanyon, Christine Maier, Milan Holzäpfel, Tillmann Baumgratz, Cor-

nelius Hempel, Petar Jurcevic, Ish Dhand, AS Buyskikh, Andrew J Daley,
Marcus Cramer, et al. Efficient tomography of a quantum many-body sys-
tem. Nature Physics, 13(12):1158–1162, 2017.

Román Orús. Tensor networks for complex quantum systems. Nature Re-
views Physics, 1(9):538–550, 2019.

Asja Fischer and Christian Igel. An introduction to restricted boltzmann

machines. In Progress in Pattern Recognition, Image Analysis, Computer
Vision, and Applications: 17th Iberoamerican Congress, CIARP 2012,
Buenos Aires, Argentina, September 3-6, 2012. Proceedings 17, pages 14–
36. Springer, 2012.

A Vaswani. Attention is all you need. Advances in Neural Information

Processing Systems, 2017.

Giacomo Torlai, Guglielmo Mazzola, Juan Carrasquilla, Matthias

Troyer, Roger Melko, and Giuseppe Carleo. Neural-network quan-
tum state tomography. Nature Physics, 14(5):447–450, 2018.
doi: 10.1038/s41567-018-0048-5. URL [Link]
s41567-018-0048-5.

Tobias Schmale, Moritz Reh, and Martin Gärttner. Efficient quan-

tum state tomography with convolutional neural networks. npj
Quantum Information, 8(1), September 2022. ISSN 2056-6387.
doi: 10.1038/s41534-022-00621-4. URL [Link]
s41534-022-00621-4.

Haoxiang Wang, Maurice Weber, Josh Izaac, and Cedric Yen-Yu Lin. Pre-
dicting properties of quantum systems with conditional generative models.
arXiv preprint arXiv:2211.16943, 2022a.
BIBLIOGRAPHY 229

Liming Zhao, Naixu Guo, Ming-Xing Luo, and Patrick Rebentrost. Provable
learning of quantum states with graphical models, 2023. URL https:
//[Link]/abs/2309.09235.

Abhinav Kandala, Antonio Mezzacapo, Kristan Temme, Maika Takita,

Markus Brink, Jerry M. Chow, and Jay M. Gambetta. Hardware-efficient
Variational Quantum Eigensolver for Small Molecules and Quantum Mag-
nets. Nature, 549(7671):242–246, September 2017b. ISSN 0028-0836,
1476-4687. doi: 10.1038/nature23879.

Vladyslav Verteletskyi, Tzu-Ching Yen, and Artur F Izmaylov. Measure-

ment optimization in the variational quantum eigensolver using a mini-
mum clique cover. The Journal of chemical physics, 152(12), 2020.

Nicholas C Rubin, Ryan Babbush, and Jarrod McClean. Application of

fermionic marginal constraints to hybrid quantum algorithms. New Jour-
nal of Physics, 20(5):053020, 2018.

Andrew Arrasmith, Lukasz Cincio, Rolando D Somma, and Patrick J Coles.

Operator sampling for shot-frugal optimization in variational algorithms.
arXiv preprint arXiv:2004.06252, 2020.

Yang Qian, Yuxuan Du, and Dacheng Tao. Shuffle-qudio: accelerate dis-
tributed vqe with trainability enhancement and measurement reduction.
Quantum Machine Intelligence, 6(1):1–22, 2024.

A. Yu. Kitaev. Quantum measurements and the abelian stabilizer problem,

1995. URL [Link]

Lidia Ruiz-Perez and Juan Carlos Garcia-Escartin. Quantum arithmetic

with the quantum fourier transform. Quantum Information Processing,
16(6), April 2017. ISSN 1573-1332. doi: 10.1007/s11128-017-1603-1. URL
[Link]

Jin-Peng Liu, Herman Øie Kolden, Hari K. Krovi, Nuno F. Loureiro,

Konstantina Trivisa, and Andrew M. Childs. Efficient quantum al-
gorithm for dissipative nonlinear differential equations. Proceedings of
the National Academy of Sciences, 118(35), August 2021a. ISSN 1091-
6490. doi: 10.1073/pnas.2026805118. URL [Link]
1073/pnas.2026805118.

Andrew M. Childs, Jin-Peng Liu, and Aaron Ostrander. High-precision

quantum algorithms for partial differential equations. Quantum, 5:574,
230 BIBLIOGRAPHY

November 2021. ISSN 2521-327X. doi: 10.22331/q-2021-11-10-574. URL

[Link]

Dong An, Noah Linden, Jin-Peng Liu, Ashley Montanaro, Changpeng Shao,
and Jiasu Wang. Quantum-accelerated multilevel Monte Carlo methods
for stochastic differential equations in mathematical finance. Quantum, 5:
481, June 2021. ISSN 2521-327X. doi: 10.22331/q-2021-06-24-481. URL
[Link]

Shi Jin, Nana Liu, and Yue Yu. Quantum simulation of partial differential
equations via schrodingerisation, 2022. URL [Link]
2212.13969.

Zhong-Xia Shang, Naixu Guo, Dong An, and Qi Zhao. Design nearly optimal
quantum algorithm for linear differential equations via lindbladians, 2024.
URL [Link]

Guang Hao Low and Yuan Su. Quantum eigenvalue processing, 2024. URL
[Link]

Dong An, Jin-Peng Liu, and Lin Lin. Linear combination of hamiltonian
simulation for nonunitary dynamics with optimal state preparation cost.
Phys. Rev. Lett., 131:150603, Oct 2023. doi: 10.1103/PhysRevLett.131.
150603. URL [Link]
150603.

Dong An, Andrew M. Childs, Lin Lin, and Lexing Ying. Laplace transform
based quantum eigenvalue transformation via linear combination of hamil-
tonian simulation, 2024. URL [Link]

Youle Wang, Lei Zhang, Zhan Yu, and Xin Wang. Quantum phase process-
ing and its applications in estimating phase and entropies. Physical Review
A, 108(6), December 2023b. ISSN 2469-9934. doi: 10.1103/physreva.108.
062413. URL [Link]

Danial Motlagh and Nathan Wiebe. Generalized quantum signal processing,

2024. URL [Link]

Zane M. Rossi and Isaac L. Chuang. Multivariable quantum signal pro-

cessing (m-qsp): prophecies of the two-headed oracle. Quantum, 6:811,
September 2022. ISSN 2521-327X. doi: 10.22331/q-2022-09-20-811. URL
[Link]
BIBLIOGRAPHY 231

Hitomi Mori, Kosuke Mitarai, and Keisuke Fujii. Efficient state preparation
for multivariate monte carlo simulation, 2024. URL [Link]
abs/2409.07336.

Xiao-Ming Zhang, Tongyang Li, and Xiao Yuan. Quantum State Prepa-
ration with Optimal Circuit Depth: Implementations and Applications.
Physical Review Letters, 129(23):230504, November 2022a. doi: 10.1103/
PhysRevLett.129.230504. URL [Link]
PhysRevLett.129.230504.

Xiaoming Sun, Guojing Tian, Shuai Yang, Pei Yuan, and Shengyu Zhang.
Asymptotically Optimal Circuit Depth for Quantum State Preparation
and General Unitary Synthesis. IEEE Transactions on Computer-Aided
Design of Integrated Circuits and Systems, 42(10):3301–3314, October
2023. ISSN 1937-4151. doi: 10.1109/TCAD.2023.3244885. URL https:
//[Link]/document/10044235.

Andrew M. Childs and Nathan Wiebe. Hamiltonian simulation using linear

combinations of unitary operations. Quantum Info. Comput., 12(11–12):
901–924, November 2012. ISSN 1533-7146.

Nikita Guseynov and Nana Liu. Efficient explicit circuit for quantum
state preparation of piece-wise continuous functions, 2024. URL https:
//[Link]/abs/2411.01131.

Nikita Guseynov, Xiajie Huang, and Nana Liu. Explicit gate construction of
block-encoding for hamiltonians needed for simulating partial differential
equations, 2024. URL [Link]

Daan Camps, Lin Lin, Roel Van Beeumen, and Chao Yang. Explicit quan-
tum circuits for block encodings of certain sparse matrices, 2023. URL
[Link]

Mehryar Mohri. Foundations of machine learning, 2018.

Takeru Kusumoto, Kosuke Mitarai, Keisuke Fujii, Masahiro Kitagawa, and

Makoto Negoro. Experimental quantum kernel trick with nuclear spins in
a solid. npj Quantum Information, 7(1):94, 2021.

Carsten Blank, Daniel K Park, June-Koo Kevin Rhee, and Francesco Petruc-
cione. Quantum classifier with tailored quantum kernel. npj Quantum
Information, 6(1):41, 2020.
232 BIBLIOGRAPHY

Yunchao Liu, Srinivasan Arunachalam, and Kristan Temme. A rigorous and

robust quantum speed-up in supervised machine learning. Nature Physics,
17(9):1013–1017, 2021b.

Elies Gil-Fuster, Jens Eisert, and Vedran Dunjko. On the expressivity of

embedding quantum kernels. Machine Learning: Science and Technology,
5(2):025003, 2024.

Hsin-Yuan Huang, Michael Broughton, Masoud Mohseni, Ryan Babbush,

Sergio Boixo, Hartmut Neven, and Jarrod R McClean. Power of data in
quantum machine learning. Nature communications, 12(1):2631, 2021a.

Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne.
Journal of machine learning research, 9(11), 2008.

Maria Schuld, Mark Fingerhuth, and Francesco Petruccione. Implementing a

distance-based classifier with a quantum interference circuit. Europhysics
Letters, 119(6):60002, 2017.

Maria Schuld and Nathan Killoran. Quantum machine learning in feature

hilbert spaces. Physical review letters, 122(4):040504, 2019.

Thomas Hubregtsen, David Wierichs, Elies Gil-Fuster, Peter-Jan HS Derks,

Paul K Faehrmann, and Johannes Jakob Meyer. Training quantum em-
bedding kernels on near-term quantum computers. Physical Review A,
106(4):042431, 2022.

Maria Schuld, Ryan Sweke, and Johannes Jakob Meyer. Effect of data en-
coding on the expressive power of variational quantum-machine-learning
models. Physical Review A, 103(3):032430, 2021.

Seyed Shakib Vedaie, Moslem Noori, Jaspreet S Oberoi, Barry C Sanders,

and Ehsan Zahedinejad. Quantum multiple kernel learning. arXiv preprint
arXiv:2011.09694, 2020.

Cong Lei, Yuxuan Du, Peng Mi, Jun Yu, and Tongliang Liu. Neural auto-
designer for enhanced quantum kernels. arXiv preprint arXiv:2401.11098,
2024.

Jennifer R Glick, Tanvi P Gujarati, Antonio D Corcoles, Youngseok Kim,

Abhinav Kandala, Jay M Gambetta, and Kristan Temme. Covariant
quantum kernels for data with group structure. Nature Physics, 20(3):
479–483, 2024.
BIBLIOGRAPHY 233

Supanut Thanasilp, Samson Wang, Marco Cerezo, and Zoë Holmes. Ex-
ponential concentration and untrainability in quantum kernel methods.
arXiv preprint arXiv:2208.11060, 2022.
Yudai Suzuki, Hideaki Kawaguchi, and Naoki Yamamoto. Quantum fisher
kernel for mitigating the vanishing similarity issue. Quantum Science and
Technology, 2022.
Ruslan Shaydulin and Stefan M Wild. Importance of kernel bandwidth in
quantum machine learning. Physical Review A, 106(4):042407, 2022.
Abdulkadir Canatar, Evan Peters, Cengiz Pehlevan, Stefan M Wild, and
Ruslan Shaydulin. Bandwidth enables generalization in quantum kernel
models. arXiv preprint arXiv:2206.06686, 2022.
Maria Schuld. Supervised quantum machine learning models are kernel
methods. arXiv preprint arXiv:2101.11020, 2021.
Sofiene Jerbi, Lukas J Fiderer, Hendrik Poulsen Nautrup, Jonas M Kübler,
Hans J Briegel, and Vedran Dunjko. Quantum machine learning beyond
kernel methods. Nature Communications, 14(1):1–8, 2023.
Xinbiao Wang, Yuxuan Du, Yong Luo, and Dacheng Tao. Towards under-
standing the power of quantum kernels in the nisq era. Quantum, 5:531,
2021a.
Jonas Kübler, Simon Buchholz, and Bernhard Schölkopf. The inductive bias
of quantum kernels. Advances in Neural Information Processing Systems,
34:12661–12673, 2021.
Ryan Sweke, Jean-Pierre Seifert, Dominik Hangleiter, and Jens Eisert. On
the quantum versus classical learnability of discrete distributions. Quan-
tum, 5:417, 2021.
Daniel Beaulieu, Dylan Miracle, Anh Pham, and William Scherr. Quantum
kernel for image classification of real world manufacturing defects. arXiv
preprint arXiv:2212.08693, 2022.
Pablo Rodriguez-Grasa, Robert Farzan-Rodriguez, Gabriele Novelli, Yue
Ban, and Mikel Sanz. Satellite image classification with neural quantum
kernels. arXiv preprint arXiv:2409.20356, 2024.
Teresa Sancho-Lorente, Juan Román-Roche, and David Zueco. Quantum
kernels to learn the phases of quantum matter. Physical Review A, 105
(4):042432, 2022.
234 BIBLIOGRAPHY

Yusen Wu, Bujiao Wu, Jingbo Wang, and Xiao Yuan. Quantum phase
recognition via quantum kernel methods. Quantum, 7:981, 2023.

Kushal Batra, Kimberley M Zorn, Daniel H Foil, Eni Minerali, Victor O

Gawriljuk, Thomas R Lane, and Sean Ekins. Quantum machine learning
algorithms for drug discovery applications. Journal of chemical informa-
tion and modeling, 61(6):2641–2647, 2021.

Nana Liu and Patrick Rebentrost. Quantum machine learning for quantum
anomaly detection. Physical Review A, 97(4):042315, 2018.

Michele Grossi, Noelle Ibrahim, Voica Radescu, Robert Loredo, Kirsten

Voigt, Constantin Von Altrock, and Andreas Rudnik. Mixed quantum–
classical method for fraud detection with quantum feature selection. IEEE
Transactions on Quantum Engineering, 3:1–12, 2022.

Shungo Miyabe, Brian Quanz, Noriaki Shimada, Abhijit Mitra, Takahiro

Yamamoto, Vladimir Rastunkov, Dimitris Alevras, Mekena Metcalf,
Daniel JM King, Mohammad Mamouei, et al. Quantum multiple kernel
learning in financial classification tasks. arXiv preprint arXiv:2312.00260,
2023.

Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature,
521(7553):436–444, 2015.

Athanasios Voulodimos, Nikolaos Doulamis, Anastasios Doulamis, and Efty-

chios Protopapadakis. Deep learning for computer vision: A brief review.
Computational intelligence and neuroscience, 2018(1):7068349, 2018.

Daniel W Otter, Julian R Medina, and Jugal K Kalita. A survey of the

usages of deep learning for natural language processing. IEEE transactions
on neural networks and learning systems, 32(2):604–624, 2020.

Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya,

Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks,
Johannes Welbl, Aidan Clark, et al. Training compute-optimal large lan-
guage models. In Proceedings of the 36th International Conference on
Neural Information Processing Systems, pages 30016–30030, 2022.

Alex de Vries. The growing energy footprint of artificial intelligence. Joule,

7(10):2191–2194, 2023.
BIBLIOGRAPHY 235

SK Jeswal and S Chakraverty. Recent developments and applications in

quantum neural network: A review. Archives of Computational Methods
in Engineering, 26(4):793–807, 2019.

Hsin-Yuan Huang, Michael Broughton, Jordan Cotler, Sitan Chen, Jerry Li,
Masoud Mohseni, Hartmut Neven, Ryan Babbush, Richard Kueng, John
Preskill, et al. Quantum advantage in learning from experiments. Science,
376(6598):1182–1186, 2022.

Evan Peters, João Caldeira, Alan Ho, Stefan Leichenauer, Masoud Mohseni,
Hartmut Neven, Panagiotis Spentzouris, Doug Strain, and Gabriel N Per-
due. Machine learning of high dimensional data on a noisy quantum
processor. npj Quantum Information, 7(1):161, 2021.

Rajeev Acharya, Laleh Aghababaie-Beni, Igor Aleiner, Trond I Andersen,

Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Nikita
Astrakhantsev, Juan Atalaya, et al. Quantum error correction below the
surface code threshold. arXiv preprint arXiv:2408.13687, 2024.

Bartlomiej Gardas, Marek M Rams, and Jacek Dziarmaga. Quantum neural

networks to simulate many-body quantum systems. Physical Review B,
98(18):184304, 2018.

Yudong Cao, Jonathan Romero, Jonathan P Olson, Matthias Degroote,

Peter D Johnson, Mária Kieferová, Ian D Kivlichan, Tim Menke, Borja
Peropadre, Nicolas PD Sawaya, et al. Quantum chemistry in the age of
quantum computing. Chemical reviews, 119(19):10856–10915, 2019.

Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL
[Link]

Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-
based learning applied to document recognition. Proceedings of the IEEE,
86(11):2278–2324, 1998.

Warren S McCulloch and Walter Pitts. A logical calculus of the ideas im-
manent in nervous activity. The bulletin of mathematical biophysics, 5:
115–133, 1943.

Matt W Gardner and SR Dorling. Artificial neural networks (the multi-

layer perceptron)—a review of applications in the atmospheric sciences.
Atmospheric environment, 32(14-15):2627–2636, 1998.
236 BIBLIOGRAPHY

Kurt Hornik. Some new results on neural network approximation. Neural

networks, 6(8):1069–1072, 1993.

Shun-ichi Amari. Backpropagation and stochastic gradient descent method.

Neurocomputing, 5(4-5):185–196, 1993.

Yann LeCun, Bernhard Boser, John Denker, Donnie Henderson, Richard

Howard, Wayne Hubbard, and Lawrence Jackel. Handwritten digit recog-
nition with a back-propagation network. Advances in neural information
processing systems, 2, 1989.

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual
learning for image recognition. In Proceedings of the IEEE conference on
computer vision and pattern recognition, pages 770–778, 2016.

Albert BJ Novikoff. On convergence proofs on perceptrons. In Proceedings

of the Symposium on the Mathematical Theory of Automata, volume 12,
pages 615–622. New York, NY, 1962.

Frank Rosenblatt. The perceptron: a probabilistic model for information

storage and organization in the brain. Psychological review, 65(6):386,
1958.

Yann LeCun, D Touresky, G Hinton, and T Sejnowski. A theoretical frame-

work for back-propagation. In Proceedings of the 1988 connectionist mod-
els summer school, volume 1, pages 21–28, 1988.

Kurt Hornik, Maxwell Stinchcombe, and Halbert White. Multilayer feed-

forward networks are universal approximators. Neural networks, 2(5):
359–366, 1989.

Rich Caruana, Steve Lawrence, and C Giles. Overfitting in neural nets:

Backpropagation, conjugate gradient, and early stopping. Advances in
neural information processing systems, 13, 2000.

Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and

Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks
from overfitting. Journal of Machine Learning Research, 15(1):1929–1958,
2014.

Anders Krogh and John Hertz. A simple weight decay can improve gener-
alization. Advances in neural information processing systems, 4, 1991.
BIBLIOGRAPHY 237

Ashish Kapoor, Nathan Wiebe, and Krysta Svore. Quantum perceptron

models. Advances in neural information processing systems, 29, 2016.

Muhammad AbuGhanem. Ibm quantum computers: Evolution, perfor-

mance, and future directions. arXiv preprint arXiv:2410.00916, 2024.

Dongxin Gao, Daojin Fan, Chen Zha, Jiahao Bei, Guoqing Cai, Jianbin Cai,
Sirui Cao, Xiangdong Zeng, Fusheng Chen, Jiang Chen, et al. Establishing
a new benchmark in quantum computational advantage with 105-qubit
zuchongzhi 3.0 processor. arXiv preprint arXiv:2412.11924, 2024.

Yunfei Wang and Junyu Liu. A comprehensive review of quantum machine

learning: from nisq to fault tolerance. Reports on Progress in Physics,
2024.

Iris Cong, Soonwon Choi, and Mikhail D Lukin. Quantum convolutional

neural networks. Nature Physics, 15(12):1273–1278, 2019.

Alberto Peruzzo, Jarrod McClean, Peter Shadbolt, Man-Hong Yung, Xiao-

Qi Zhou, Peter J Love, Alán Aspuru-Guzik, and Jeremy L O’brien. A
variational eigenvalue solver on a photonic quantum processor. Nature
communications, 5(1):4213, 2014.

Gavin E Crooks. Gradients of parameterized quantum gates using

the parameter-shift rule and gate decomposition. arXiv preprint
arXiv:1905.13311, 2019.

John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient meth-
ods for online learning and stochastic optimization. Journal of machine
learning research, 12(7), 2011.

Diederik P Kingma. Adam: A method for stochastic optimization. arXiv

preprint arXiv:1412.6980, 2014.

Seth Lloyd and Christian Weedbrook. Quantum generative adversarial

learning. Physical review letters, 121(4):040502, 2018.

Sergey Bravyi, David Gosset, and Robert König. Quantum advantage with
shallow circuits. Science, 362(6412):308–311, 2018.

Elton Yechao Zhu, Sonika Johri, Dave Bacon, Mert Esencan, Jungsang Kim,
Mark Muir, Nikhil Murgai, Jason Nguyen, Neal Pisenti, Adam Schouela,
et al. Generative quantum learning of joint probability distribution func-
tions. Physical Review Research, 4(4):043092, 2022.
238 BIBLIOGRAPHY

He-Liang Huang, Yuxuan Du, Ming Gong, Youwei Zhao, Yulin Wu, Chaoyue
Wang, Shaowei Li, Futian Liang, Jin Lin, Yu Xu, et al. Experimental
quantum generative adversarial networks for image generation. Physical
Review Applied, 16(2):024051, 2021b.

Marcello Benedetti, Delfina Garcia-Pintos, Oscar Perdomo, Vicente Leyton-

Ortega, Yunseong Nam, and Alejandro Perdomo-Ortiz. A generative mod-
eling approach for benchmarking and training shallow quantum circuits.
npj Quantum Information, 5(1):45, 2019a.

Yuxuan Du, Zhuozhuo Tu, Xiao Yuan, and Dacheng Tao. Efficient measure
for the expressivity of variational quantum algorithms. Physical Review
Letters, 128(8):080506, 2022c.

Thomas Barthel and Jianfeng Lu. Fundamental limitations for measure-

ments in quantum many-body systems. Physical Review Letters, 121(8):
080406, 2018.

Sham M Kakade, Karthik Sridharan, and Ambuj Tewari. On the complexity

of linear prediction: Risk bounds, margin bounds, and regularization.
Advances in neural information processing systems, 21, 2008.

Richard M Dudley. The sizes of compact subsets of hilbert space and conti-
nuity of gaussian processes. Journal of Functional Analysis, 1(3):290–330,
1967.

ABAED Haussler and M Warmuth. Occam’s razor. Information Processing

Letters, 24:377–380, 1987.

Martin Larocca, Nathan Ju, Diego Garcı́a-Martı́n, Patrick J Coles, and

Marco Cerezo. Theory of overparametrization in quantum neural net-
works. Nature Computational Science, 3(6):542–551, 2023.

Jarrod R McClean, Sergio Boixo, Vadim N Smelyanskiy, Ryan Babbush,

and Hartmut Neven. Barren plateaus in quantum neural network training
landscapes. Nature communications, 9(1):4812, 2018.

Christoph Dankert, Richard Cleve, Joseph Emerson, and Etera Livine. Ex-
act and approximate unitary 2-designs and their application to fidelity
estimation. Physical Review A—Atomic, Molecular, and Optical Physics,
80(1):012304, 2009.
BIBLIOGRAPHY 239

Aram W Harrow and Richard A Low. Random quantum circuits are approx-
imate 2-designs. Communications in Mathematical Physics, 291:257–302,
2009.

Jonas Haferkamp. Random quantum circuits are approximate unitary t-

designs in depth o(nt5+o(1) ). Quantum, 6:795, 2022.

Marco Cerezo, Akira Sone, Tyler Volkoff, Lukasz Cincio, and Patrick J
Coles. Cost function dependent barren plateaus in shallow parametrized
quantum circuits. Nature communications, 12(1):1791, 2021b.

Arthur Pesah, Marco Cerezo, Samson Wang, Tyler Volkoff, Andrew T Sorn-
borger, and Patrick J Coles. Absence of barren plateaus in quantum
convolutional neural networks. Physical Review X, 11(4):041011, 2021.

Kaining Zhang, Min-Hsiu Hsieh, Liu Liu, and Dacheng Tao. To-
ward trainability of deep quantum neural networks. arXiv preprint
arXiv:2112.15002, 2021b.

Edward Grant, Leonard Wossnig, Mateusz Ostaszewski, and Marcello

Benedetti. An initialization strategy for addressing barren plateaus in
parametrized quantum circuits. Quantum, 3:214, 2019.

Kaining Zhang, Liu Liu, Min-Hsiu Hsieh, and Dacheng Tao. Escaping from
the barren plateau via gaussian initializations in deep variational quantum
circuits. Advances in Neural Information Processing Systems, 35:18612–
18627, 2022b.

Andrea Skolik, Jarrod R McClean, Masoud Mohseni, Patrick Van

Der Smagt, and Martin Leib. Layerwise learning for quantum neural
networks. Quantum Machine Intelligence, 3:1–11, 2021.

Tobias Haug and MS Kim. Optimal training of variational quantum algo-

rithms without barren plateaus. arXiv preprint arXiv:2104.14543, 2021.

Farid Ablayev, Marat Ablayev, Joshua Zhexue Huang, Kamil Khadiev, Nai-
lya Salikhova, and Dingming Wu. On quantum methods for machine
learning problems part ii: Quantum classification algorithms. Big Data
Mining and Analytics, 3(1):56–67, 2019.

Fabio Valerio Massoli, Lucia Vadicamo, Giuseppe Amato, and Fabrizio

Falchi. A leap among quantum computing and quantum neural networks:
A survey. ACM Computing Surveys, 55(5):1–37, 2022.
240 BIBLIOGRAPHY

Kosuke Mitarai, Makoto Negoro, Masahiro Kitagawa, and Keisuke Fujii.

Quantum circuit learning. Physical Review A, 98(3):032309, 2018.

Davis Arthur et al. A hybrid quantum-classical neural network architecture

for binary classification. arXiv preprint arXiv:2201.01820, 2022.

Johannes Bausch. Recurrent quantum neural networks. Advances in neural

information processing systems, 33:1368–1379, 2020.

Jinjing Shi, Ren-Xin Zhao, Wenxuan Wang, Shichao Zhang, and Xuelong
Li. Qsan: A near-term achievable quantum self-attention network. IEEE
Transactions on Neural Networks and Learning Systems, 2024.

Liangliang Fan and Haozhen Situ. Compact data encoding for data re-
uploading quantum classifier. Quantum Information Processing, 21(3):87,
2022.

Shi-Xin Zhang, Chang-Yu Hsieh, Shengyu Zhang, and Hong Yao. Differen-
tiable quantum architecture search. Quantum Science and Technology, 7
(4):045023, 2022c.

Kehuan Linghu, Yang Qian, Ruixia Wang, Meng-Jun Hu, Zhiyuan Li, Xue-
gang Li, Huikai Xu, Jingning Zhang, Teng Ma, Peng Zhao, et al. Quantum
circuit architecture search on a superconducting processor. Entropy, 26
(12):1025, 2024.

Xinbiao Wang, Junyu Liu, Tongliang Liu, Yong Luo, Yuxuan Du, and
Dacheng Tao. Symmetric pruning in quantum neural networks. arXiv
preprint arXiv:2208.14057, 2022b.

Mahabubul Alam, Satwik Kundu, and Swaroop Ghosh. Knowledge distilla-

tion in quantum neural network using approximate synthesis. In Proceed-
ings of the 28th Asia and South Pacific Design Automation Conference,
pages 639–644, 2023.

Mingze Li, Lei Fan, Aaron Cummings, Xinyue Zhang, Miao Pan, and Zhu
Han. Hybrid quantum classical machine learning with knowledge distil-
lation. In ICC 2024-IEEE International Conference on Communications,
pages 1139–1144. IEEE, 2024.

Zhan Yu, Hongshun Yao, Mujin Li, and Xin Wang. Power and limitations
of single-qubit native quantum neural networks. Advances in Neural In-
formation Processing Systems, 35:27810–27823, 2022a.
BIBLIOGRAPHY 241

Sukin Sim, Peter D Johnson, and Alán Aspuru-Guzik. Expressibility

and entangling capability of parameterized quantum circuits for hybrid
quantum-classical algorithms. Advanced Quantum Technologies, 2(12):
1900070, 2019.

Kouhei Nakaji and Naoki Yamamoto. Expressibility of the alternating lay-

ered ansatz for quantum computation. Quantum, 5:434, 2021.

Zoë Holmes, Kunal Sharma, Marco Cerezo, and Patrick J Coles. Connecting
ansatz expressibility to gradient magnitudes and barren plateaus. PRX
Quantum, 3(1):010313, 2022.

Zhan Yu, Qiuhao Chen, Yuling Jiao, Yinan Li, Xiliang Lu, Xin Wang, and
Jerry Zhijian Yang. Non-asymptotic approximation error bounds of pa-
rameterized quantum circuits. In The Thirty-eighth Annual Conference
on Neural Information Processing Systems, 2022b.

Carlos Ortiz Marrero, Mária Kieferová, and Nathan Wiebe. Entanglement-

induced barren plateaus. PRX Quantum, 2(4):040316, 2021.

Samson Wang, Enrico Fontana, Marco Cerezo, Kunal Sharma, Akira Sone,
Lukasz Cincio, and Patrick J Coles. Noise-induced barren plateaus in vari-
ational quantum algorithms. Nature communications, 12(1):6961, 2021b.

Martin Larocca, Piotr Czarnik, Kunal Sharma, Gopikrishnan Muraleedha-

ran, Patrick J Coles, and Marco Cerezo. Diagnosing barren plateaus with
tools from quantum optimal control. Quantum, 6:824, 2022.

Bobak Toussi Kiani, Seth Lloyd, and Reevu Maity. Learning unitaries by
gradient descent. arXiv preprint arXiv:2001.11897, 2020.

Roeland Wiersema, Cunlu Zhou, Yvette de Sereville, Juan Felipe Car-

rasquilla, Yong Baek Kim, and Henry Yuen. Exploring entanglement and
optimization within the hamiltonian variational ansatz. PRX quantum, 1
(2):020319, 2020.

Eric R Anschuetz. Critical points in quantum generative models. arXiv

preprint arXiv:2109.06957, 2021.

Xuchen You, Shouvanik Chakrabarti, and Xiaodi Wu. A convergence theory

for over-parameterized variational quantum eigensolvers. arXiv preprint
arXiv:2205.12481, 2022.
242 BIBLIOGRAPHY

Zhiqiang Xu, Xin Cao, and Xin Gao. Convergence analysis of gradient
descent for eigenvector computation. International Joint Conferences on
Artificial Intelligence, 2018.

Junyu Liu, Khadijeh Najafi, Kunal Sharma, Francesco Tacchino, Liang

Jiang, and Antonio Mezzacapo. Analytic theory for the dynamics of wide
quantum neural networks. Physical Review Letters, 130(15):150601, 2023.

Yuxuan Du, Min-Hsiu Hsieh, Tongliang Liu, Shan You, and Dacheng Tao.
Learnability of quantum neural networks. PRX quantum, 2(4):040337,
2021b.

Jun Qi, Chao-Han Huck Yang, Pin-Yu Chen, and Min-Hsiu Hsieh. Theo-
retical error performance analysis for variational quantum circuit based
functional regression. npj Quantum Information, 9(1):4, 2023.

Amira Abbas, David Sutter, Christa Zoufal, Aurélien Lucchi, Alessio Figalli,
and Stefan Woerner. The power of quantum neural networks. Nature
Computational Science, 1(6):403–409, 2021.

Matthias C Caro, Hsin-Yuan Huang, Marco Cerezo, Kunal Sharma, Andrew

Sornborger, Lukasz Cincio, and Patrick J Coles. Generalization in quan-
tum machine learning from few training data. Nature communications,
13(1):4919, 2022.

Kaifeng Bu, Dax Enshan Koh, Lu Li, Qingxian Luo, and Yaobo Zhang.
Statistical complexity of quantum circuits. Physical Review A, 105(6):
062431, 2022.

Hsin-Yuan Huang, Richard Kueng, and John Preskill. Information-theoretic

bounds on quantum advantage in machine learning. Physical Review Let-
ters, 126(19):190505, 2021c.

Kaining Zhang, Junyu Liu, Liu Liu, Liang Jiang, Min-Hsiu Hsieh, and
Dacheng Tao. The curse of random quantum data. arXiv preprint
arXiv:2408.09937, 2024a.

Yuxuan Du, Yibo Yang, Dacheng Tao, and Min-Hsiu Hsieh. Problem-
dependent power of quantum neural networks on multiclass classification.
Physical Review Letters, 131(14):140601, 2023.

Kyle Poland, Kerstin Beer, and Tobias J Osborne. No free lunch for quantum
machine learning. arXiv preprint arXiv:2003.14103, 2020.
BIBLIOGRAPHY 243

Kunal Sharma, Marco Cerezo, Zoë Holmes, Lukasz Cincio, Andrew Sorn-
borger, and Patrick J Coles. Reformulation of the no-free-lunch theorem
for entangled datasets. Physical Review Letters, 128(7):070501, 2022.

Xinbiao Wang, Yuxuan Du, Zhuozhuo Tu, Yong Luo, Xiao Yuan, and
Dacheng Tao. Transition role of entangled data in quantum machine
learning. Nature Communications, 15(1):3716, 2024a.

Xinbiao Wang, Yuxuan Du, Kecheng Liu, Yong Luo, Bo Du, and Dacheng
Tao. Separable power of classical and quantum learning protocols through
the lens of no-free-lunch theorem. arXiv preprint arXiv:2405.07226,
2024b.

Eric R Anschuetz, Hong-Ye Hu, Jin-Long Huang, and Xun Gao. Inter-
pretable quantum advantage in neural sequence learning. PRX Quantum,
4(2):020338, 2023.

Eric R Anschuetz and Xun Gao. Arbitrary polynomial separations in train-

able quantum machine learning. arXiv preprint arXiv:2402.08606, 2024.

Haimeng Zhao and Dong-Ling Deng. Entanglement-induced provable and

robust quantum learning advantages. arXiv preprint arXiv:2410.03094,
2024.

Marco Cerezo, Martin Larocca, Diego Garcı́a-Martı́n, Nelson L Diaz, Paolo

Braccia, Enrico Fontana, Manuel S Rudolph, Pablo Bermejo, Aroosa Ijaz,
Supanut Thanasilp, et al. Does provable absence of barren plateaus imply
classical simulability? or, why we need to rethink variational quantum
computing. arXiv preprint arXiv:2312.09121, 2023.

Pablo Bermejo, Paolo Braccia, Manuel S Rudolph, Zoë Holmes, Lukasz Cin-
cio, and M Cerezo. Quantum convolutional neural networks are (effec-
tively) classically simulable. arXiv preprint arXiv:2408.12739, 2024.

Armando Angrisani, Alexander Schmidhuber, Manuel S Rudolph, M Cerezo,

Zoë Holmes, and Hsin-Yuan Huang. Classically estimating observables of
noiseless quantum circuits. arXiv preprint arXiv:2409.01706, 2024.

Sacha Lerch, Ricard Puig, Manuel S Rudolph, Armando Angrisani, Tyson

Jones, M Cerezo, Supanut Thanasilp, and Zoë Holmes. Efficient quantum-
enhanced classical simulation for patches of quantum landscapes. arXiv
preprint arXiv:2411.19896, 2024.
244 BIBLIOGRAPHY

Seongwook Shin, Yong Siah Teo, and Hyunseok Jeong. Dequantizing quan-
tum machine learning models using tensor networks. Physical Review
Research, 6(2):023218, 2024.
Jonas Landman, Slimane Thabet, Constantin Dalyac, Hela Mhiri, and El-
ham Kashefi. Classically approximating variational quantum machine
learning with random fourier features. arXiv preprint arXiv:2210.13200,
2022.
Franz J Schreiber, Jens Eisert, and Johannes Jakob Meyer. Classical sur-
rogates for quantum learning models. Physical Review Letters, 131(10):
100803, 2023.
Yuxuan Du, Min-Hsiu Hsieh, and Dacheng Tao. Efficient learning for
linear properties of bounded-gate quantum circuits. arXiv preprint
arXiv:2408.12199, 2024.
Maxwell Henderson, Samriddhi Shakya, Shashindra Pradhan, and Tristan
Cook. Quanvolutional neural networks: powering image recognition with
quantum circuits. Quantum Machine Intelligence, 2(1):2, 2020.
HTS ALRikabi, Ibtisam A Aljazaery, Jaafar Sadiq Qateef, Abdul Hadi M
Alaidi, and M Roa’a. Face patterns analysis and recognition system based
on quantum neural network qnn. Int. J. Interac. Mob. Tech, 16(8):35–48,
2022.
Hongni Jin and Kenneth M Merz Jr. Integrating machine learning
and quantum circuits for proton affinity predictions. arXiv preprint
arXiv:2411.17856, 2024.
Jiwon Roh, Seunghyeon Oh, Donggyun Lee, Chonghyo Joo, Jinwoo Park,
Il Moon, Insoo Ro, and Junghwan Kim. Hybrid quantum neural network
model with catalyst experimental validation: Application for the dry re-
forming of methane. ACS Sustainable Chemistry & Engineering, 12(10):
4121–4131, 2024.
Yanan Li, Zhimin Wang, Rongbing Han, Shangshang Shi, Jiaxin Li, Ruimin
Shang, Haiyong Zheng, Guoqiang Zhong, and Yongjian Gu. Quantum
recurrent neural networks for sequential learning. Neural Networks, 166:
148–161, 2023a.
Nouhaila Innan, Abhishek Sawaika, Ashim Dhor, Siddhant Dutta, Sairupa
Thota, Husayn Gokal, Nandan Patel, Muhammad Al-Zafar Khan, Ioan-
nis Theodonis, and Mohamed Bennai. Financial fraud detection using
BIBLIOGRAPHY 245

quantum graph neural networks. Quantum Machine Intelligence, 6(1):7,

2024.
Huda Ghazi Enad, Mazin Abed Mohammed, et al. A review on artificial
intelligence and quantum machine learning for heart disease diagnosis:
Current techniques, challenges and issues, recent developments, and future
directions. Fusion: Pract Appl (FPA), 11(1):08–25, 2023.
Mohammad H Amin, Evgeny Andriyash, Jason Rolfe, Bohdan Kulchytskyy,
and Roger Melko. Quantum boltzmann machine. Physical Review X, 8
(2):021050, 2018.
Jonathan Romero, Jonathan P Olson, and Alan Aspuru-Guzik. Quantum
autoencoders for efficient compression of quantum data. Quantum Science
and Technology, 2(4):045001, 2017.
Bingzhi Zhang, Peng Xu, Xiaohui Chen, and Quntao Zhuang. Generative
quantum machine learning via denoising diffusion probabilistic models.
Physical Review Letters, 132(10):100602, 2024b.
Michael Kölle, Gerhard Stenzel, Jonas Stein, Sebastian Zielinski, Björn Om-
mer, and Claudia Linnhoff-Popien. Quantum denoising diffusion models.
arXiv preprint arXiv:2401.07049, 2024.
Manuel S Rudolph, Sacha Lerch, Supanut Thanasilp, Oriel Kiss, Oxana
Shaya, Sofia Vallecorsa, Michele Grossi, and Zoë Holmes. Trainability
barriers and opportunities in quantum generative modeling. npj Quantum
Information, 10(1):116, 2024.
Mohamed Hibat-Allah, Marta Mauri, Juan Carrasquilla, and Alejandro
Perdomo-Ortiz. A framework for demonstrating practical quantum ad-
vantage: comparing quantum against classical generative models. Com-
munications Physics, 7(1):68, 2024.
Xun Gao, Z-Y Zhang, and L-M Duan. A quantum machine learning al-
gorithm based on generative models. Science advances, 4(12):eaat9004,
2018.
Xun Gao, Eric R Anschuetz, Sheng-Tao Wang, J Ignacio Cirac, and
Mikhail D Lukin. Enhancing generative models via quantum correlations.
Physical Review X, 12(2):021037, 2022.
Yuxuan Du, Zhuozhuo Tu, Bujiao Wu, Xiao Yuan, and Dacheng Tao. Power
of quantum generative learning. arXiv preprint arXiv:2205.04730, 2022d.
246 BIBLIOGRAPHY

Javier Alcazar, Vicente Leyton-Ortega, and Alejandro Perdomo-Ortiz. Clas-

sical versus quantum models in machine learning: insights from a finance
application. Machine Learning: Science and Technology, 1(3):035003,
2020.

Marcello Benedetti, Edward Grant, Leonard Wossnig, and Simone Severini.

Adversarial quantum circuit learning for pure state approximation. New
Journal of Physics, 21(4):043023, 2019b.

Junde Li, Rasit O Topaloglu, and Swaroop Ghosh. Quantum generative

models for small molecule drug discovery. IEEE transactions on quantum
engineering, 2:1–8, 2021.

Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine trans-
lation of rare words with subword units. In Katrin Erk and Noah A. Smith,
editors, Proceedings of the 54th Annual Meeting of the Association for
Computational Linguistics (Volume 1: Long Papers), pages 1715–1725,
Berlin, Germany, August 2016. Association for Computational Linguis-
tics. doi: 10.18653/v1/P16-1162. URL [Link]
P16-1162.

Taku Kudo and John Richardson. SentencePiece: A simple and language in-
dependent subword tokenizer and detokenizer for neural text processing.
In Eduardo Blanco and Wei Lu, editors, Proceedings of the 2018 Con-
ference on Empirical Methods in Natural Language Processing: System
Demonstrations, pages 66–71, Brussels, Belgium, November 2018. Asso-
ciation for Computational Linguistics. doi: 10.18653/v1/D18-2012. URL
[Link]

Sabrina J. Mielke, Zaid Alyafeai, Elizabeth Salesky, Colin Raffel, Manan

Dey, Matthias Gallé, Arun Raja, Chenglei Si, Wilson Y. Lee, Benoı̂t
Sagot, and Samson Tan. Between words and characters: A brief history
of open-vocabulary modeling and tokenization in nlp. arXiv:2112.10508,
2021.

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual
learning for image recognition. arXiv:1512.03385, 2015.

Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normal-
ization, 2016. URL [Link]
BIBLIOGRAPHY 247

Diederik P. Kingma and Jimmy Ba. Adam: A Method for Stochastic Op-
timization. In Yoshua Bengio and Yann LeCun, editors, 3rd Interna-
tional Conference on Learning Representations, ICLR 2015, San Diego,
CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. URL
[Link]

Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang,

Andrew Howard, Benoit Steiner, and Hartwig Rolland. Quantization and
training of neural networks for efficient integer-arithmetic-only inference.
In Proceedings of the IEEE Conference on Computer Vision and Pattern
Recognition (CVPR), pages 2704–2713, 2018.

Song Han, Jeff Pool, John Tran, and William J Dally. Learning both weights
and connections for efficient neural networks. In Advances in Neural In-
formation Processing Systems (NeurIPS), pages 1135–1143, 2015.

Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared

Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion
parameter language models using model parallelism. arXiv preprint
arXiv:1909.08053, 2019.

Joseph McDonald, Baolin Li, Nathan Frey, Devesh Tiwari, Vijay Gade-
pally, and Siddharth Samsi. Great power, great responsibility: Recom-
mendations for reducing energy for training language models. Findings
of the Association for Computational Linguistics: NAACL 2022, 2022.
doi: 10.18653/v1/[Link]-naacl.151. URL [Link]
18653/v1/[Link]-naacl.151.

Radosvet Desislavov, Fernando Martı́nez-Plumed, and José Hernández-

Orallo. Trends in ai inference energy consumption: Beyond the
performance-vs-parameter laws of deep learning. Sustainable Com-
puting: Informatics and Systems, 38:100857, 2023. ISSN 2210-5379.
doi: [Link] URL [Link]
[Link]/science/article/pii/S2210537923000124.

Greg Yang, Edward J. Hu, Igor Babuschkin, Szymon Sidor, Xiaodong Liu,
David Farhi, Nick Ryder, Jakub Pachocki, Weizhu Chen, and Jianfeng
Gao. Tensor programs v: Tuning large neural networks via zero-shot
hyperparameter transfer. arXiv:2203.03466, 2022.

Shuming Ma, Hongyu Wang, Lingxiao Ma, Lei Wang, Wenhui Wang, Shao-
han Huang, Li Dong, Ruiping Wang, Jilong Xue, and Furu Wei. The era
248 BIBLIOGRAPHY

of 1-bit llms: All large language models are in 1.58 bits. arXiv:2402.17764,
2024.

Guang Hao Low. Quantum Signal Processing by Single-Qubit Dynam-

ics. Thesis, Massachusetts Institute of Technology, 2017. URL https:
//[Link]/handle/1721.1/115025.

Iordanis Kerenidis and Anupam Prakash. Quantum Recommendation Sys-

tems. arXiv:1603.08675, September 2016.

Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika,
Dawn Song, and Jacob Steinhardt. Measuring massive multitask language
understanding. Proceedings of the International Conference on Learning
Representations (ICLR), 2021.

Guangxi Li, Xuanqiang Zhao, and Xin Wang. Quantum self-attention neural
networks for text classification, 2023b. URL [Link]
2205.05625.

El Amine Cherrat, Iordanis Kerenidis, Natansh Mathur, Jonas Land-

man, Martin Strahm, and Yun Yvonna Li. Quantum vision trans-
formers. Quantum, 8:1265, February 2024. ISSN 2521-327X.
doi: 10.22331/q-2024-02-22-1265. URL [Link]
q-2024-02-22-1265.

Ethan N. Evans, Matthew Cook, Zachary P. Bradshaw, and Margarite L.

LaBorde. Learning with sasquatch: a novel variational quantum trans-
former architecture with kernel-based self-attention. 2024. URL https:
//[Link]/abs/2403.14753.

Dominic Widdows, Willie Aboumrad, Dohun Kim, Sayonee Ray, and

Jonathan Mei. Quantum natural language processing. 2024. URL
[Link]

Yeqi Gao, Zhao Song, Xin Yang, and Ruizhe Zhang. Fast quantum algorithm
for attention computation. 2023. URL [Link]
08045.

Chen-Yu Liu, Chao-Han Huck Yang, Min-Hsiu Hsieh, and Hsi-Sheng Goan.
A quantum circuit-based compression perspective for parameter-efficient
learning. 2024b. URL [Link]
BIBLIOGRAPHY 249

Siyi Yang, Naixu Guo, Miklos Santha, and Patrick Rebentrost. Quan-
tum Alphatron: quantum advantage for learning with kernels and
noise. Quantum, 7:1174, November 2023. ISSN 2521-327X.
doi: 10.22331/q-2023-11-08-1174. URL [Link]
q-2023-11-08-1174.

Chenyi Zhang and Tongyang Li. Comparisons are all you need for optimizing
smooth functions, 2024. URL [Link]

Hao Wang, Chenyi Zhang, and Tongyang Li. Near-optimal quantum algo-
rithm for minimizing the maximal loss, 2024c. URL [Link]
abs/2402.12745.

Patrick Rebentrost, Maria Schuld, Leonard Wossnig, Francesco Petruccione,

and Seth Lloyd. Quantum gradient descent and newton’s method for
constrained polynomial optimization, 2018b. URL [Link]
abs/1612.01789.

Yidong Liao and Chris Ferrie. Gpt on a quantum computer. 2024. URL
[Link]

Nikhil Khatri, Gabriel Matos, Luuk Coopmans, and Stephen Clark. Quixer:
A quantum transformer model. 2024. URL [Link]
2406.04305.

Wassily Hoeffding. Probability inequalities for sums of bounded random

variables. The collected works of Wassily Hoeffding, pages 409–426, 1994.

Herman Chernoff. A measure of asymptotic efficiency for tests of a hy-

pothesis based on the sum of observations. The Annals of Mathematical
Statistics, pages 493–507, 1952.

Masashi Okamoto. Some inequalities relating to the partial sum of binomial

probabilities. Annals of the institute of Statistical Mathematics, 10:29–35,
1959.

Alfred Haar. Der massbegriff in der theorie der kontinuierlichen gruppen.

Annals of mathematics, 34(1):147–169, 1933.

Gabriel Nagy. On the haar measure of the quantum su (n) group. Commu-
nications in mathematical physics, 153:217–217, 1993.

Martin Adam. Applications of unitary k-designs in quantum information

processing. PhD thesis, Masarykova univerzita, Fakulta informatiky, 2013.
250 BIBLIOGRAPHY

Martin Larocca, Supanut Thanasilp, Samson Wang, Kunal Sharma, Ja-

cob Biamonte, Patrick J Coles, Lukasz Cincio, Jarrod R McClean, Zoë
Holmes, and M Cerezo. A review of barren plateaus in variational quan-
tum computing. arXiv preprint arXiv:2405.00781, 2024.

Z Puchala and JA Miszczak. Symbolic integration with respect to the haar

measure on the unitary groups. Bulletin of the Polish Academy of Sci-
ences. Technical Sciences, 65(1):21–27, 2017.

Aidan Roy and Andrew J Scott. Unitary designs and codes. Designs, codes
and cryptography, 53:13–31, 2009.