On the Relation between Trainability and Dequantization of Variational Quantum Learning Models

## Abstract

Abstract The quest for successful variational quantum machine learning (QML) relies on the design of suitable parametrized quantum circuits (PQCs), as analogues to neural networks in classical machine learning.
Successful QML models must fulfill the properties of trainability and non-dequantization, among others.
Recent works have highlighted an intricate interplay between trainability and dequantization of such models, which is still unresolved.
In this work we contribute to this debate from the perspective of machine learning, proving a number of results identifying, among others when trainability and non-dequantization are not mutually exclusive.
We begin by providing a number of new somewhat broader definitions of the relevant concepts, compared to what is found in other literature, which are operationally motivated, and consistent with prior art.
With these precise definitions given and motivated, we then study the relation between trainability and dequantization of variational QML.
Next, we also discuss the degrees of “variationalness” of QML models, where we distinguish between models like the hardware efficient ansatz and quantum kernel methods.
Finally, we introduce recipes for building PQC-based QML models which are both trainable and nondequantizable, and corresponding to different degrees of variationalness.
We do not address the practical utility for such models.
Our work however does point toward a way forward for finding more general constructions, for which finding applications may become feasible.

## I Introduction

Quantum Machine Learning (QML) algorithms [, , , , , , ] are among the most-often cited applications for near-term and intermediate-term quantum devices [, , , , , ].
QML models are predominantly based on parametrized quantum circuits (PQCs) [, ].
One of the main questions in the field at the moment is *how do we design good PQCs for QML?*
The quest for good PQCs for QML may involve several challenges, and we distill a few of them from the success story of Neural Networks (NNs) for classical Machine Learning (ML).
Some such favorable properties include those arising in ML theory, like *expressivity* [, , , , ], *generalization* [, , , , , , , , , , ], and *trainability* [, , , , , ].
Other desiderata include the capacity of the QML models to solve *practically relevant* problems [] or ask whether the models are *non-dequantizable*, meaning that the performance of the quantum method cannot be matched by a classical efficient method [, , , , , , , , , ].

In this work we provide new strides in this quest for good PQCs by constructing models that are trainable, non-dequantizable, and variational.
For these three notions, we have a strong wish to be as broad as possible while being sufficiently rigorous that mathematical proofs become possible.
Hence, we first spend significant effort to establish precise language so that we can pave the way towards discussing the loosely-defined fourth leg of practical relevance, as depicted in Fig. 1.
For the broad audience, the question of practical relevance may be the most interesting, as it aligns with the question of the “killer application” of quantum computers.
However, this is also arguably the most problematic characteristic to formally capture and treat theoretically.
As we strive to keep our work on unambiguous and precise grounds, we focus solely on the three other desiderata, and end up constricting models of arguably “just” academic interest.
Nonetheless, we believe these are necessary steps to take.

Figure: Figure 1: Venn diagram of machine learning models with respect to the favorable properties we study in this work. Precisely-defined concepts and results are denoted with solid lines; intuitive notions are marked in dashed lines. The different dashes account for the fact that we do formalize “Variational” via a proxy, whereas “Practically relevant” remains unspecified. The dotted arrow indicates that neural networks do not adhere to our proxy definition of variationalness, although they are non-controversially a variational machine learning model. In this work we chart the intersection between trainability, non-dequantizable, and variational QML models. The inclusion of practical relevance thus remains an open topic, and indeed we believe it is the most important current question in the field. The in-document reference numbers are Liu 2021 [] and Gyurik 2023 [].
Refer to caption: x1.png

While the concepts of *trainability* and *dequantization* are intuitively clear, we notice that finding well-defined, uncontroversial definitions is difficult.
As we elaborate below, in both these categories slight differences in the definitions result in completely different properties and relationships.
Thus, our first contribution is to formalize the question of trainability versus dequantization of PQC-based QML models in a very broad sense.
Our notion of trainability asks whether the solutions produced by a training algorithm for learning tasks of interest are as good as they could be.
We therefore go beyond other common proxies for trainability like the so-called Barren Plateau (BP) phenomenon [, ].
In a similar spirit, our notion of dequantization is broad: it demands the existence of a classical algorithm that achieves similar performance as a quantum one when tackling the same tasks.
This way, our focus surpasses just checking if a quantum circuit can be classically simulated.
We acknowledge these choices are different from the foci of other corners of recent literature which have explored the interplay between trainability and dequantization in quantum optimization tasks [].

The definitions we propose attempt to impose only the weakest restrictions we could demand while being sufficiently precise, and we explain at length why they are meaningful.
Next, we focus on the relation between BPs and trainability in a more narrow sense, and we elaborate on the distinction between simulation and dequantization.
Our main results are proofs that trainability does not imply dequantization in variational QML: there exist variational QML models which are gradient-based trainable and still non-dequantizable.

The rest of the manuscript is organized as follows:
In Section II we fix the relevant notation and definitions for PQC-based QML, trainability, and dequantization, and also flesh out some of the basic relations between these concepts that can be directly derived from previous works.
Section III introduces different degrees of variationalness in QML.
In Section IV we give the results that trainability does not imply dequantization for several degrees of variational QML.
Finally Section V summarizes the manuscript and discusses the results and outlook.

## II Trainability and dequantization of QML

### II.1 Supervised learning

In supervised learning, we consider a data domain $\mathcal{X}$ and a label co-domain $\mathcal{Y}$, and a learning task is specified by a probability distribution $\mathcal{D}(\mathcal{X}\times\mathcal{Y})$ over inputs and labels(^1^11 A common special case of this is where there is a single ground truth function $f$. Then for each $x$ there is a single label $y=f(x)$, and we have an underlying distribution over $\mathcal{X}$. Then the joint distribution is given by $P(x,y)=\delta(y=f(x))P(x)$, where $\delta$ is the Dirac delta.).

A learning model ($\mathcal{F},\mathcal{A}$) consists of a family of functions $\mathcal{F}\subseteq\mathcal{Y}^{\mathcal{X}}$, called the hypothesis family, and a training algorithm $\mathcal{A}:\{\text{data sets}\}\to\mathcal{F}$ which, for a given training set, selects a hypothesis in the family.
A training set is a collection of labeled examples $S\sim\mathcal{D}^{N}$ sampled independently from the problem distribution.

A risk functional $R:\mathcal{Y}^{\mathcal{X}}\to\mathbb{R}_{\geq 0}$ is used to assess the quality of each function as a solution to the learning task.
The goal of the training algorithm $\mathcal{A}$ is to find a hypothesis $f$ which approximately minimizes $R(f)$ for the problem distribution given just the dataset.
Most training algorithms make use of the efficient-to-compute empirical risk $\hat{R}_{S}$, which is a proxy of $R(f)$ in which the quality of the function as a solution is assessed only for the points of the training set $S$.
The risk functional is implicitly considered also as part of the learning task, which is specified by the pair $(\mathcal{D},R)$.

Since $\mathcal{A}$ is the algorithm that takes a dataset on input, $\mathcal{A}(S)$ denotes the actual function outputted by the training algorithm, and we call $f^{*}_{\mathcal{D}}$ an optimal solution to the task $(\mathcal{D},R)$ within the hypothesis family $f^{*}_{\mathcal{D}}\in\mathcal{F}$ (there may be more than one, so we pick any single one).
Similarly, we denote with $f^{*}_{S}\in\mathcal{F}$ an optimum of the empirical risk $\hat{R}_{S}$ with respect to the training set $S$.

### II.2 PQC-based QML models

In variational QML we consider PQC-based quantum learning models $\mathcal{F}_{Q}$, where each of the hypotheses $f\in\mathcal{F}_{Q}$ can be realized as a PQC of polynomial size in the relevant scaling parameter of the learning task.
There are several approaches to designing the PQCs, which can make different use of the parameters of the circuit.

One common approach to PQC-based QML is to have a PQC prepare a quantum state $\rho(x;\vartheta)$ dependent on both the input $x\in\mathcal{X}$ and some trainable parameters $\vartheta\in\Theta$, and then measure a fixed observable $\mathcal{M}$ to realize the function.
This corresponds to real-valued functions of the form $f_{\vartheta}(x)=\operatorname{tr}\{\rho(x;\vartheta)\mathcal{M}\}$.
In case the target labels must be integer-valued (or categorical), as is commonly the case in classification tasks, these functions are then composed with suitable real-to-integer mappings for reading out labels.
In either case, we refer to $f_{\vartheta}$ as labeling functions.

A common alternative to the above type of QML models are the quantum kernel methods, which rely on preparing a data-dependent state $\rho(x)$ to define a so-called Embedding Quantum Kernel (EQK) $k(x,x^{\prime})=\operatorname{tr}\{\rho(x)\rho(x^{\prime})\}$ [, ], which can be evaluated using a PQC.
For the quantum kernel approach, the resulting labeling functions are of the form $f_{\alpha}(x)=\sum_{i=1}^{N}\alpha_{i}k(x,x_{i})$, where $\{(x_{i})_{i}\}$ is the training set of size $N$ fed to the learning algorithm, and $\alpha=(\alpha_{i})_{i}$ is a real vector of trainable parameters.

The choice of the underlying PQC, as the so-called feature map in both approaches above, is known to be critical.
Two representative examples of QML models are: those based on the $1$-dimensional Hardware Efficient Ansatz (HEA) [], and the kernel-based QML model introduced in Ref. [].
We refer to the latter as the “DLP kernel” $k_{\mathrm{DLP}}$, as it was used to prove a quantum-classical learning separation for a learning task based on the Discrete Logarithm Problem (DLP), which is hard for classical computers under standard cryptographic assumptions.
We use these two examples throughout the work to illustrate the notions of trainability and dequantization that we introduce below.

### II.3 Trainability

Prior works have dealt with trainability in QML, but until now a formal definition has been lacking.
We next expose a few conflicting desiderata, which we take as guide to reach a working definition of trainability.
First, we would like to capture practically relevant definitions, which would conclude that, e.g. deep neural networks are (most of the time) trainable.
At the same time, a precise definition cannot ignore the fact that finding global optima of even simple learning models is NP-hard and too much to ask, as we elaborate shortly.
Consequently, we want to capture the notion that a learning model $(\mathcal{F},\mathcal{A})$ should be considered trainable if the solutions within $\mathcal{F}$ found by $\mathcal{A}$ are *good enough*.
Two issues make this a tricky business: specifying what good enough means and which tasks should the solutions be good for.

Venturing a naive definition like “a model is trainable if the learning algorithm solves every given task perfectly” runs into fundamental issues: under this definition no model can ever be trainable due to the no-free-lunch theorem [], which guarantees that for any model there is at least one learning task in which it must fail.
We could next lower the requirement from “the learning algorithm solves every given task perfectly” to “the learning algorithm solves every given task approximately”, meaning
“the performance of the hypothesis reached by the learning algorithm $R(\mathcal{A}(S))$ is approximately optimal *within the hypothesis class* $R(\mathcal{A}(S))\approx R(f^{*}_{\mathcal{D}})$, for any task $\mathcal{D}$”.
Under this definition we know that neither classical neural networks nor PQCs of log-depth can be trainable, unless $\mathsf{P}=\mathsf{NP}$ [].
Hence we must relax the assumptions further.
Responding with a more relaxed definition like “a model is trainable if there exists a learning task for which the learning algorithm outputs an approximately optimal hypothesis” results in too weak a notion for which all models are trainable, as another consequence of the no-free-lunch theorem.
Basing the definition on reaching locally optimal solutions is no help either, as there are models for which almost all local optima are guaranteed to be as bad as random guessing [], so there would be models which are trainable under this definition, but which always output bad solutions.
It may indeed be the case that many QML models display mostly bad local minima, and it is a still poorly understood miracle of deep learning that this it so often *not* the case there.
To avoid these problems, we decide to work with a context-dependent notion of trainability.

###### Definition 1 (Task-dependent trainability.) .

Given a suite of learning tasks of interest $\{(\mathcal{D}_{i},R_{i})_{i}\}$, we say a learning model $(\mathcal{F},\mathcal{A})$ is trainable if the following holds for each task: the empirical risk of the hypothesis produced by the learning algorithm is close to the optimal one within the class $\hat{R}_{S}(\mathcal{A}(S))\approx\hat{R}_{S}(f^{*}_{S})$ with high probability with respect to a training set $S$ of polynomial size being sampled i.i.d. according to $\mathcal{D}$.

This definition is of course not fully precise, as we did not specify the notion of closeness.
This is an issue that is usually much easier to handle on a case-by-case basis.

The conceptual idea is that a model is trainable for a given set of tasks if the labeling function outputted by the training algorithm is approximately optimal within the hypothesis family, with high probability over the drawing of the training set.
That is, a model can still be considered trainable even if it displays poor performance in a task it is not well-geared to solve.

Our definition of trainability bears some similarity to notions of *agnostic PAC learning* [].
The main difference to agnostic learning is that our definition involves the *empirical risk* $\hat{R}_{S}$, since in practice this is the quantity we have access to, and not the *expected risk* $R$.
Further demanding that the output should be approximately optimal with respect to the expected risk would be a statement about generalization and inductive bias [, , ], which is not our focus here.

Trainability is easy to establish for one of our illustrative examples: the DLP kernel.
The representer theorem guarantees that the hypotheses produced in standard kernel-based ML is optimal with respect to the empirical risk.
That means kernel methods are trainable via usual means under our definition, including the DLP kernel.
Regarding HEA-based models, our second illustrative example, it is not true in general that all HEA-based QML models are trainable under our definition.

The discussion of useful notions of trainability does not end here, though.
We have assumed nothing about the nature of the training algorithm so far.
In particular, it may be that we consider training algorithms $\mathcal{A}$ different from the ones QML practitioners would use.
Accordingly, it makes sense to also discuss the nature of the training algorithm $\mathcal{A}$.
For example, one could talk about *efficient trainability* by imposing that the learning algorithm $\mathcal{A}$ must run in polynomial time, and then also distinguish between quantum and classical efficient trainability.
The efficacy of simple algorithms like gradient descent is closely linked with the Barren Plateau phenomenon, which we discuss next.

###### Definition 1 (Task-dependent trainability.) .

### II.4 Barren Plateaus in Machine Learning

The Barren Plateau (BP) phenomenon introduced in Ref. [] has been taken as a proxy for trainability in optimization problems.
Here, we adapt the definition of BPs to make sense for any parametrized (Q)ML model with classical data $x$, in a similar way to Ref. [].
We propose a general definition which keeps the spirit that BPs are a concentration phenomenon that happens with high probability for random initialization of the variational parameters, independently of whether they are the weights and biases of a classical neural network, the rotation angles of a PQC, or the weights in the sum of kernel-based models.
The role of the parameters is different in the three cases, but in all of them we can consider a probability distribution over the parameter domain.

Then, given a parametrized (Q)ML hypothesis class $\mathcal{F}$ of size $n$(^2^22 We introduce the *size* of a hypothesis class $n$, which should capture both the width and depth of both PQCs and neural networks, and it can be fixed a posteriori.), with variational parameters $\vartheta\in\Theta$, and a probability distribution $\mathcal{P}$ over $\Theta$, we define BPs in ML as follows:

###### Definition 2 (Barren Plateaus in Machine Learning) .

The ML model $\mathcal{F}\coloneqq\{f_{\vartheta}\,|\,\vartheta\in\Theta\}$ has a Barren Plateau with respect to the parameter distribution $\mathcal{P}$ if the function value concentrates exponentially, either for all $x\in\mathcal{X}$:

$$ $\displaystyle\sup_{x\in\mathcal{X}}\operatorname*{Var}_{\vartheta\sim\mathcal{ P}}\left[f_{\vartheta}(x)\right]$ $\displaystyle\in\mathcal{O}(\mathrm{exp}(-n)),$ (BP1) $$

or, more weakly, in expectation over the inputs $x$ drawn according to the problem distribution $\mathcal{D}$:

$$ $\displaystyle\operatorname*{\mathbb{E}}_{x\sim\mathcal{D}}\operatorname*{Var}_ {\vartheta\sim\mathcal{P}}\left[f_{\vartheta}(x)\right]$ $\displaystyle\in\mathcal{O}(\mathrm{exp}(-n)).$ (BP2) $$

The operational meaning of this definition changes depending on the type of the ML model.
We set this definition so that the moral of the story remains the same: if a ML model exhibits a BP in this sense, then there may be obstacles preventing trainability via usual methods.
We shed light on the fine print throughout the following sections.
This definition gives rise to a similar scenario as that of Ref. [], just here the focus is on the hypothesis families present in ML, and not on the quantum states prepared by the PQCs.

Specifically for kernels, this definition talks about the parameters $\alpha$ of the hypothesis family, as introduced in Section II.2.
Ref. [] considered the case where the kernel function itself concentrates, a phenomenon dubbed *vanishing similarity*.
Kernel functions suffering from vanishing similarity could result in a BP for the corresponding hypothesis family as defined here, yet only in one of the two senses we consider.
Recall that for kernel methods the hypothesis family itself depends on the training data: the label given to a new input comes from comparing it with every datum in the training set.
That means that kernel methods in general do not have BPs *for every input* $x$, in the sense of Eq. (BP1), since evaluating the labeling function on the points of the training set most often results in non-vanishing values by construction.
Accordingly when we talk about BPs for kernel-based QML models we implicitly assume we mean BPs *in expectation* over the inputs, in the sense of Eq. (BP2).
We note that there could be different natural definitions of BPs for QML, and that specifically for kernel-based hypothesis families the presence of BPs would be very sensitive to small changes in the definitions.

Back to our illustrative examples, Ref. [] showed that the HEA could have BPs under the uniform distribution due to its generic structure, but not for the case of shallow PQCs, of up to logarithmic depth, together with local observables.
Regarding the DLP kernel as our second example, in Ref. [] one sees that the DLP kernel is not affected by the vanishing similarity and has no BPs under the uniform distribution.

But recall that we are ultimately interested in *trainability*, and there BPs are not the whole story.
Works like [, , ] show how there can be BP-free models for which any training algorithm ends in a bad solution.
We show that the converse is also true: there can be QML models with BPs and which are still trainable.

###### Proposition 1 .

There exists QML models which have BPs under the uniform distribution and are trainable for learning tasks that are classically intractable under standard cryptographic assumptions.

###### Proof sketch.

The basic idea behind the proof (the full proof is in Appendix A) is to take a kernel method which is trainable and which solves a classically-intractable learning task, like the one in Ref. [], and convert it into a deep-layered variational model which does exhibit BPs.
We show that the trainability of the kernel method gives a way to train the deep-layered circuit despite it having BPs, at least to the same performance as with the kernel-based approach.
The training algorithm does not initialize parameters and random and then take gradients.
Rather, it solves the kernel-based optimization problem and then sets all the parameters to match the outputted hypothesis (as explained in the appendix, we have an efficient mapping for the parameters of the deep-layered circuit to recover the kernel-based hypothesis).
The representer theorem then proves that we are not missing out on better solutions, which satisfies the “good solution” part of the definition of trainability.
∎

Noteworthy is that this construction does not educate us on how to design new trainable QML models.
Instead, we started from the DLP kernel, i.e. a QML model we knew to be trainable to begin with, and massaged it so that it would display a BP without changing its performance.
Still, this small result confirms that *absence of BPs is neither necessary nor sufficient for trainability in general*.
This does not mean that BPs do not suppose a problem when designing trainable PQCs, it only means they do not prevent all forms of trainability.
Indeed, the model was not *gradient-based trainable*.

###### Definition 2 (Barren Plateaus in Machine Learning) .

###### Proposition 1 .

###### Proof sketch.

### II.5 Gradient-based trainability

Trainability in the sense we introduced in the previous section is very broad, since it allows for unrealistic training algorithms.
Limiting the permitted training algorithms adds difficulty to designing trainable QML models, but at the same time it brings us closer to practically relevant results.
We introduce *gradient-based* training algorithms with the goal of reaching a more stringent notion that relates to currently used training algorithms [, ].
This section introduces and motivates gradient-based training algorithms and discusses the relation between gradient-based trainability and BPs.

We draw inspiration from the well-known Gradient Descent (GD) algorithm, which requires an initial specification of parameters, and uses the gradient of the empirical risk with respect to the parameters $\nabla_{\vartheta}\hat{R}_{S}(f_{\vartheta})$.
In GD an initial parameter specification is typically sampled from a distribution $\mathcal{P}$ over the parameter domain $\Theta$.
Then, parameters are sequentially updated in the direction opposite to the gradient $\nabla_{\vartheta}\hat{R}_{S}(f_{\vartheta})$ to minimize the empirical risk.
The particular parametrization $\vartheta\mapsto f_{\vartheta}$ is relevant, as different parametrizations of the same hypothesis family give rise to different gradients, and thus to different outputs using GD [].
This way, whether GD produces a good output from a hypothesis family $\mathcal{F}$ depends not only on the task $(\mathcal{D},R)$, but also on the initialization distribution $\mathcal{P}$, and the specific parametrization.

We generalize the GD algorithm by introducing *gradient-based* training algorithms, in Algorithm 1.
Gradient-based training algorithms retain the central role of both: the initialization distribution $\mathcal{P}$ and the specific parametrization of $\mathcal{F}$(^3^33 There exist non-gradient-based methods which share these features, like genetic or evolutionary algorithms, which we could have also included in an even more general family. We decide against a more general notion for the ease of presentation.).
In all, for a model $(\mathcal{F},\mathcal{A})$ to be gradient-based trainable, it needs to be trainable according to Def. 1, and the training algorithm $\mathcal{A}$ needs to be a gradient-based.

Figure: Algorithm 1 Gradient-based training algorithm.

An important restriction of gradient-based training algorithms is that they should not be allowed to evaluate the empirical risk corresponding to arbitrary parameters $\vartheta$.
Rather, the algorithm should start from a random initial specification $\vartheta_{0}\sim\mathcal{P}$, and then only be allowed to iteratively select new parameters which are geometrically close in parameter space.
This is why we limit the algorithm to only take steps in the direction of the gradient, up to an adaptive learning rate $C(\vartheta)$.
We prevent more complex algorithms to hide inside this update rule by restricting the allowed functional form of $C(\vartheta)$, which at step $t$ may only depend on $t$, $\nabla_{\vartheta}\hat{R}_{S}(f_{\vartheta_{t}})$, and $H_{\vartheta}(\hat{R}_{S}(f_{\vartheta_{t}}))$, where $H_{\vartheta}$ denotes the Hessian.

We note that a parameter distribution $\mathcal{P}$ already played a central role when introducing BPs in Def. 2.
Gradient-based trainability and BPs are clearly deeply related: if the model has a BP according to the distribution $\mathcal{P}$, then the value of all functions concentrates exponentially with high probability over $\mathcal{P}$, and so the gradient becomes exponentially small with high probability over $\mathcal{P}$, which means the optimization cannot tread towards the minima of the landscape.
For PQC-based models, precision is limited by the number of samples needed from the quantum computer, and BPs require exponentially many of them.

In Prop. 1 we showed that a deep HEA model can be trainable via a reduction to kernel methods.
Now, it follows that the same model is not gradient-based trainable under, e.g., the uniform distribution, since it is well-known that HEA has a BP under the uniform distribution, so any gradient-based approach must fail.
This way, we observe that *BPs do prevent gradient-based trainability with respect to the same distribution* and *trainability does not imply gradient-based trainability*.
But, since *a model may have a BP under a certain parameter distribution, but not under a different one*, it follows that *a model may be gradient-based trainable under a certain parameter distribution, but not under a different one*.
One could consider an alternative initialization distribution for the HEA which were guaranteed to recover the underlying kernel-based model, as it is known (as exploited later in Cor. 7) that such a model can be gradient-based trainable.
One should not wonder then about the presence of BPs under the uniform distribution anymore, but rather under this alternative one, and one would find that the deep HEA model does *not* have a BP under the alternative distribution.
For this reason, the presence of BPs and the gradient-based trainability of a given QML model should always be discussed with respect to the same parameter distribution $\mathcal{P}$.
This last point becomes especially relevant when discussing new promising initialization strategies for PQCs, like *warm starts* [].

One fact we exploit below is that kernel methods are in general also gradient-based trainable.
Even though we usually optimize the parameters of the kernel via a quadratic program, it is known that optimizing them via gradients produces similarly optimal outputs.
This results in one point in which we must proceed with care regarding kernels and BPs.
Even if a kernel function suffers from vanishing similarity and the resulting hypothesis family has a BP, that hypothesis family could still be considered gradient-based trainable.
The reason being that the concentration phenomenon of the function values does not apply to the training set, which is a measure-0 0 set.
Thus, when talking about gradient-based trainability and BPs of kernel-based QML, we consider a parametrization of the kernel-based hypothesis family where the role of the training data is played by other variational parameters that are sampled independently from the training set.
In that case, the functions also concentrate over the training set, and the presence of the BP results in non-trainability via gradients.

Revisiting our two central examples: on the one hand we know the DLP kernel is gradient-based trainable (it does not have a BP nor vanishing similarity).
Conversely, HEA-based models cannot be said to be gradient-based trainable in general, even in the BP-free cases, as their landscapes might still contain many bad local minima [, , ].

As a side remark, the importance of the initialization distribution is intuitive when discussing NNs.
Improvements in initialization have brought about major steps in the development of successful NN-based ML.
This way, our definition of BPs for ML also captures the *vanishing gradients* problem of NNs [], strictly from the lens of the initialization distribution (and not from the lens of activation function, and other forms of normalization or regularization).

### II.6 Dequantization

In the past few sections we have discussed concepts in the orbit of *trainability*.
In this section, we move to discussing *dequantization*.
We motivate the use of a task-dependent notion of dequantization, we remark the distinction to the related notion of classical simulation, and we briefly comment on the potential dequantization of our two illustrative examples.

Dequantization can be understood in a number of ways, but here we adhere to a rather general notion in which given a quantum algorithm, there is a (perhaps related) classical algorithm with matching performance for a given suite of tasks of interest.
This captures classical simulability of quantum circuits as discussed in [, ], but also more general classes of quantum-inspired algorithms à la Ewin Tang [], which “dequantized” much of quantum linear algebraic approaches, and also the recently introduced classical surrogate approaches [, , , , ].

Thus, in our reading, to dequantize a quantum learning model, it is enough to provide a roughly equally efficient classical learner (e.g. with polynomially related runtimes) that solves the same tasks at approximately at least the same level of performance.

###### Definition 3 (Dequantization in QML) .

Given a suite of learning tasks of interest $\{(\mathcal{D}_{i},R_{i})_{i}\}$, we say a QML model $(\mathcal{F}_{Q},\mathcal{A})$ is dequantizable if there exists a classical hypothesis family $\mathcal{F}_{C}$ and learning algorithm $\mathcal{A}_{C}\colon\{\text{data sets}\}\to\mathcal{F}_{C}\subseteq\mathcal{Y
}^{\mathcal{X}}$, such that the following holds for each of the learning tasks: given a training set $S$ sampled from the problem distribution, the performance of the classical learner is approximately at least as good as that of the quantum learner: $R(\mathcal{A}_{C}(S))\lesssim R(\mathcal{A}(S))$.

Although we define dequantization broadly in terms of a set of learning tasks, we wish to keep the focus on “dequantizing a model”, and not on “dequantizing a problem”, so the learning tasks of interest should be considered very general.
Below we elaborate on the distinction between this notion of dequantization and the related notion of simulating a PQC.

A limitation of this definition is that it could allow for very powerful learning models to be dequantized for relatively easy learning tasks.
Indeed, if we started from learning tasks which a classical model can solve approximately optimally to begin with, then every all-powerful learning model is immediately dequantizable for those learning tasks, even if the classical model is completely unrelated to the structure of the all-powerful model.
Similarly, we would say “the DLP kernel has been dequantized for the DLP-based learning task” already if we found an efficient classical algorithm for the discrete logarithm, in which case learning would be done by a completely different classical method, and not necessarily a kernel-based one.
Thus this definition spans also a gray area housing counter-intuitive true statements.
This is not to our detriment, as it is our manifest intent to consider broad definitions that could be further specialized a posteriori if needed.

One avenue to establish non-dequantization is to find a quantum advantage in learning, which in the language of PAC learning means to find a concept class which can be efficiently learned with a quantum computer but not with a classical computer.
Among the proposals for quantum advantages in learning within Ref. [], we find the use of “non-classical” hypothesis families and also “non-classical” training algorithms, both of which can give rise to learning tasks that are hard for any classical learner and easy for a given quantum learner.
Thus, depending on the source of quantum advantage (from training algorithm or hypothesis class itself), there may be different ways to approach dequantization.

One way applies in cases where the learning algorithm is easy (given the power to compute e.g. the values and derivatives of the parametrized hypothesis family), and the family is hard.
Here one could classically simulate all functions in the hypothesis family $\mathcal{F}_{Q}$:

###### Definition 4 (PQC simulation) .

We say a PQC-based function family $\mathcal{F}_{Q}$ is classically simulable if there exists a classical poly-time algorithm which can approximate $f_{\vartheta}(x)$ to good precision given $\vartheta$ and $x$.
This can be further specialized to hold either for all inputs $x$, for all parameters $\vartheta$, or with high probability under respective distributions.

Notice this is a statement only about a function family, and not about any learning task.
So dequantization and simulation in this sense are essentially different properties.

In general, the simulation of a hypothesis family is neither sufficient nor necessary for dequantization of the corresponding QML model, as the training algorithm itself could perform classically-hard computations (see Section 3 in Ref. []).
Yet we recall that many gradient-based training algorithms are classically tractable.
Indeed, assuming a classically-easy training algorithm, it holds that PQC simulation is sufficient for dequantization of the QML model *for all learning tasks*, and yet it is not necessary:

###### Proposition 2 (Adapted from [ 42 ] ) .

There exist QML models which are dequantizable but whose circuits are not simulable.

###### Proof sketch.

The basic idea (the full proof is in Appendix A) is that there exist functions which are hard to evaluate without data, but easy given data, as discussed in Ref. [].
∎

We have deliberately not observed the possibility of quantum pre-computation in our definitions, since we are interested in quantum-versus-classical separations.
Both Defs. 3 and 4 could be straightforwardly extended to accommodate quantum pre-computation, in which case they would be better suited toward studying quantum-versus-quantum separations instead.
This would be e.g. in the spirit of Ref. [], in which emphasis is placed on the distinction between PQCs and other simpler quantum circuits like the ones used in classical shadow protocols [].

We conclude this section by returning to our two illustrative examples (HEA and the DLP kernel), now from the point of view of dequantization.
First: Ref. [] relates that the classical simulability of HEA depends on precisely what we mean by HEA.
Whether we know how to simulate HEA depends mainly on the connectivity graph of the computing platform, the entropy of the initial state, and the locality of the measured observable.
Therefore from here on we consider only $1$-dimensional HEA where the observable and initial state are such that the whole circuit is simulable without any pre-computation.
This means that a QML model based on a shallow HEA with a local observable, together with a classically-easy training algorithm, is always dequantizable via direct PQC simulation for all possible tasks.
Conversely, for the DLP kernel: the learning-theoretic results brought forth in Ref. [] guarantee that no classical algorithm can solve the same learning task as the DLP kernel efficiently(^4^44 There are two ways in which we can leverage hardness of DLP-related problems to conclude non-dequantization. The simplest one is to assume the uniform version of the mapping from the quantum model $(\mathcal{F}_{Q},\mathcal{A})$ to the corresponding classical algorithm. In this case standard notions of hardness of DLP suffice. If we instead demand that there should exist a classical model $(\mathcal{F}_{C},\mathcal{A}_{C})$ which does the same job, in this case we need to assume the existence of a sequence of hard primes and generators for the DLP problem, see Ref. [] for a more in-depth discussion.).
This constitutes proof that the QML model based on the DLP kernel is non-dequantizable.
The latter argument says nothing about simulating the corresponding circuit directly, but since *simulable* $\Rightarrow$ *dequantizable* with a classically efficient training algorithm, it immediately follows that *non-dequantizable* $\Rightarrow$ *non-simulable*.

###### Definition 3 (Dequantization in QML) .

###### Definition 4 (PQC simulation) .

###### Proposition 2 (Adapted from [ 42 ] ) .

###### Proof sketch.

### II.7 Trainability versus dequantization

Up until now we have introduced five main concepts: trainability, gradient-based trainability, absence of BPs, simulability, and dequantization.
We have also shown some relations between trainability, gradient-based trainability, and absence of BPs, on the one hand; and the relation between simulability and dequantization, on the other hand.
In this section we first revisit recent developments on the relation between absence of BPs and simulability, and then we comment on the relation between (gradient-based) trainability and dequantization.
We observe at the end of the section that in order to make a contribution beyond re-interpreting prior work we need to discuss the role of variationalness in QML.

Recollecting: the $1$-dimensional shallow HEA with local observables is known to be both free of BPs [] and classically simulable [].
This is not an isolated case: the search for trainable PQCs has struggled to stay ahead of the efforts in dequantization.
For instance Refs. [, , , , , , , , , , , ] contain proofs that certain PQC Ansätze are free of BPs.
The unifying work of Refs. [, ] offers an algebraic perspective into BPs which Ref. [] uses to prove that these same Ansätze are indeed classically simulable (potentially with quantum pre-computation).
Intriguingly, the results of Ref. [] reach most PQC Ansätze for which we have a proof of abscence of BPs.
This hints at a larger question: *Is it true that all provably BP-free Ansätze are also classically simulable(^5^55 Note the difference between “all PQCs for which we have a proof” and “all PQCs for which there exists a proof”.)?*
The answer to this question is known in general to be negative: on the one hand, one can construct contrived counter-examples, as in Appendix B in Ref. []; and, on the other hand, it is yet unclear whether specialized parameter initialization techniques known as *warm starts* [] can break current attempts at classical simulability of PQCs, for example for PQCs with BPs under the uniform distribution, which are average-case trivially simulable.
There is an important open question in this direction: are there *natural* counterexamples, so not contrived?
Finding a natural counterexample would potentially amount to achieving our main goal: to design PQCs that are trainable, non-dequantizable, and can solve practically relevant tasks.

It may not be surprising that we already know that trainability does not imply dequantization in QML, according to our definitions:

###### Proposition 3 (Learning separation in Ref. [ 41 ] ) .

There exist QML models which are trainable and non-dequantizable.

###### Proof.

The learning separation in [] is the proof.
There is a learning task based on the DLP which no classical learner can solve according to cryptographic assumptions, and the authors construct a QML model which solves it with high probability.
The fact that the QML model solves this task confirms that the model is trainable, and the fact that this task cannot be solved classically confirms it is non-dequantizable under standard assumptions.
This completes the proof.
∎

###### Corollary 4 .

There exist deep-layered circuits, like Deep HEA, which are trainable and non-dequantizable.

###### Proof.

It follows directly from combining the proofs of Props. 1 and 3.
The training algorithm involves a reduction to kernel methods and is not gradient-based, and the task is the same as the DLP kernel, which no classical algorithm can solve.
∎

###### Corollary 5 .

There exist QML models which are gradient-based trainable and non-dequantizable.

###### Proof sketch.

As mentioned above, usual kernel models like the DLP kernel can also be trained via gradients.
These models do not have a BP under the uniform distribution.
∎

All these constructions rely on a reduction to kernel methods, they do not educate us on how to design variational PQCs with which to furnish other variational QML models.
Nevertheless, they help settling the lines of discussion.
Yet, we need one final distinction: between general “QML” and specific “variational QML”.

###### Proposition 3 (Learning separation in Ref. [ 41 ] ) .

###### Proof.

###### Corollary 4 .

###### Proof.

###### Corollary 5 .

###### Proof sketch.

## III Degrees of variationalness in QML

Figure: Figure 2: Degrees of variationalness of QML models considered in this work. Spectrum of variationalness of quantum machine learning models considered in this work, see also Table 1. The color indicates the potential dequantization of these models. The shaded white area marks the possible existence of other variational quantum machine learning models, strictly more variational than the vari veryational models we introduce, still gradient-based trainable. None of the models in this spectrum have been found to be practically relevant, which still remains a critical open question. The in-document reference numbers are Liu 2021 [] and Cerezo 2023 [].
Refer to caption: x2.png

**Table 1: QML models considered in this work according to their trainability, non-dequantization, and degree of “variationalness”. Our main contribution are what we dub vari veryational models, which are trainable, non-dequantizable, and variational. The question whether one should consider further very variational models remains open.**
| QML model | Gradient-based | Non- | Very |
| --- | --- | --- | --- |
| Trainable? | dequantizable? | variational? |  |
| Shallow HEA | ✓ | ✗ | ✓ |
| + local obs [] |  |  |  |
| DLP kernel [] | ✓ | ✓ | ✗ |
| Deep HEA | ✗ | ✓ | ✓ |
| Somewhat variational | ✓ | ✓ | ✗ |
| [Cors. 6, 7] |  |  |  |
| Vari veryational [sic] | ✓ | ✓ | ? |
| [Thm. 8, Cor. 9] |  |  |  |
| ? | ✓ | ✓ | ✓ |

We have established that trainability does not imply dequantization, yet for certain variational models it does.
So the question is whether the notion of being variational causes the issue.
For example kernel-based QML models are not *less variational* than other PQC-based models where the parameters of the circuit are directly optimized.
To explore this we try to pinpoint a workable measure of being variational and then define a spectrum of models along this measure to understand where and why issues arise, as shown in Fig. 2.
The next section then discusses gradient-based trainability and dequantization specifically for variational QML models.

The starting point in the discussion is: what does actually make a quantum algorithm “variational”?
The concept clearly has room for different interpretations, which affect what can be proven and what is true.
We use our two central examples to discuss variationalness.
In the case of HEA, the variational parameters of the circuit $\vartheta$ are directly optimized over, most commonly using gradients, like in NNs.
For models like the DLP kernel, not only are the free parameters $\alpha$ tuned by a quadratic program after the quantum kernel has been evaluated on the training set, but also these parameters are not the angles of rotation gates in the circuit.

Since the concept of variationalness is not well-defined, here we take “similarity to the HEA” as a proxy for it, as shown in Fig. 2.
Indeed, this notion of variationalness allows us to cover the space between the DLP kernel (trainable, non-dequantizable, non-variational) and the shallow HEA (BP-free, dequantizable, variational), detailed in Table 1.
We build up to a list of well-posed properties that aim at capturing the essence of variationalness from the HEA design.
We are interested in bottom-up, structural properties for the design of the PQC, and not abstract quantities that might be hard to estimate for a given circuit.
As a first step, we identify the minimal requirement for a QML model to be considered at least “somewhat variational”: that the trainable parameters appear in the angles of rotation gates in the circuit.
As already hinted at in Prop. 1, somewhat variational models have a flaw: they can be just kernel methods in disguise, which means they are not variational enough.

We then go beyond somewhat variational models by considering some defining aspects of the design of the HEA:
(1) the PQC should consist of repeated layers $U_{1}(x;\vartheta_{1}),\ldots,U_{L}(x;\vartheta_{L})$ that depend on both inputs and parameters, uniformly;
(2) the number of layers $L$ should be tunable and independent of the number of qubits $n$;
(3) the PQC should start from the $\lvert 0\rangle$ state; and
(4) we should measure a fixed observable $\mathcal{M}_{0}$, independent of the number of layers $L$, at the end.
We refer to QML models that fulfill these properties as “vari veryational”(^6^66 “Vari veryational” is a *spoonerism* of “very variational” [].).
This is our best attempt to capture the essence of what makes a QML model fundamentally variational.
Specifically, vari veryational models make for ideal deep-layered circuits, which is the main area of application in the study of BPs.

Yet, our desire is to eventually define what “very variational” models are.
We note that, in spite of our best ideas, there may be a better definition, and that is the reason why we use the term vari veryational for the models above.
We invite researchers to contribute new bottom-up, structural properties to be added to our list of vari veryational models so that, ideally, we reach the best possible definition, which then would receive the name very variational.

## IV Trainability versus dequantization in variational QML

Section II.7 concluded that the previously existing learning separations already constitute proof that (gradient-based) trainability does not imply dequantization in QML.
Yet every QML model above had kernel methods at their core, which we have labelled non-variational in Section III.
In this section we study the relation between trainability and dequantization specifically for variational QML models.
To this end, we consider the spectrum of QML models, based on our intuitive reading of their “variationalness”, collected in Table 1 and Fig. 2.
A complete layout of the implications and non-implications we discuss and prove in this paper is then given in Fig. 3.

Figure: Figure 3: Main notions studied in this work. The blue lines are proven implications, the orange lines indicate the existence of counterexamples. We quote the results that contain the counterexamples: where boxes with solid contour lines refer to this work, boxes without a contour refer to prior art. The in-document reference numbers are Liu 2021 [], Anschuetz 2022 [], and Cerezo 2023 [].
Refer to caption: x3.png

We tackle the question of trainability versus dequantization individually for both: somewhat variational models, and vari veryational models, as just introduced.
We show that indeed trainability does not imply dequantization by explicitly constructing learning separations.
The models and tasks we consider are artificial and their only purpose is to show the learning separation when trained via gradients.

For didactic purposes we start with the simplest somewhat variational models:

###### Corollary 6 .

There exists a somewhat variational QML model with a single parameter which is gradient-based trainable and non-dequantizable.

###### Proof sketch.

Take the DLP kernel $k_{\mathrm{DLP}}$ and add a single qubit rotation gate $U(\vartheta)$ somewhere inside the circuit, which gives rise to the parametrized kernel function $k_{\vartheta}(x,x^{\prime})$.
Assume also that the placement of $U(\vartheta)$ does not result in a vanishing gradient, so that, with high probability over $x,x^{\prime}$, and $\vartheta$ sampled uniformly at random from their respective domains, $\lvert\partial_{\vartheta}k(x,x^{\prime})\rvert\geq 1/\operatorname{poly}(n)$, where $n$ is the length of $x$.
To make things non-trivial, assume there exists an unknown value $\vartheta_{0}\neq 0$ for which $U(\vartheta_{0})=\mathbb{I}$.
For the gradient-based trainability we sample an initial parameter from the uniform distribution in $[0,2\pi)$.
In order to show this model is trainable and non-dequantizable, we must only show that a gradient-based training algorithm can find a good enough approximation of $\vartheta_{0}$, and then the model reduces to $k_{\mathrm{DLP}}$, which is trainable and non-dequantizable.
The gradient-based optimization can be used for example to optimize the target-kernel alignment loss function [, ].
With high probability the random initialization on of the variational parameter is such that the target-kernel alignment loss function can be trained via gradient descent.
∎

One could argue that a QML model that contains only one parameter is by no means variational enough.
Instead one could demand that the number of parameters be related to the size of the model.
For instance we next consider somewhat variational models where the number of trainable parameters scales with the number of qubits:

###### Corollary 7 .

There exists a somewhat variational QML model with number of training parameters at least linear in the number of qubits which is gradient-based trainable and non-dequantizable.

###### Proof sketch.

The key idea is that the hypothesis family in kernel methods uses parameters in a different way to other PQCs.
Indeed, for a given training set $S=\{(x_{i},y_{i})_{i=1}^{N}\}$, a ML model based on a given kernel $k$ must output functions of the form $f_{\alpha}(x)=\sum_{i=1}^{N}\alpha_{i}k(x,x_{i})$.
It is also known that the loss function used to optimize the parameters $\alpha$ for a given task is convex with respect to these parameters [].
This means that even though we normally use a different training algorithm, like Support Vector Machine or Kernel Ridge Regression, this optimization step could be satisfyingly solved via gradients, where the initial parameters $\alpha^{0}$ could be all set to 0 0, or all be drawn from a Gaussian with variance $1/\sqrt{N}$.

Recall that the DLP kernel $k_{\mathrm{DLP}}$ is an EQK and that the hypotheses it gives rise to are of the form $h_{\alpha}(x)=\sum_{i=1}^{N}\alpha_{i}k_{\mathrm{DLP}}(x,x_{i})$.
We would normally evaluate each of the overlaps individually and then perform the weighted sum on a classical computer, but we could instead evaluate the function directly on a PQC, borrowing ideas from the Linear Combination of Unitaries (LCU) framework [], assuming a normalization condition over $\alpha$.
We can consider the parametrized observable $\mathcal{M}(\alpha,(x_{i})_{i})=\sum_{i=1}^{N}\alpha_{i}\rho(x_{i})$, which can be realized as a PQC with depth at least linear in the number of qubits, due to the construction in Ref. [].
For us to execute the parametrized observable $\mathcal{M}(\alpha,(x_{i})_{i})$ as an LCU circuit, we need to perform amplitude encoding of $\alpha$ on an auxiliary register with logarithmically many qubits in the size of the training set.
Then, we are left with the PQC-based QML model

$$ $\displaystyle\mathcal{F}_{Q}=\{f_{\alpha}(x)=\operatorname{tr}\left\{\rho(x) \mathcal{M}(\alpha,(x_{i})_{i})\}\,|\,\lVert\alpha\rVert_{1}=1\right\}.$ (1) $$

This is the hypothesis family spanned by the DLP kernel, so we know it can solve a non-classically-solvable learning task.
Finally, recalling that the loss function we optimize is convex with respect to $\alpha$, it is confirmed that the model is gradient-based trainable for the task, and further that it is non-dequantizable.

We note this proof is similar to the proof of Prop. 1 in Appendix A.
The main two differences are (1) that in Prop. 1 we were allowed any training algorithm, whereas here we are restricted to a gradient-based algorithm, and (2) that the construction in Prop. 1 has a BP, while the construction here does not.
∎

Cors. 6 and 7 enlighten the relationship between trainability and dequantization when focusing on a strictly variational setting.
Nevertheless, we deem them unsatisfying on one account: their proofs still rely on reductions to kernel methods.
We want to move away from such non-variationalness, and so we next consider vari veryational QML models.

As our final contribution, we show that trainability does not imply dequantization also for vari veryational models.
As a first step, we propose a recipe for trainable, non-dequantizable QML models based on the combination of two quantum circuits: one evaluating a classically-intractable function, and one giving rise to an easy optimization problem.
Bringing both together in a straightforward way (tensor product), results on a learning model that is as easy to train as the easy optimization problem, but whose functions are as difficult to evaluate as the difficult function.

###### Theorem 8 .

Let $\mathcal{X}=\{0,1\}^{n}$ and $\mathcal{Y}=\{0,1\}$.
Let $Q(x)$ be a function in $\operatorname{\mathsf{BQP}}$ and not in $\operatorname{\mathsf{HeurBPP/poly}}$ under a given distribution $\mathcal{P}(x)$, and let $U(x)$ be a unitary such that $\langle 0\rvert U^{\dagger}(x)Z_{1}U(x)\lvert 0\rangle=Q(x)$.
Let $\mathcal{H}$ be a Hamiltonian, and $W(\vartheta)$ a parametrized unitary for which the following optimization problem can be solved with a given gradient-based algorithm $\mathcal{A}_{W}$:

$$ $\displaystyle\vartheta^{*}\leftarrow\arg\max_{\vartheta\in\Theta}\langle 0 \rvert W^{\dagger}(\vartheta)HW(\vartheta)\lvert 0\rangle,$ (2) $$

and such that $\max_{\vartheta\in\Theta}\langle 0\rvert W^{\dagger}(\vartheta)HW(\vartheta)
\lvert 0\rangle=1$.
Call $V(x;\vartheta)=U(x)\otimes W(\vartheta)$, and $\mathcal{M}=Z_{1}\otimes H$, and consider the corresponding hypothesis class $\mathcal{F}_{Q}$:

$$ $\displaystyle\mathcal{F}_{Q}\coloneqq\{f_{\vartheta}(x)=\langle 0\rvert V^{ \dagger}(x;\vartheta)\mathcal{M}V(x;\vartheta)\lvert 0\rangle\,|\,\vartheta\in \Theta\}.$ (3) $$

Let $\mathcal{D}_{\mathcal{P}}$ specify a learning task: $P(x,y)=\mathcal{P}(x)\delta(y=Q(x))$.

Then $\mathcal{F}_{Q}$ is gradient-based trainable for $\mathcal{D}_{\mathcal{P}}$, and it is not dequantizable.

###### Proof sketch.

The full proof is in Appendix B.
The learning task $\mathcal{D}_{\mathcal{P}}$ combines evaluating a single classically intractable function and an easy optimization.
Solving the learning task requires evaluating the single function.
Since we take the function to be neither classically evaluatable nor classically learnable, it follows that no classical algorithm can solve the learning task.
Since the function is in BQP and moreover we have access to the circuit that evaluates it, the quantum model can evaluate it.
After evaluating the function, training the quantum model is as difficult as solving the parametrized optimization task.
Since by assumption the optimization problem can be solved with a given gradient-based algorithm, it follows that the model is gradient-based trainable using the same algorithm.
∎

The construction in Theorem 8 resembles the construction in Appendix B of Ref. [], which also takes advantage of functions in $\operatorname{\mathsf{BQP}}$ and not in $\operatorname{\mathsf{HeurBPP/poly}}$ to prevent classical simulation.
The main difference in our result is that we state the problem as a supervised learning problem, instead of the problem of only evaluating the function (which eventually we shall want to optimize).
Note that the tensor product structure we use is clearly different from typical PQCs one may encounter in QML.
The following result takes one more step away from the construction in Ref. [] in that we further impose a uniform deep-layered Ansatz structure.

Note that neither the statement nor the proof of Theorem 8 mentions variationalness.
It is in the following corollary that we construct a learning separation based on Theorem 8 but for which the quantum model is required to be vari veryational.

###### Corollary 9 .

There exist vari veryational QML models which are gradient-based trainable and non-dequantizable with any number of repeating identical and parametrized layers up to sub-exponentially many in the number of qubits.

The construction of the vari veryational circuit we use as proof is in Appendix B, together with a brief discussion on this construction versus the one given in Appendix B of Ref. [].

###### Proof sketch.

We must only take Theorem 8 and propose a special case where $\mathcal{F}_{Q}$ is vari veryational.
The main hurdle is to ensure that $\mathcal{F}_{Q}$ allows a deep-layered structure, as in general even if a circuit $U(x)$ gives rise to a hard function, a sequential concatenation of the circuit $U^{L}(x)=U(x)U(x)\cdots U(x)$ could give rise to a non-hard function.
A deep-layered structure is easy to achieve for the trainable part: first we can take $H$ to be single-qubit, with e.g. $H=Z$, and then we can take $W(\vartheta)=\prod_{j=1}^{L}R_{X}(\vartheta_{j})$.
With these, it follows that initializing $\vartheta$ uniformly at random and then performing gradient descent is enough to solve the optimization task.
For the classically-hard unitary, we start from any given $U(x)$ and expand into a unitary $\tilde{U}(x)$ acting on the same qubits as $U(x)$ and $t$ extra auxiliary ones.
The unitary $\tilde{U}(x)$ applies $U(x)$ on the original qubits only if all the auxiliary qubits are on state $\lvert 0\rangle$, and then $\tilde{U}(x)$ performs modular addition by one on the auxiliary register $\lvert j\rangle\mapsto\lvert j+1\bmod{2^{t}}\rangle$.
What we achieve by this is that, by repeating $\tilde{U}(x)$ uniformly on the all-$\lvert 0\rangle$ state $\prod_{j=1}^{L}\tilde{U}(x)\lvert 0\rangle\!\lvert 0\rangle$, as long as the number of layers $L$ is subexponential in the number of auxiliary qubits, we obtain the same outcome when measuring $Z_{1}$ on the work register independently of the number of layers.
We combine $\tilde{U}(x)$ and $R_{X}(\vartheta_{j})$ to reach a single layer $V^{j}(x;\vartheta_{j})=\tilde{U}(x)\otimes R_{X}(\vartheta_{j})$.
It suffices for us to define $V(x;\vartheta)=\prod_{j=1}^{L}V^{j}(x;\vartheta_{j})$ to fulfill all the assumptions of Theorem 8.
By going through the list of properties of vari veryational QML models, we can see that indeed, this hypothesis family $\mathcal{F}_{Q}$ fulfills all of them.
∎

Since vari veryational models are a special case of somewhat variational ones, Cor. 9 alone is enough proof for both scenarios.
Still, Cors. 6 and 7 served the didactic purpose of showing that the DLP kernel can be hidden in variational PQC-based models which are trained via gradients.

The ideas behind these constructions at least provide a direction toward a class of methods which are gradient-based trainable and non-dequantizable built in a rather natural way – by combining trainable models with the computation of a hard function.
One way of moving forward would be by relaxing the tight structure of the hard computation which is embedded to something more general, but which is still arguably hard to simulate (for example in the construction of Cor. 9 we had to resort to unnatural counters to make sure we have easy non-simulability even when layers iterate; however in our view it would not be a foolish bet that even without the counter, a more natural construction which just repeats a hard circuit is in general hard to simulate, although at present we do not have a proof of this claim.)

###### Corollary 6 .

###### Proof sketch.

###### Corollary 7 .

###### Proof sketch.

###### Theorem 8 .

###### Proof sketch.

###### Corollary 9 .

###### Proof sketch.

## V Summary and outlook

In this work we have discussed general notions of trainability and dequantization for Quantum Machine Learning (QML) models based on Parametrized Quantum Circuits (PQCs).
We have proposed clear definitions for trainability and dequantization.
We have argued that our definitions are operationally meaningful and not more restrictive than necessary.
We have proved several relations between trainability, dequantization, and other common features in the literature like Barren Plateaus (BPs) and quantum circuit simulation, as depicted in Fig. 3.
We have also discussed the need to focus on restricted notions of *gradient-based* trainability and *variational* QML, as a means to approach the question of designing good PQCs for QML.
We have also focused on increasingly realistic definitions of “variationalness” in QML.
We introduced a new family of *vari veryational* QML models, which convey the essence of commonly used gradient-based training algorithms and deep-layered PQCs.
This discussion is supported by providing recipes for variational QML models which are trainable and non-dequantizable.

Throughout our discussion, we have made observations that may seen counterintuitive upon first glance.
For example: absence of Barren Plateaus is neither necessary nor sufficient for trainability in general, but it is necessary for gradient-based trainability; and classical simulation is neither necessary nor sufficient for dequantization in general, but it is sufficient if we assume the training algorithm is classically efficient.
These remarks call for a more nuanced analysis when moving forward in the study of trainability and dequantization of PQC-based QML.

Unfortunately, the models we have designed to prove the results were all contrived examples.
For instance in Theorem 8 we take advantage of a PQC construction that perfectly splits up into two disconnected circuits, one carrying out a classically-hard computation, and the other one bearing an easy-to-optimize variational circuit.
Indeed, this proof by itself falls short of providing insightful design principles for PQC-based QML models.

In a broader context, our results raise deeper questions.
As discussed in Ref. [], all the utilized learning separations rely on computationally hard problems, and some of them are arguably not about learning.
The way in which we ensured that our QML models would solve the problem was by planting the solution in the architecture of the hypothesis family itself.
This may be deemed unsatisfactory, as the learning task could be trivially solved by the QML model we constructed.
And yet, a critical question remains: how to design QML models with a certain inductive bias [, ].
It seems, then, that a fruitful research direction shall be to explore the space between completely generic circuits (no inductive bias) and circuits where the answer to a computationally hard problem is hard-coded.

On a different note, previous proofs of simulation of BP-free circuits have relied to some degree on a specific class of simulation algorithms, exploiting the so-called *polynomial subspaces* [], either exactly or approximately.
An advantage of this approach is that the dequantization proofs come with a directly implementable algorithm.
A disadvantage is that these simulation algorithms may only be guaranteed to succeed with high probability over the parameter domain, and that leaves the door open for them to fail precisely on the cases which would be interesting for QML.
Our contributions in this direction show that it is easy to plant computationally-hard problems in variational QML, and so this questions the role of average-case classical simulation algorithms.

If history is anything to go by, the applications of ML-related technologies are often surprising, and found through trial and error, rather than algorithmic analyses.
There is no reason to expect QML to be different, especially in the sense that predicting outstanding performance for a task may be very hard without extensive evaluations (at least: we do not expect to be able to find the majority of applications this way).
Consequently, at present one of the main goals would be to find models which are at least trainable, and which at least have the capacity for non-dequantization relative to *all tasks* (i.e. dequantization by direct PQC simulation).
Further, toward broad-purpose QML methods (and as opposed to the valuable investigations of introducing the right domain-specific inductive biases), it is also important to keep the models as expressive as possible, at least in principle.
Our paper makes strides in this direction.

### Acknowledgements

The authors thank Marco Cerezo, Jens Eisert, Zoë Holmes, Jarrod McClean, and Ryan Sweke for their insightful comments in an earlier version of this draft.
EGF thanks Greg White for pointing out the concept of spoonerism.
EGF is a 2023 Google PhD Fellowship recipient and acknowledges support by the Einstein Foundation (Einstein Research Unit on Quantum Devices), BMBF (Hybrid), and BMWK (EniQmA).
CG, APS and VD were supported by the Dutch National Growth Fund (NGF), as part of the Quantum Delta NL programme.
This work was supported by the Dutch Research Council (NWO/OCW), as part of the Quantum Software Consortium programme (project number 024.003.03), and co-funded by the European Union (ERC CoG, BeMAIQuantum, 101124342).
Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union or the European Research Council.
Neither the European Union nor the granting authority can be held responsible for them.

## Appendix A Proofs of Props. 1 and 2

Here we restate and prove the two propositions in Section II.

###### Proposition 1 .

There exists QML models which have BPs under the uniform distribution and are trainable for learning tasks that are classically intractable under standard cryptographic assumptions.

###### Proof.

We prove the statement directly by giving an example.
Consider the DLP kernel $k_{\mathrm{DLP}}(x,x^{\prime})=\operatorname{tr}(\rho(x)\rho(x^{\prime}))$.
Consider the hypothesis family $\mathcal{F}_{k}$ it gives rise to, with training set $\{(x_{i},y_{i})_{i=1}^{N}\}$:

$$ $\displaystyle\mathcal{F}_{k}$ $\displaystyle\coloneqq\left\{\left.f_{\alpha}(x)=\sum_{i=1}^{N}\alpha_{i} \operatorname{tr}\{\rho(x)\rho(x_{i})\}\,\right|\,\alpha\in\mathbb{R}^{N} \right\}.$ (4) $$

To evaluate $f_{\alpha}(x)$, we typically evaluate each overlap $\operatorname{tr}\{\rho(x)\rho(x_{i})\}$ separately and then sum.
We could instead evaluate it all at once with a single circuit instead, using the Linear Combination of Unitaries (LCU) formalism [].
Here, we use LCU to design a circuit whose observable corresponds to a mixed quantum state, which we express as a classical mixture of pure states explicitly.
In this way, we do not take advantage of the interference phenomena that LCU usually allows, but rather use it to create a linear combination of states.

We consider the parametrized observable $\mathcal{M}(\alpha,(x_{i})_{i})=\sum_{i=1}^{N}\alpha_{i}\rho(x_{i})$ and we recognize we can implement it as an LCU circuit.
On the one hand, we prepare the state $\lvert\alpha\rangle=\sum_{i}\alpha_{i}\lvert i\rangle$ on an auxiliary system.
W.l.o.g. the vector $\alpha$ can be taken to be appropriately normalized.
On the other hand, we consider the data-dependent unitary gate $V(x)$ that gives rise to the quantum embedding $\rho(x)=V(x)\lvert 0\rangle\!\langle 0\rvert V^{\dagger}(x)$.
Then, we construct a circuit in which, after $\lvert\alpha\rangle$ has been prepared, we apply $V(x_{i})$ on the work register, controlled on the auxiliary register being in state $\lvert i\rangle$.
We initialize the computer to be on the all $\lvert 0\rangle$ state, then evolve it to become $\lvert\alpha\rangle\otimes V(x)\lvert 0\rangle$, then apply the controlled-$V(x_{i})$ gates, and finally measure the projector onto $\lvert 0\rangle$ on the work register and a diagonal observable that takes care of the signs on the auxiliary register.
The resulting expectation value is, indeed the same as for the kernel method $\operatorname{tr}\{\rho(x)\mathcal{M}(\alpha,(x_{i})_{i})\}=f_{\alpha}(x)$.

In the LCU circuit, some gates are $1$-qubit trainable, and some gates are $2$-qubit fixed, but we have an efficient description of the whole circuit.
Next, rewrite all gates as $2$-qubit arbitrary gates, with a given known parametrization, from which we can recover the LCU circuit explicitly.
The $2$-qubit gates at this step must observe a $1$-dimensional connectivity graph, so each qubit may only be connected to adjacent qubits.
This means that any non-local $2$-qubit gate must be compiled as linearly many local $2$-qubit gates.
Organize all gates in non-commuting layers, and complete any layers with new $2$-local gates, overall resulting in a deep-layered brickwork architecture.
This step includes also the encoding gates required to prepare $\rho(x)$, where a possibly-discrete gate set is compiled with the continuous set of arbitrary local $2$-qubit gates.

We call $\vartheta$ the parameters of the brickwork Ansatz, for which, crucially, we have an efficient specification $(\alpha;(x_{i})_{i})\mapsto\vartheta$ such that we recover the LCU kernel-based parametrized observable.
We choose not to write $\vartheta(\alpha;(x_{i})_{i})$ for ease of notation.
The depth of the circuit is at least linear in the size of the training set, and also at least linear in the required complexity of preparing $\rho(x)$.
The observable we measure at the end is global: it consists of a collection of Pauli-$Z$s and projectors onto the $\lvert 0\rangle$ state on all qubits.
Then, from Ref. [] we know that this quantum circuit has a BP under the uniform distribution over $\vartheta$, as it is an instance of the HEA with linear depth and global observable.
Crucially, this Ansatz has a BP with respect to the circuit parameters $\vartheta$, and not the free parameters of the kernel-based hypothesis family $\alpha$, which is just a subset of the entire function family, and has a very particular parametrization associated to it.
A different question would be what is the distribution over $\vartheta$ induced by the uniform distribution over $\alpha$, and whether that results in a BP, but that is not relevant for this result.

Nevertheless, from Ref. [] we know this model is capable of solving a learning task based on the DLP which is assumed to be hard for any classical learner.
The reduction from this model onto that of [] needs only that we fix the parameters to recover the LCU circuit.
So, the learning algorithm we use takes two steps:

- 1.
Use the $k_{\mathrm{DLP}}$ and a Support Vector Machine (SVM) to reach the optimal $\alpha^{*}$ vector, which we know actually solves the problem as explained in [].
- 2.
Set the parameters $\vartheta$ of the brickwork Ansatz to recover $f_{\alpha^{*}}(x)$ as an LCU circuit.

The solution we are left with $f_{\alpha^{*}}$ satisfies the requirements of the proposition: it is trainable, in the sense that there is a training algorithm with which it solves a task of interest; and it has a BP, in the sense that the cost function concentrates exponentially with respect to the uniform distribution of the circuit parameters.
Crucially, we say the model is trainable because, even though the hypothesis family generated by the brick-layered Ansatz is strictly larger than that generated only by the quantum kernel, the representer theorem guarantees that the solution found by SVM is optimal over all linear models, of which anything generated by the layered Ansatz is a special case.
This completes the proof.

We note the same strategy would not necessarily follow from any arbitrary trainable circuit: in the sense that just compiling a trainable PQC into a deep-layered brickwork Ansatz because the added functions might give rise to a better solution to the learning task.
It could be that by making the hypothesis family larger, what used to be a good-enough solution for the smaller model stops being close to optimal for the larger model.
For this step to still work, we must exploit some guarantee of optimality like the one given by the representer theorem.
∎

###### Proposition 2 (Adapted from [ 42 ] ) .

There exist QML models which are dequantizable but whose circuits are not simulable.

###### Proof.

We prove the statement directly by giving an example.
Consider a sequence of hypothesis families $(\mathcal{F}_{n})_{n}$ and problem distributions $(\mathcal{D}_{n})_{n}$.
Consider a sequence of PQCs $(C_{n})_{n}$ which evaluate BQP-hard functions on $n$ qubits, so which are not simulable.
The learning task is function regression for trigonometric polynomials of degree $n$ on a single variable $x$.
For each $n\in\mathbb{N}$, $\mathcal{F}_{n}$ consists of taking the circuit $C_{n}$ and adding a column of single qubit encoding gates $(R_{Z}(x))^{\otimes n}$ at a location that does not make the circuits easier to evaluate.
This way, the sequence of circuits corresponding to $(\mathcal{F}_{n})_{n}$ are non-simulable by construction.
For the classical learner, we consider the hypothesis function of linear combinations of Fourier monomials of degree up to $n$, of which there are $2n+1$.
The learning algorithm that finds the coefficients given data is based on the Fast Fourier Transform.

Since the Fast Fourier Transform is an empirical risk minimizer, the classical learner is guaranteed to perform at least as good as the quantum learner in terms of the training error, independently of the training algorithm used for the quantum model.
Still, the circuits on which the quantum model is based are not simulable by construction.

It follows that the sequence of quantum models $(\mathcal{F}_{n})_{n}$ is dequantizable for the task of trigonometric regression, yet the corresponding sequence of circuits is not simulable, thus completing the proof.
∎

The goal of the last two results is to reinforce the difference between the notions we introduce in this work and their proxies.
Prop. 1 only points out that trainability and BPs are phenomena of different nature.
And the same applies for Prop. 2 with dequantization and simulation.

###### Proposition 1 .

###### Proof.

###### Proposition 2 (Adapted from [ 42 ] ) .

###### Proof.

## Appendix B Proofs of Theorem 8 and Cor. 9

We first re-state and prove the results from Section IV, and next we briefly discuss their relation to the construction in Appendix B of Ref. [].

###### Theorem 8 .

Let $\mathcal{X}=\{0,1\}^{n}$ and $\mathcal{Y}=\{0,1\}$.
Let $Q(x)$ be a function in $\operatorname{\mathsf{BQP}}$ and not in $\operatorname{\mathsf{HeurBPP/poly}}$ under a given distribution $\mathcal{P}(x)$, and let $U(x)$ be a unitary such that $\langle 0\rvert U^{\dagger}(x)Z_{1}U(x)\lvert 0\rangle=Q(x)$.
Let $\mathcal{H}$ be a Hamiltonian, and $W(\vartheta)$ a parametrized unitary for which the following optimization problem can be solved with a given gradient-based algorithm $\mathcal{A}_{W}$:

$$ $\displaystyle\vartheta^{*}\leftarrow\arg\max_{\vartheta\in\Theta}\langle 0 \rvert W^{\dagger}(\vartheta)HW(\vartheta)\lvert 0\rangle,$ (5) $$

and such that $\max_{\vartheta\in\Theta}\langle 0\rvert W^{\dagger}(\vartheta)HW(\vartheta)
\lvert 0\rangle=1$.
Call $V(x;\vartheta)=U(x)\otimes W(\vartheta)$, and $\mathcal{M}=Z_{1}\otimes H$, and consider the corresponding hypothesis class $\mathcal{F}_{Q}$:

$$ $\displaystyle\mathcal{F}_{Q}\coloneqq\{f_{\vartheta}(x)=\langle 0\rvert V^{ \dagger}(x;\vartheta)\mathcal{M}V(x;\vartheta)\lvert 0\rangle\,|\,\vartheta\in \Theta\}.$ (6) $$

Let $\mathcal{D}_{\mathcal{P}}$ specify a learning task: $P(x,y)=\mathcal{P}(x)\delta(y=Q(x))$.

Then $\mathcal{F}_{Q}$ is gradient-based trainable for $\mathcal{D}_{\mathcal{P}}$, and it is not dequantizable.

###### Proof.

As explained in Ref. [], for $Q:\{0,\ldots,2^{n}-1\}\to\{0,1\}$ to not be in $\operatorname{\mathsf{HeurBPP/poly}}$, $Q$ must be hard to evaluate and learn classically from examples.
That means, that given polynomially many input-out pairs, no classical algorithm can evaluate it classically with probability larger than $1/2+1/\operatorname{poly}(n)$ over $x\sim\mathcal{P}(x)$.
This could be for example the most significant digit of the discrete logarithm of $x$ according to a known basis.
Based on $Q(x)$, we can consider a binary classification task in which each integer $x$ is assigned a class $y(x)\in\{\pm 1\}$ depending on $Q(x)$, by identifying the outcome measurement 0 0 with class $-1$.

In parallel, we have the optimization task of finding the highest energy of $H$ by optimizing the parameters of $V(\vartheta)$, which is assumed to be efficiently solvable.

Then as a supervised learning task, we consider a training set $S=\{(x_{i},y_{i})\}_{i=1}^{N}$, where $x_{i}\sim\mathcal{P}(x)$ and $y_{i}=1$ if $Q(x)=1$, $y_{i}=-1$ if $Q(x)=0$.
The hypothesis class $\mathcal{F}_{Q}$ we consider is

$$ $\displaystyle\mathcal{F}_{Q}\coloneqq\{f_{\vartheta}(x)=\langle 0\rvert V^{ \dagger}(x;\vartheta)\mathcal{M}V(x;\vartheta)\lvert 0\rangle\,|\,\vartheta\in\Theta\}$ (7) $$

We consider the problem solved when we find a hypothesis specified by parameters $\vartheta_{\text{sol}}$ for which it holds that

$$ $\displaystyle f(x;\vartheta_{\text{sol}})=y(x)$ (8) $$

with high probability over $x\sim\mathcal{P}(x)$.
Using the training set we have access to, and using the mean squared error, we are left with the following optimization problem:

$$ $\displaystyle\vartheta_{\text{sol}}$ $\displaystyle=\arg\min_{\vartheta}\{\frac{1}{2N}\sum_{i=1}^{N}\lVert f(x_{i}; \vartheta)-y_{i}\rVert^{2}\}$ (9) $\displaystyle=\arg\min_{\vartheta}\{\frac{1}{2N}\sum_{i=1}^{N}\lVert\langle 0 \rvert V^{\dagger}(x_{i};\vartheta)\mathcal{M}V(x_{i};\vartheta)\lvert 0 \rangle-y_{i}\rVert^{2}\}$ (10) $\displaystyle=\arg\min_{\vartheta}\{\frac{1}{2N}\sum_{i=1}^{N}\lVert\langle 0 \rvert(U(x_{i})\otimes W(\vartheta))^{\dagger}(Z_{1}\otimes H)(U(x_{i})\otimes W (\vartheta))\lvert 0\rangle-y_{i}\rVert^{2}\}$ (11) $\displaystyle=\arg\min_{\vartheta}\{\frac{1}{2N}\sum_{i=1}^{N}\lVert\langle 0 \rvert U(x_{i})^{\dagger}Z_{1}U(x_{i})\lvert 0\rangle\langle 0\rvert W( \vartheta)^{\dagger}HW(\vartheta)\lvert 0\rangle-y_{i}\rVert^{2}\}$ (12) $\displaystyle=\arg\min_{\vartheta}\{\frac{1}{2N}\sum_{i=1}^{N}\lVert y_{i} \langle 0\rvert W(\vartheta)^{\dagger}HW(\vartheta)\lvert 0\rangle-y_{i}\rVert ^{2}\}$ (13) $\displaystyle=\arg\min_{\vartheta}\{\frac{1}{2N}\sum_{i=1}^{N}\lVert y_{i}( \langle 0\rvert W(\vartheta)^{\dagger}HW(\vartheta)\lvert 0\rangle-1)\rVert^{2}\}$ (14) $\displaystyle=\arg\min_{\vartheta}\{(\langle 0\rvert W(\vartheta)^{\dagger}HW( \vartheta)\lvert 0\rangle-1)^{2}\}$ (15) $\displaystyle=\arg\max_{\vartheta}\{\langle 0\rvert W(\vartheta)^{\dagger}HW( \vartheta)\lvert 0\rangle\}$ (16) $\displaystyle=\vartheta^{*}.$ (17) $$

We see that the solution of our classification problem $\vartheta_{\text{sol}}$ is the same as the solution $\vartheta^{*}$ of the optimization problem based only on $H$ and $W(\vartheta)$, which can be solved by the given training algorithm $\mathcal{A}_{W}$ by assumption.
Because we assumed the optimization problem to be efficiently solvable by gradient-based optimization, it follows that our binary classification problem is also efficiently solvable by gradient-based optimization.
Here, similarly to Prop. 1, we took a trainable model and added more ingredients to it to make it look difficult.
But, in the end, training our model to fit data according to the function $Q$ is as easy as training the simple quantum state optimization task, so the model we proposed is gradient-based trainable.
Still, the same task cannot be solved by a classical model because that would imply a classical algorithm being able to evaluate $Q(x)$, which we ruled out by assumption.
∎

###### Corollary 9 .

There exist vari veryational QML models which are gradient-based trainable and non-dequantizable with any number of layers up to sub-exponentially many in the number of qubits.

###### Proof.

We prove this statement by giving an explicit example of a vari veryational model that fulfills the assumptions of Theorem 8.
The model corresponds to a tensor product of two PQCs, one corresponding to the hard computational task of evaluating $Q(x)$, and one corresponding to the easy optimization task corresponding to $H$ and $W(\vartheta)$.

We start with the computational part, where we have the unitary $U(x)$ which implements the classically-hard function $Q(x)$.
From $U(x)$, we must construct a layered circuit where all layers are equal, and which still produces $Q(x)$ when Pauli $Z$ is measured on the first qubit, at the end.
To achieve this, consider an auxiliary register made of $t\in\mathbb{N}$ qubits and consider an integer-adder $t$-qubit unitary gate $A$ whose action on the computational basis is to add $1$ modulo $2^{t}$: $A\lvert b\rangle=\lvert b+1\bmod{2^{t}}\rangle$.
Then, we define the $(n+t)$-qubit unitary $\tilde{U}(x)$ as a sequential two-step process:

- 1.
Implement $U(x)$ on the first $n$ qubits conditioned on the extra $t$ qubits being in state $\lvert 0\rangle$.
- 2.
Apply $A$ on the $t$ working qubits.

With this, the action of $\tilde{U}(x)$ on the $(n+t)$ qubits is:

$$ $\displaystyle\tilde{U}(x)\lvert 0\rangle\lvert b\rangle$ $\displaystyle=\left(U(x)^{\delta_{b,0}}\lvert 0\rangle\right)\lvert b+1\mod{2^ {t}}\rangle.$ (18) $$

Here $\delta_{a,b}$ is the Kronecker delta, which equals $1$ if $a=b$, and is 0 0 otherwise.
In particular, for the first $n$ qubits, $\tilde{U}(x)$ applies $U(x)$ if $b=0$, and does nothing in any other case.
Also, it follows that $\tilde{U}(x)^{L}\lvert 0\rangle\lvert 0\rangle=(U(x)^{\lceil L/(2^{t})\rceil}
\lvert 0\rangle)\lvert L\mod 2^{t}\rangle$.
And, in particular, $\tilde{U}(x)^{L}\lvert 0\rangle\lvert 0\rangle=(U(x)\lvert 0\rangle)\lvert L\rangle$ for any $L<2^{t}$.
That means, when using $\lvert 0\rangle$ as the input state for both registers, applying $\tilde{U}(x)$ $L$ times in sequence has the same effect on the first $n$ qubits as only applying it once, given than $L$ is not exponential in $t$.
So, provided the number of layers is subexponential $L<2^{t}$, it holds that

$$ $\displaystyle\langle 0|\!\langle 0|(\tilde{U}^{L}(x))^{\dagger}(Z_{1}\otimes \mathbb{I})\tilde{U}^{L}(x)\lvert 0\rangle\!\lvert 0\rangle$ $\displaystyle=\langle 0|\!\langle 0|\tilde{U}(x)^{\dagger}(Z_{1}\otimes\mathbb {I})\tilde{U}(x)\lvert 0\rangle\!\lvert 0\rangle$ (19) $\displaystyle=\langle 0\rvert U(x)^{\dagger}Z_{1}U(x)\lvert 0\rangle$ (20) $\displaystyle=Q(x).$ (21) $$

For the easy optimization task, we could take any PQC-Hamiltonian combination that we know to be trainable and deep-layered.
For this proof, it is enough to pick a very simple one.
We can take the single-qubit observable $H=Z$, and the layered Ansatz $W(\vartheta)=\prod_{j=1}^{L}R_{X}(\vartheta_{j})$.
With these, it follows that initializing $\vartheta$ uniformly at random and then performing gradient descent is enough to solve the optimization task.
Since the highest-energy state of $Z$ is already the initial state $\lvert 0\angle$, this optimization problem reduces to finding a specification of $\theta$ fulfilling $\sum_{j=1}^{L}\theta_{j}=2\pi M$, for any $M\in\mathbb{Z}$, since $R_{X}$ forms a $U(1)$ group and $R_{X}(2\pi M)=\mathbb{I}$ up to a global phase for any $M\in\mathbb{Z}$.
This optimization problem is easy regardless of $L$, so in particular it also works for $L<2^{t}$.

All together, the PQC we are considering consists of $L$ layers uniformly repeated:

$$ $\displaystyle\mathcal{F}_{Q}$ $\displaystyle\coloneqq\{f_{\vartheta}(x)=\langle 0\rvert V^{\dagger}(x; \vartheta)\mathcal{M}V(x;\vartheta)\lvert 0\rangle\,|\,\vartheta\in\Theta\}$ (22) $\displaystyle V(x;\vartheta)$ $\displaystyle=\prod_{i=1}^{L}\tilde{U}(x)\otimes R_{X}(\vartheta_{i}).$ (23) $$

We have seen that this PQC fulfills the assumptions of Theorem 8 and it also fulfills the defining requirements for a QML model to be vari veryational from Section III.
This completes the proof.
∎

Both this construction and that of Ref. [] leverage a hard computational task to make a statement about trainability and dequantization.
In both cases there is an encoding unitary which, upon measuring Pauli Z on the first qubit, evaluates a specific function of bitstrings to a single bit.
The quantum function is chosen to ensure that no classical algorithm can evaluate it, even when given advice.

The main difference is two-fold.
On the one hand, we pose a learning problem and a model that can solve it, and not just a computational problem.
At the same time we also propose a learning algorithm that ensures that the quantum algorithm actually solves the task.
On the other hand, we force ourselves to work with so-defined vari veryational models, which rely on deep-layered variational circuits, as opposed to the circuit constructed in Ref. [].
That being said, a valid criticism of our construction is that the way in which we turn a computational task into a learning task is almost trivial.
The trainable component of our circuit is detached from the encoding part, and it only appears as a multiplication factor independent of the input.
Indeed, our proof does not educate us on how to design PQCs for QML, but rather it is the minimal construction necessary to prove the statement.

###### Theorem 8 .

###### Proof.

###### Corollary 9 .

###### Proof.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 5
presentation: 3
questions: - What does "gradient-based trainable" mean precisely? Does it mean there is no barren plateau in the sense of Definition 2?
- On page 2, the risk functional is defined over the space $\mathcal{Y}^\mathcal{X}$. Can you explain this notation, specifically, why the data domain $\mathcal{X}$ appears as the power in the label co-domain $\mathcal{Y}$, but not vice versa?
- I am a bit uncertain about the name "vari veryational". Is there further justification for this name, besides it's a spoonerism of "very variational"? It feels a bit uninformative to the general quantum information audience.
soundness: 3
strengths: - The paper proposes clear definitions for trainability and dequantization using a rigorous learning theory language. This clarifies the vagueness of many seemingly related but not equivalent concepts in quantum learning theory.
- This paper constructed a QML model that is gradient-based trainable but not dequantizable (based on standard cryptographic assumptions).
- This paper provides an extended discussion of several related results in the quantum learning theory (Figure 3).
summary: This paper discusses and clarifies several important concepts in quantum machine learning (QML), including trainability, simulatability, and de-quantization. Building upon the established concepts, this paper introduces a new family of "vari veryational" QML models, a spoonerism of "very variational", that capture the essence of deep-layered QML models and gradient-based training algorithms. It is shown that in this family of QML models, there exist non-dequantizable but trainable models. This resolves an open question that trainability and dequantization are mutually compatible.
weaknesses: - The QML model constructed in this paper seems a bit contrived. The construction is based on a computationally hard problem, and the proposed training method is quite specific and not able to generalize to other QML designs. I feel this construction is mostly of theoretical interest and has limited connection to practically relevant variational quantum algorithms.
- Several definitions in Section 2 are quite formal and math-heavy, and it’s unclear whether such definitions are truly necessary in light of the paper’s main technical contributions. I feel the theoretical framework may be somewhat excessive relative to the provable results.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: - It would enhance the paper if the authors could offer insights or preliminary guidelines on designing QML models that are trainable, non-dequantizable, and very variational.
soundness: 2
strengths: - The paper commendably formalizes the concept of dequantization, linking several key concepts in QML models, including trainability, dequantization, and classical simulation. This integration provides a valuable framework for understanding QML models.

- The paper is well written and concepts are explained clearly.
summary: This paper tries to establish a relationship between trainability and dequantization in the context of QML models. The authors present a formalization of these concepts and attempt to illustrate conditions under which these properties co-exist.
weaknesses: - From a technical standpoint, the paper's contribution appears limited, primarily synthesizing existing results rather than offering new findings. It attempts to establish connections between different unclear concepts but lacks significant technical contributions.

- The discussion would benefit from a more detailed analysis of existing QML models to determine which categories they fall into. Such a comparison would enhance the paper's relevance and applicability in the field.

- On the practical side, the paper falls short of providing actionable insights or guidelines for designing effective QML models, which limits its utility for practitioners in the field.

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: - If “de-” is the prefix for the reverse of something, can non-dequantizable just be “quantizable”?
soundness: 3
strengths: - Figures 1 and 3 are good, and help with reader comprehension
- The paper is generally well written and understandable
- The writing style especially is very approachable and the focus on explanation is beneficial to the paper
- The coverage of recent literature is sufficient
summary: This paper formalizes the relationship between differing ideas in the QML literature regarding different aspects of learning QML models. With these formalizations in hand, the authors then prove that there exist variational QML models which are trainable and non-dequantizable.
weaknesses: - This paper seems to want to do two things. After introducing a new representational/formal scheme for QML, it wants to (a) show how other papers fit into this scheme and (b) use this scheme to prove novel results. However, in attempting to do both, results in both being weaker. If the paper were to lean into (a) and be more of a review paper (where the formalize in the synthesis of many previous papers) and give more examples of how the literature fits into this paradigm, it would be good. Or, if the paper were to lean into (b) and emphasize more the research power of this paradigm through novel theoretical contributions, that would also be good. To be concrete for this latter approach, this would largely involve moving 3.3/3.4 to an appendix.
- Figure 2 and Table 1 seem to convey the same information redudantly
- This paper is generally interesting and is a quality paper, but I question whether ICLR is the ideal venue for it and whether there is sufficient novelty of interest to this community
- Not a major point, but the “vari veryational” term doesn’t seem ideal, both for speaking (sorry for the phonocentrism Derrida), but also for writing (with autocorrect/spell check). Maybe a different abbreviation would clarify better?

---

confidence: 5
contribution: 3
initial_rating: 6
presentation: 4
questions: What implications do the authors' results have on the construction of quantum neural network architectures?
soundness: 4
strengths: The authors prove concrete, rigorous results, which are hard to come by in the field of quantum machine learning; this is particularly true of concrete quantum-classical separations in machine learning (where the quantum model is assumed to be efficiently trainable). The authors give explicit examples of efficiently trainable quantum networks with provable quantum advantages in learning over their classical counterparts.
summary: The authors address a pressing question in the field of quantum machine learning: do there exist "variational" (i.e., trained via gradient descent) quantum neural networks which are both efficient to train and also difficult to classically simulate? The authors answer this question in the affirmative, giving a general method for constructing variational quantum machine learning models with these two properties.
weaknesses: The authors' Theorem 3 and Corollary 4---which give the recipe for constructing a learning problem solved by a quantum model efficiently trainable via gradient descent, but which is unable to be dequantized---essentially separates these two conditions out, considering a tensor product of two systems where one is trivial and easy to optimize and the other implements a quantumly-easy, classically-hard function, but is untrained. Because of this, it is difficult to know what broader impact this work has on the actual design of variational quantum algorithms (see Questions).

A minor additional weakness is that the authors' proposed criteria for "dequantizable" focuses on the supervised learning setting; the unsupervised learning setting (e.g., sampling problems) may also contain concrete quantum advantages in an efficiently trainable setting, particularly with the current wealth of quantum experiments demonstrating a quantum advantage in sampling tasks (Nature 574, 505; Nature 626, 58).

Meta-review: This paper investigates the compatibility of trainability and non-dequantizability in variational quantum machine learning (QML) models. The authors introduce the concept of "vari veryational" models, providing a theoretical framework and constructions that meet these two criteria. While reviewers raised concerns about the limited practical implications of the constructions, the focus on supervised learning, and the somewhat contrived nature of the proposed models, the work offers valuable insights into the design of variational QML models and advances understanding in the field.

Decision: Accept (Poster)