I S A G OOD R EPRESENTATION S UFFICIENT FOR S AMPLE E FFICIENT R EINFORCEMENT L EARNING ?
A BSTRACT
Modern deep learning methods provide effective means to learn good representations.
However, is a good representation itself sufﬁcient for sample efﬁcient reinforcement learning?
This question has largely been studied only with respect to (worst-case) approximation error, in the more classical approximate dynamic programming literature.
With regards to the statistical viewpoint, this question is largely unexplored, and the extant body of literature mainly focuses on conditions which permit sample efﬁcient reinforcement learning with little understanding of what are necessary conditions for efﬁcient reinforcement learning.
This work shows that, from the statistical viewpoint, the situation is far subtler than suggested by the more traditional approximation viewpoint, where the requirements on the representation that sufﬁce for sample efﬁcient RL are even more stringent. Our main results provide sharp thresholds for reinforcement learning methods, showing that there are hard limitations on what constitutes good function approximation (in terms of the dimensionality of the representation), where we focus on natural representational conditions relevant to value-based, model-based, and policy-based learning.
These lower bounds highlight that having a good (valuebased, model-based, or policy-based) representation in and of itself is insufﬁcient for efﬁcient reinforcement learning, unless the quality of this approximation passes certain hard thresholds.
Furthermore, our lower bounds also imply exponential separations on the sample complexity between 1) value-based learning with perfect representation and value-based learning with a good-but-not-perfect representation, 2) value-based learning and policy-based learning, 3) policy-based learning and supervised learning and 4) reinforcement learning and imitation learning.
I NTRODUCTION
Modern reinforcement learning (RL) problems are often challenging due to the huge state space.
To tackle this challenge, function approximation schemes are often employed to provide a compact representation, so that reinforcement learning can generalize across states.
A common paradigm is to ﬁrst use a feature extractor to transform the raw input to features (a succinct representation) and then apply a linear predictor on top of the features.
Traditionally, the feature extractor is often handcrafted (Sutton & Barto, 2018), while more modern methods often train a deep neural network to extract features.
The hope of this paradigm is that, if there exists a good low dimensional (linear) representation, then efﬁcient reinforcement learning is possible.
Empirically, combining various RL function approximation algorithms with neural networks for feature extraction has lead to tremendous successes on various tasks (Mnih et al., 2015; Schulman et al., 2015; 2017).
A major problem, however, is that these methods often require a large amount of samples to learn a good policy.
For example, deep Q -network requires millions of samples to solve certain Atari games (Mnih et al., 2015).
Here, one may wonder if there are fundamental statistical limitations on such methods, and, if so, under what conditions it would be possible to efﬁciently learn a good policy?
In the supervised learning context, it is well-known that empirical risk minimization is a statistically efﬁcient method when using a low-complexity hypothesis space (Shalev-Shwartz & Ben-David, 2014), e.g. a hypothesis space with bounded VC dimension.
For example, polynomial number of samples sufﬁce for learning a near-optimal d -dimensional linear classiﬁer, even in the agnostic setting 1 .
In contrast, in the more challenging RL setting, we seek to understand if efﬁcient learning is possible (say from a sample complexity perspective) when we have access to an accurate (and compact) parametric representation — e.g. our policy class contains a near-optimal policy or our hypothesis class accurately approximates the optimal value function.
In particular, this work focuses on the following question:
Is a good representation sufﬁcient for sample-efﬁcient reinforcement learning?
This question has largely been studied only with respect to approximation error in the more classical approximate dynamic programming literature, where it is known that algorithms are stable to certain worst-case approximation errors.
With regards to sample efﬁciency, this question is largely unexplored, where the extant body of literature mainly focuses on conditions which are sufﬁcient for efﬁcient reinforcement learning though there is little understanding of what are necessary conditions for efﬁcient reinforcement learning.
In reinforcement learning, there is no direct analogue of empirical risk minimization as in the supervised learning context, and it is not evident what are the statistical limits of learning based on properties of our underlying hypothesis class (which may be value-based, policy-based, or model-based).
Many recent works have provided polynomial upper bounds under various sufﬁcient conditions, and in what follows we list a few examples.
For value-based learning, the work of Wen & Van Roy (2013) showed that for deterministic systems 2 , if the optimal Q -function can be perfectly predicted by linear functions of the given features, then the agent can learn the optimal policy exactly with polynomial number of samples.
Recent work (Jiang et al., 2017) further showed that if certain complexity measure called Bellman rank is bounded, then the agent can learn a near-optimal policy efﬁciently.
For policy-based learning, Agarwal et al.
(2019) gave polynomial upper bounds which depend on a parameter that measures the difference between the initial distribution and the distribution induced by the optimal policy.
Our Contributions.
This paper gives, perhaps surprisingly, strong negative results to this question.
The main results are exponential lower bounds in terms of planning horizon H for value-based, modelbased, and policy-based algorithms with given good representations 3 .
Notably, the requirements on the representation that sufﬁce for sample efﬁcient RL are even more stringent than the more traditional approximation viewpoint.
A comprehensive summary of previous upper bounds and our lower bounds is given in Table and here we brieﬂy summarize our hardness results.
For value-based learning, we show even if Q -functions of all policies can be approximated by linear functions of the given representation with approximation error
δ = Ω (cid:16)(cid:113) Hd (cid:17) where d is the dimension of the representation and H is the planning horizon, then the agent still needs to sample exponential number of trajectories to ﬁnd a near-optimal policy.
For model-based learning, we show even if the transition matrix and the reward function can be approximated by linear functions of the given representation with approximation error
δ = Ω (cid:16)(cid:113) Hd (cid:17) (in (cid:96) ∞ sense), the agent still needs to sample exponential number of trajectories to ﬁnd a near-optimal policy.
We show even if optimal policy can be perfectly predicted by a linear function of the given representation with a strictly positive margin, the agent still requires exponential number of trajectories to ﬁnd a near-optimal policy. Our simplicity.
These lower bounds hold even in deterministic systems and even if the agent knows the transition model.
Note these negative results apply to the case where the Q -function, the model, or the optimal policy can be predicted well by a linear function of the given representation.
Since the class of linear functions is a strict subset of many more complicated function classes, including neural networks in particular, our negative results imply lower bounds for these more complex function classes as well.
Our results highlight the following conceptual insights:
• The requirements on the representation that sufﬁce for sample efﬁcient RL are signiﬁcantly more stringent than the more traditional approximation viewpoint; our statistical lower bounds show that there are hard thresholds on the worst-case approximation quality of the representation which are not necessary from the approximation viewpoint.
• Since our lower bounds apply even when the agent knows the transition model, the hardness is not due to the difﬁculty of exploration in the standard sense.
The unknown reward function is sufﬁcient to make the problem exponentially difﬁcult.
• Our lower bounds are not due to the agent’s inability to perform efﬁcient supervised learning, since our assumptions do admit polynomial sample complexity upper bounds if the data distribution is ﬁxed.
• Our lower bounds are not pathological in nature and suggest that these concerns may arise in practice.
In a precise sense, almost all feature extractors induce a hard MDP instance in our construction (see Section 4.4).
Instead, one interpretation is that the hardness is due to a distribution mismatch in the following sense: the agent does not know which distribution to use for minimizing a (supervised) learning error (see
Kakade (2003) for discussion), and even a known transition model is not information-theoretically sufﬁcient to reduce the sample complexity.
Furthermore, our work implies several interesting exponential separations on the sample complexity between: 1) value-based learning with perfect representation and value-based learning with a goodbut-not-perfect representation, 2) value-based learning and policy-based learning, 3) policy-based learning and supervised learning and 4) reinforcement learning and imitation learning.
We provide more details in Section 5.
R ELATED W ORK
A summary of previous upper bounds, together with lower bounds proved in this paper, is provided in Table 1.
Some key assumptions are formally stated in Section 3 and Section 4.
Our lower bounds highlight that classical complexity measures in supervised learning including small approximation error and margin, and standard assumptions in reinforcement learning including optimality gap and deterministic systems, are not enough for efﬁcient RL with function approximation.
We need additional assumptions, e.g., ones used in previous upper bounds, for efﬁcient RL.
2. P REVIOUS L OWER B OUNDS
Existing exponential lower bounds, to our knowledge, construct unstructured MDPs with an exponentially large state space and reduce a bandit problem with exponentially many arms to an
MDP (Krishnamurthy et al., 2016; Sun et al., 2017).
However, these lower bounds cannot apply to
MDPs whose transition models, value functions, or policies can be approximated with some natural function classes, e.g., linear functions, neural networks, etc.
The current paper gives the ﬁrst set of lower bounds for RL with linear function approximation (and thus also hold for super classes of linear functions such as neural networks).
2. P REVIOUS U PPER B OUNDS
We divide previous algorithms (with provable guarantees) into three classes: those that utilize uncertainty-based bonuses (e.g. UCB variants or Thompson sampling variants); approximate dynamic programming variants (which often make assumptions with respect to concentrability coefﬁcients); and direct policy search-based methods (such as conserve policy iteration (CPI, see Kakade (2003)) or policy gradient methods, which make assumptions with respect to distribution mismatch coefﬁcients). [Table] See Section 2 for discussion on this table. RL , Generative Model , Known Transition are deﬁned in Section 3.3.
Exact linear Q
Assumption 4.1 with δ = 0 . Approx linear Q δ = Ω (cid:16)(cid:113) Hd all π : Assumption 4.2 with δ = 0 . Approximate Linear Q π for all π : Assumption 4.2 with δ = Ω (cid:16)(cid:113) H d (cid:17) .
DetMDP: deterministic system deﬁned in Section 3.1.
Bellman-rank: Deﬁnition 5 in
Jiang et al.
Low Var: Assumption 1 in Du et al. (2019b).
Gap: Assumption 3.1.
Bounded
Distribution Mismatch Coefﬁcient: Deﬁnition 3.3 in Agarwal et al.
(cid:96) ∞
Approx Linear
MDP: Assumption 4.3 with δ = Ω (cid:16)(cid:113)
Hd (cid:17) .
(cid:88) : there exists an algorithm with polynomial sample complexity to ﬁnd a near-optimal policy.
(cid:88) × : requires certain condition on the initial distribution.
× : exponential number of samples is required. ?:
open problem.
The ﬁrst class of methods include those based on witness rank, Belman rank, and the Eluder dimension, while the latter two classes of algorithms make assumptions either on concentrability coefﬁcients or on distribution mismatch coefﬁcients (see Agarwal et al.
; Scherrer (2014) for discussions).
Uncertainty bonus-based algorithms.
Now we discuss existing theoretical results on value-based learning with function approximation.
The most relevant work is Wen & Van Roy (2013) which showed in deterministic systems, if the optimal Q -function is within a pre-speciﬁed function class which has bounded Eluder dimension, for which the class of linear functions is a special case, then the agent can learn the optimal policy using polynomial number of samples.
This result has recently been generalized by Du et al.
(2019a) which can deal with stochastic reward and low variance transition but requires strictly positive optimality gap.
As we listed in Table 1, it is an open problem whether the condition that the optimal Q -function is linear itself is sufﬁcient for efﬁcient RL.
Li et al.
(2011) proposed a Q -learning algorithm which requires the Know-What-It-Knows oracle.
However, it is in general unknown
how to implement such oracle in practice.
Jiang et al.
(2017) proposed the concept of Bellman Rank to characterize the sample complexity of value-based learning methods and gave an algorithm that has polynomial sample complexity in terms of the Bellman Rank, though the proposed algorithm is not computationally efﬁcient.
Bellman rank is bounded for a wide range of problems, including MDP with small number of hidden states, linear MDP, LQR, etc.
Later work gave computationally efﬁcient algorithms for certain special cases (Dann et al., 2018; Du et al., 2019a; Yang & Wang, 2019b; Jin et al., 2019).
Recently, Witness rank, a generalization of Bellman rank to model-based methods, is studied in Sun et al.
Approximate dynamic programming-based algorithms.
We now discuss approximate dynamic programming-based results characterized in terms of the concentrability coefﬁcient.
While classical approximate dynamic programming results typically require (cid:96) ∞ -bounded errors, the notion of concentrability (originally due to (Munos, 2005)) permits sharper bounds in terms of average-case function approximation error, provided that the concentrability coefﬁcient is bounded (e.g. see
Munos (2005); Szepesv ´ ari & Munos (2005); Antos et al.
Geist et al.
Under the assumption that this problem-dependent parameter is bounded, Munos (2005) ; Szepesv ´ ari & Munos (2005) and Antos et al.
(2008) proved sample complexity and error bounds for approximate dynamic programming methods when there is a data collection policy (under which value-function ﬁtting occurs) that induces a ﬁnite concentrability coefﬁcient.
The assumption that the concentrability coefﬁcient is ﬁnite is in fact quite limiting.
See Chen & Jiang (2019) which provides a more detailed discussion on this quantity.
Direct policy search-based algorithms
Stronger guarantees over approximate dynamic programming-based algrithm can be obtained with direct policy search-based methods, where instead of having a bounded concentrability coefﬁcient, one only needs to have a bounded distribution mismatch coefﬁcient .
The latter assumption requires the agent to have access to a “good” initial state distribution (e.g. a measure which has coverage over where an optimal policy tends to visit); note that this assumption does not make restrictions over the class of MDPs.
There are two classes of algorithms that fall into this category.
First, there is Conservative Policy Iteration (Kakade & Langford, 2002), along with Policy Search by Dynamic Programming (PSDP)
(Bagnell et al., 2004), and other boosting-style of policy search-based methods Scherrer & Geist (2014); Scherrer (2014), which have guarantees in terms of bounded distribution mismatch ratio.
Second, more recently, Agarwal et al.
(2019) showed that policy gradient styles of algorithms also have comparable guarantees.
Recent extensions.
Subsequent to this work, the work by Van Roy & Dong (2019) and Lattimore &
Szepesvari (2019) made notable contributions to the misspeciﬁed linear bandit problem.
In particular, both papers found that Theorem 4.1 in our paper can be extended to the misspeciﬁed linear bandit problem and gave upper bounds for this problem showing that our lower bound has tight dependency on δ and d .
Lattimore & Szepesvari (2019) further gave an upper bound for the setting where the Q -functions of all policies can be approximated by linear functions with small approximation errors and the agent can interact with the environment using a generative model. This upper bound also demonstrates that our lower bound has tight dependency on δ and d .  P RELIMINARIES
Throughout this paper, for a given integer H , we use [ H ] to denote the set { 0 , 1 , . . .
, H − 1 } .
3. E PISODIC R EINFORCEMENT L EARNING
Let M =
( S , A , H, P, R ) be an Markov Decision Process (MDP) where S is the state space,
A is the action space whose size is bounded by a constant
, H ∈ Z + is the planning horizon,
P : S ×A → (cid:52) ( S ) is the transition function which takes a state-action pair and returns a distribution over states and R : S ×
A → (cid:52) ( R ) is the reward distribution.
Without loss of generality, we assume a ﬁxed initial state s 0 4 .
A policy π : S → (cid:52) ( A ) prescribes a distribution over actions for each state.
The policy π induces a (random) trajectory s 0 , a 0 , r 0 , s 1 , a 1 , r 1 , . . .
, s H − 1 , a H − 1 , r H − 1 where a 0 ∼ π ( s 0 ) , r 0 ∼ R ( s 0 , a 0 ) , s 1 ∼ P ( s 0 , a 0 ) , a 1 ∼ π ( s 1 ) , etc.
To streamline our analysis, for each h ∈ [ H ] , we use S h ⊆ S to denote the set of states at level h , and we assume S h do not intersect with each other.
We also assume (cid:80)
H − 1 h =0 r h ∈ [0 , 1] almost surely.
Our goal is to ﬁnd a policy π that maximizes the expected total reward E (cid:104)(cid:80) H − 1 h =
r h | π (cid:105) .
We use π ∗ to denote the optimal policy.
We say a policy π is ε -optimal if E (cid:104)(cid:80)
H − 1 h =
r h | π (cid:105) ≥ E (cid:104)(cid:80)
H − 1 h =
r h | π ∗ (cid:105) − ε .
In this paper we prove lower bounds for deterministic systems, i.e., MDPs with deterministic transition P , deterministic reward R .
In this setting, P and R can be regarded as functions instead of distributions.
Since deterministic systems are special cases of general stochastic MDPs, lower bounds proved in this paper still hold for more general MDPs.
3. Q - FUNCTION AND O PTIMALITY G AP
An important concept in RL is the Q -function.
Given a policy π , a level h ∈ [ H ] and a state-action pair ( s, a ) ∈ S h × A , the Q -function is deﬁned as Q πh ( s, a ) =
E (cid:104)(cid:80) H − 1 h (cid:48)
=
h r h (cid:48) | s h
= s, a h
= a, π (cid:105) .
For simplicity, we denote Q ∗ h ( s, a ) =
Q π ∗ h ( s, a ) .
In addition to these deﬁnitions, we list below an important assumption, the optimality gap assumption, which is widely used in reinforcement learning and bandit literature.
To state the assumption, we ﬁrst deﬁne the function gap : S ×
A → R as gap( s, a ) =
arg max a (cid:48) ∈A Q ∗ ( s, a (cid:48) )
− Q ∗ ( s, a ) .
Now we formally state the assumption.
Assumption 3.1 (Optimality Gap) .
There exists ρ > 0 such that ρ ≤ gap( s, a ) for all ( s, a ) ∈ S ×A with gap( s, a ) > 0 .
Here, ρ is the smallest reward-to-go difference between the best set of actions and the rest.
Recently,
Du et al. (2019b) gave a provably efﬁcient Q -learning algorithm based on this assumption and
Simchowitz & Jamieson (2019) showed that with this condition, the agent only incurs logarithmic regret in the tabular setting.
3. Q UERY M ODELS
Here we discuss three possible query oracles interacting with the MDP.
• RL : The most basic and weakest query oracle for MDP is the standard reinforcement learning query oracle where the agent can only interact with the MDP by choosing actions and observe the next state and the reward.
• Generative Model : A stronger query model assumes the agent can transit to any state (Kearns & Singh, Kakade, ; Sidford et al.,
This query model is available in certain robotic applications where one can control the robot to reach the target state.
• Known Transition :
The strongest query model considered is that the agent can not only transit to any state, but also knows the whole transition function.
In this model, only the reward is unknown.
In this paper, we will prove lower bounds for the strongest Known Transition query oracle.
Therefore, our lower bounds also apply to RL and Generative Model query oracles.
M AIN R ESULTS
In this section we formally present our lower bounds.
We also discuss proof ideas in Section 4.4.
4. L OWER B OUND FOR V ALUE - BASED L EARNING
We ﬁrst present our lower bound for value-based learning.
A common assumption is that the Qfunction can be predicted well by a linear function of the given features (representation) (Bertsekas & Tsitsiklis, 1996).
Formally, the agent is given a feature extractor φ : S ×
A → R d which can be hand-crafted or a pre-trained neural network that transforms a state-action pair to a d -dimensional embedding.
The following assumption states that the given feature extractor can be used to predict the Q -function with approximation error at most δ using a linear function.
Assumption 4.1.
There exists δ > 0 and θ 0 , θ 1 , . . .
, θ H − 1 ∈ R d such that for any h ∈ [ H ] and any ( s, a ) ∈ S h × A , | Q ∗ h ( s, a ) − (cid:104) θ h , φ ( s, a ) (cid:105)| ≤ δ.
Here δ is the approximation error, which indicates the quality of the representation.
If δ = 0 , then
Q -function can be perfectly predicted by a linear function of φ ( · , · ) .
In general, δ becomes smaller as we increase the dimension of φ , since larger dimension usually has more expressive power.
When the feature extractor is strong enough, previous papers (Chen & Jiang, 2019; Farahmand, 2011) assume that linear functions of φ can approximate the Q -function of any policy.
Assumption 4.2 (Policy Completeness) .
There exists δ > 0 , such that for any h ∈ [ H ] and any policy π , there exists θ πh ∈ R d such that for any ( s, a ) ∈ S h × A , | Q πh ( s, a ) − (cid:104) θ h , φ ( s, a ) (cid:105)| ≤ δ.
In the theoretical reinforcement learning literature, Assumption 4.2 is often called the (approximate) policy completeness assumption.
This assumption is crucial in proving polynomial sample complexity guarantee for value iteration type of algorithms (Chen & Jiang, 2019; Farahmand, 2011).
The following theorem shows when δ = Ω (cid:16)(cid:113) Hd (cid:17) , the agent needs to sample exponential number of trajectories to ﬁnd a near-optimal policy.
Theorem 4.1 (Exponential Lower Bound for Value-based Learning) .
There exists a family of MDPs and a feature extractor φ that satisfy Assumption 4.2 with d = 2 · (cid:100) 8 ln 2 H/δ 2 (cid:101) , such that any algorithm that returns a 1 / 2 -optimal policy with probability 0 .
9 needs to sample Ω (cid:0) 2 H (cid:1) trajectories.
Note this lower bound also applies to MDPs that satisfy Assumption 4.1, since Assumption 4. is strictly stronger.
We would like to emphasize that since linear functions is a subclass of more complicated function classes, e.g., neural networks, our lower bound also holds for these function classes.
Moreover, in many scenarios, the feature extractor φ is the last layer of a neural network.
Modern neural networks are often over-parameterized, which makes d large.
In this case, d is much larger than H .
Thus, our lower bound holds even if the representation has small approximation error.
4. L OWER B OUND FOR M ODEL - BASED L EARNING
Here we present our lower bound for model-based learning.
Recently, Yang & Wang (2019b) proposed the linear transition assumption which was later studied in Yang & Wang (2019a); Jin et al.
Again, we assume the agent is given a feature extractor φ : S ×
A → R d , and now we state the assumption formally as follow.
Assumption 4.3 (Approximate Linear MDP) .
There exists δ > 0 , β 0 , β 1 , . . .
, β H − 1 ∈ R d and ψ : S → R d such that for any h ∈ [ H − 1] , ( s, a ) ∈ S
h × A and s (cid:48)
∈ S h
+1 , | P ( s (cid:48) | s, a ) − (cid:104) ψ
( s (cid:48) ) , φ ( s, a ) (cid:105)| ≤ δ and | E [ R ( s, a )] − (cid:104) β h , φ ( s, a ) (cid:105)| ≤ δ .
It has been shown in Yang & Wang (2019b;a); Jin et al.
(2019) if (cid:107) P ( · | s, a ) − (cid:104) ψ ( · ) , φ ( s, a ) (cid:105)(cid:107) 1 is bounded, then the problem admits an algorithm with polynomial sample complexity.
Now we show that when δ = Ω (cid:16)(cid:113) Hd (cid:17) in Assumption 4.3, the agent needs exponential number of samples to ﬁnd a near-optimal policy.
Theorem 4.2 (Exponential Lower Bound for Linear Transition Model) .
There exists a family of
MDPs and a feature extractor φ that satisfy Assumption 4.3 with d = 2 · (cid:100) 8 ln 2 H/δ 2 (cid:101) , such that any algorithm that returns a 1 / 2 -optimal policy with probability 0 .
9 needs to sample Ω (cid:0) 2 H (cid:1) trajectories.
We do note that an (cid:96) ∞ approximation for a transition matrix may be a weak condition.
Under the stronger condition that the transition matrix can be approximated well under the total variational distance, there exists polynomial sample complexity upper bounds that can tolerate approximation errors (Yang & Wang, 2019b;a; Jin et al., 2019).
4. L OWER B OUND FOR P OLICY - BASED L EARNING
Next we present our lower bound for policy-based learning.
This class of methods use function approximation on the policy and use optimization techniques, e.g., policy gradient, to ﬁnd the optimal policy.
In this paper, we focus on linear policies on top of a given representation.
A linear policy π is a policy of the form π ( s h ) =
arg max a ∈A (cid:104) θ h , φ ( s h , a ) (cid:105) where s h ∈ S h , φ ( · , · ) is a given feature extractor and θ h ∈ R
d is the linear coefﬁcient.
Note that applying policy gradient on softmax parameterization of the policy is indeed trying to ﬁnd the optimal policy among linear policies.
Similar to value-based learning, a natural assumption for policy-based learning is that the optimal policy is realizable 5 , i.e., the optimal policy is linear.
Assumption 4.4.
For any h ∈ [ H ] , there exists θ h ∈ R d that satisﬁes for any s ∈ S h , we have π ∗ ( s ) ∈ arg max a (cid:104) θ h , φ ( s, a ) (cid:105) .
Here we discuss another assumption.
For learning a linear classiﬁer in the supervised learning setting, one can reduce the sample complexity signiﬁcantly if the optimal linear classiﬁer has a margin.
Assumption 4.5.
We assume φ ( s, a ) ∈ R d satisﬁes (cid:107) φ ( s, a ) (cid:107) 2 = 1 for any ( s, a ) ∈ S × A .
For any h ∈ [ H ] , there exists θ h ∈ R d with (cid:107) θ h (cid:107) 2 = 1 and (cid:52) > 0 such that for any s ∈ S h , there is a unique optimal action π ∗ ( s ) , and for any a (cid:54) =
π ∗ ( s ) , (cid:104) θ h , φ ( s, π ∗ ( s ))
(cid:105) − (cid:104) θ h , φ ( s, a ) (cid:105) ≥ (cid:52) .
Here we restrict the linear coefﬁcients and features to have unit norm for normalization.
Note that
Assumption 4.5 is strictly stronger than Assumption 4.4.
Now we present our result for linear policy.
Theorem 4.3 (Exponential Lower Bound for Policy-based Learning) .
There exists an absolute constant (cid:52) 0 , such that for any (cid:52) ≤ (cid:52) 0 , there exists a family of MDPs and a feature extractor φ that satisfy Assumption 3.1 with ρ = 1 2min { H,d } and Assumption 4.5, such that any algorithm that returns a 1 / 4 -optimal policy with probability at least 0 .
9 needs to sample Ω (cid:0) min { 2 H , 2 d } (cid:1) trajectories.
Compared with Theorem 4.1, Theorem 4.3 is even more pessimistic, in the sense that even with perfect representation with benign properties (gap and margin), the agent still needs to sample exponential number of samples.
It also suggests that policy-based learning could be very different from supervised learning.
4. P ROOF I DEAS
The binary tree hard instance.
All our lower bound are proved based on reductions from the following hard instance.
In this instance, both the transition P and the reward R are deterministic.
There are H levels of states, which form a full binary tree of depth H .
There are 2 h states in level h , and thus 2 H − 1 states in total.
Among all the 2 H − 1 states in level H − 1 , there is only one state with reward R = 1 , and for all other states in the MDP, the corresponding reward value R = 0 .
Intuitively, to ﬁnd a 1 / 2 -optimal policy for such MDPs, the agent must enumerate all possible states in level
H − 1 to ﬁnd the state with reward R = 1 .
Doing so intrinsically induces a sample complexity of Ω(2 H ) .
This intuition is formalized in Theorem A.1 using Yao’s minimax principle (Yao, 1977).
Lower bound for value-based and model-based learning We now show how to construct a set of features so that Assumption 4.1-4.3 hold.
Our main idea is to the utilize the following fact regarding the identity matrix: ε - rank( I 2 H ) ≤
O ( H/ε 2 ) .
Here for a matrix A ∈ R n × n , its ε - rank (a.k.a approximate rank ) is deﬁned to be min { rank( B ) : B ∈ R n × n , (cid:107) A − B (cid:107) ∞ ≤ ε } , where we use (cid:107) · (cid:107) ∞ to denote the entry-wise (cid:96) ∞ norm of a matrix.
The upper bound ε - rank( I n ) ≤ O (log n/ε 2 ) was ﬁrst proved in Alon (2009) using the Johnson-Lindenstrauss Lemma (Johnson & Lindenstrauss, 1984), and we also provide a proof in Lemma A.1.
The concept of ε - rank has wide applications in theoretical computer science (Alon, 2009; Barak et al., 2011; Alon et al., 2013; 2014; Chen & Wang, 2019), but to our knowledge, this is the ﬁrst time that it appears in reinforcement learning.
This fact can be alternatively stated as follow: there exists Φ ∈ R
2 H × O
( H/ε 2 ) such that (cid:107) I 2 H − ΦΦ (cid:62) (cid:107) ∞
≤ ε .
We interpret each row of Φ as the feature of a state in the binary tree.
By construction of Φ , now features of states in the binary tree have a nice property that (i) each feature vector has approximately unit norm and (ii) different feature vector are nearly orthogonal.
Using this set of features, we can now show that Assumption 4.1-4.3 hold.
Here we prove Assumption 4.1 holds as an example and prove other assumptions also hold in the appendix.
To prove Assumption 4.1, we note that in the binary tree hard instance, for each level h , only a single state satisﬁes Q ∗ = 1 , and all other states satisfy Q ∗ = 0 .
We simply take θ h to be the feature of the state with Q ∗ = 1 .
Since all feature vectors are nearly orthogonal, Assumption 4.1 holds.
Since the above fact regarding the ε - rank of the identity matrix can be proved by simply taking each row of Φ to be a random unit vector, our lower bound reveals another intriguing (yet pessimistic) aspect of Assumption 4.1-4.3: for the binary tree instance, almost all feature extractors induce a hard MDP instance.
This again suggests that a good representation itself may not necessarily lead to efﬁcient RL and additional assumptions (e.g. on the reward distribution) could be crucial.
Lower bound for policy-based learning.
It is straightfoward to construct a set of feature vectors for the binary tree instance so that Assumption 4.4 holds, even if d = 1 .
We set φ ( s, a ) to be +1 if a = a 1 and − 1 if a = a 2 .
For each level h , for the unique state s in level h with Q ∗ = 1 , we set θ h to be 1 if π ∗ ( s ) =
a 1 and − 1 if π ∗ ( s ) = a 2 .
With this construction, Assumption 4.4 holds.
To prove that the lower bound under Assumption 4.5, we use a new reward function for states in level H − 1 in the binary tree instance above so that there exists a unique optimal action for each state in the MDP.
See Figure 2 for an example with H = 3 levels of states.
Another nice property of the new reward function is that for all states s we always have π ∗ ( s )
=
a 1 .
Now, we deﬁne 2 H − 1 different new MDPs as follow: for each state in level H − 1 , we change its original reward (deﬁned in Figure 2) to 1 .
An exponential sample complexity lower bound for these MDPs can be proved using the same argument as the original binary tree hard instance, and now we show this set of MDPs satisfy Assumption 4.5.
We ﬁrst show in Lemma A.2 that there exists a set N ⊆ S
d − 1 with |N| =
(1 / (cid:52) ) Ω( d ) , so that for each p ∈ N , there exists a hyperplane L that separates p and N \ { p } , and all vectors in N have distance at least (cid:52) to L .
Equivalently, for each p ∈ N , we can always deﬁne a linear function f p so that f p ( p ) ≥ (cid:52) and f p ( q ) ≤ −(cid:52) for all q ∈ N \ { p } .
This can be proved using standard lower bounds on the size of ε -nets.
Now we simply use vectors in N as features of states.
By construction of the reward function, for each level h , there could only be two possible cases for the optimal policy π ∗ .
I.e., either π ∗ ( s ) =
a 1 for all states in level h , or π ∗ ( s ) =
a 2 for a unique state s and π ∗ ( s (cid:48) )
= a 1 for all s (cid:54) =
s (cid:48) .
In both cases, we can easily deﬁne a linear function with margin (cid:52) to implement the optimal policy π ∗ , and thus Assumption 4.5 holds.
Notice that in this proof, we critically relies on d = Θ( H ) , so that we can utilize the curse of dimensionality to construct a large set of vectors as features.
S EPARATIONS
Perfect representation vs. good-but-not-perfect representation.
For value-based learning in deterministic systems, Wen & Van Roy (2013) showed polynomial sample complexity upper bound when the representation can perfectly predict the Q -function.
In contrast, if the representation is only able to approximate the Q -function, then the agent requires exponential number of trajectories.
This exponential separation demonstrates a provable exponential beneﬁt of better representation.
Value-based learning vs. policy-based learning.
Note that if the optimal Q -function can be perfectly predicted by the provided representation, then the optimal policy can also be perfectly predicted using the same representation.
Since Wen & Van Roy (2013) showed polynomial sample complexity upper bound when the representation can perfectly predict the Q -function, our lower bound on policy-based learning, which applies to perfect representations, thus demonstrates that the ability of predicting the Q -function is much stronger than that of predicting the optimal policy.
Supervised learning vs. reinforcement learning.
For policy-based learning, if the planning horizon
H = 1 , the problem becomes learning a linear classiﬁer, for which there are polynomial sample complexity upper bounds.
For policy-based learning, the agent needs to learn H linear classiﬁers sequentially.
Our lower bound on policy-based learning shows the sample complexity dependency on
H is exponential.
Imitation learning vs. reinforcement learning.
In imitation learning (IL), the agent can observe trajectories induced by the optimal policy (expert).
If the optimal policy is linear in the given representation, it can be shown that the simple behavior cloning algorithm only requires polynomial number of samples to ﬁnd a near-optimal policy (Ross et al., 2011).
Our Theorem 4.3 shows if the agent cannot observe expert’s behavior, then it requires exponential number of samples.
Therefore, our lower bound shows there is an exponential separation between policy-based RL and IL when function approximation is used.
A CKNOWLEDGMENTS
The authors would like to thank Yuping Luo, Wenlong Mou, Martin Wainwright, Mengdi Wang and Yifan Wu for insightful discussions.
Also, the authors would also like to gratefully acknowledge Benjamin Van Roy, Shi Dong, Tor Lattimore and Csaba Szepesv´ari for sharing a draft of their work and their comments.
Simon S. Du is supported by NSF grant DMS-1638352 and the Infosys Membership. Ruosong Wang is supported in part by NSF IIS1763562, AFRL CogDeCON FA875018C0014, and DARPA SAGAMORE HR00111990016.
Sham M. Kakade acknowledges funding from the Washington Research Foundation Fund for Innovation in Data-Intensive Discovery; the NSF award CCF 1740551; and the ONR award N00014-18-1-2247.
Part of this work was done while Simon S.
Du was visiting Google Brain Princeton and Ruosong Wang was visiting Princeton University.
A P ROOFS OF L OWER B OUNDS
In this section we present our lower bounds.
It will also be useful to deﬁne the value function of a given state s ∈ S h as V πh ( s ) =
E (cid:104)(cid:80) H − 1 h (cid:48)
=
h r h (cid:48) | s h
= s, π (cid:105) .
For simplicity, we denote V ∗ h
=
V π ∗ h ( s ) .
Throughout the appendix, for the Q -function Q πh and Q ∗ h and the value function V πh and V ∗ h , we may omit h from the subscript when it is clear from the context.
We ﬁrst introduce the INDEX-QUERY problem, which will be useful in our lower bound arguments.
Deﬁnition A.1 ( INDEX-QUERY ) .
In the INDQ n problem, there is an underlying integer i ∗ ∈ [ n ] .
The algorithm sequentially (and adaptively) outputs guesses i ∈ [ n ] and queries whether i = i ∗ .
The goal is to output i ∗ , using as few queries as possible.
Deﬁnition A.2 ( δ -correct algorithms) .
For a real number δ ∈ (0 , 1) , we say a randomized algorithm
A is δ -correct for INDQ n , if for any underlying integer i ∗ ∈ [ n ] , with probability at least 1 − δ , A outputs i ∗ .
The following theorem states the query complexity of INDQ n for 0 .
1 -correct algorithms, whose proof is provided in Section B.1.
Theorem A.1.
Any 0 .
1 -correct algorithm A for INDQ n requires at least 0 .
9 n queries in the worst case.
A. P ROOF OF L OWER B OUND FOR V ALUED - BASED L EARNING
In this section we prove Theorem 4.1.
We need the following existential result, whose proof is provided in Section B.2.
Lemma A.1.
For any n > 2 , there exists a set of vectors P = { p 0 , p 1 , . .
, p n − 1 } ⊂ R d with d = (cid:100) 8 ln n/ε 2 (cid:101) such that
(cid:107) p
i (cid:107) 2 = 1 for all 0 ≤ i ≤ n − 1 ; 2. |(cid:104) p i , p j (cid:105)| ≤ ε for any 0 ≤ i, j ≤ n − 1 with i (cid:54) =
j .
Now we give the construction of the hard MDP instances.
We ﬁrst deﬁne the transitions and the reward functions.
In the hard instances, both the rewards and the transitions are deterministic.
There are H levels of states, and level h ∈
[ H ] contains 2 h distinct states.
Thus, there are 2 H − 1 states in the MDPs.
We use s 0 , s 1 , . . .
, s 2 H − 2 to name these states.
Here, s 0 is the unique state in level h = 0 , s 1 and s 2 are the two states in level h
= 1 , s 3 , s 4 , s 5 and s 6 are the four states in level h
= 2 , etc.
There are two different actions, a 1 and a 2 , in the MDPs.
For a state s i in level h with h < H − 1 , playing action a 1 transits state s i to state s
i +1 and playing action a 2 transits state s i to state s
i +2 , where s
i +
and s 2 i +2 are both states in level h
+ 1 .
See Figure 1 for an example with H = 3 .
In our hard instances, r ( s, a ) = 0 for all ( s, a ) pairs except for a unique state s in level H − 2 and a unique action a ∈ { a 1 , a 2 } .
It is convenient to deﬁne r ( s (cid:48) )
=
r ( s, a ) , if playing action a transits s to s (cid:48) .
For our hard instances, we have r ( s ) =
1 for a unique node s in level H − 1 and r ( s ) =
for all other nodes.
Now we deﬁne the features map φ ( · , · ) .
We ﬁrst invoke Lemma A.1 to get a set P = { p 0 , p 1 , . .
, p 2 H − 1 } ⊂ R d/ 2 with d = 2 · (cid:100) 8 ln 2 H/δ 2 (cid:101) .
For each state s i , φ ( s i , a 1 ) ∈ R d is deﬁned to be [ p i ; 0] , and φ ( s i , a
2 ) ∈ R d is deﬁned to be [0; p i ] .
This ﬁnishes the deﬁnition of the
MDPs.
We now show that no matter which state s in level H − 1 satisﬁes r ( s )
= 1 , the resulting
MDP always satisﬁes Assumption 4.2.
Verifying Assumption 4.2.
By construction, for each level h ∈
[ H ] , there is a unique state s h in level h and action a h ∈ { a 1 , a 2 } , such that Q ∗ ( s h , a h ) = 1 .
For all other ( s, a ) pairs such that s (cid:54) =
s h or a (cid:54)
=
a h , it is satisﬁed that Q ∗ ( s, a ) = 0 .
For a given level h and policy π , we take θ πh to be
Q π ( s h , a h ) · φ ( s h , a h ) .
Now we show that | Q π ( s, a ) − (cid:104) θ πh , φ ( s, a ) (cid:105)| ≤ δ for all states s in level h and a ∈ { a 1 , a 2 } .
Case I: a (cid:54) =
a h .
In this case, we have Q π ( s, a ) = 0 and (cid:104) θ πh , φ ( s, a ) (cid:105) = 0 , since θ πh and φ ( s, a ) do not have a common non-zero coordinate.
[Figure]
s
[Figure]
Q ∗ ( s 1 , a 1 ) =s
Q ∗ ( s 1 , a 2 ) =
Q ∗ ( s 0 , a 1 ) =
ss
Q ∗ ( s 2 , a 1 ) =s
Q ∗ ( s 2 , a 2 ) =
Q ∗ ( s 0 , a 2 ) =
Case II: a = a h and s (cid:54) =
s h .
In this case, by the second property of P in Lemma A.1 and the fact that Q π ( s h , a h ) ≤ 1 , we have |(cid:104) θ πh , φ ( s, a ) (cid:105)| ≤ δ .
Meanwhile, we have Q π ( s, a ) = 0 .
Case III: a = a h and s = s h .
In this case, we have (cid:104) θ πh , φ ( s, a ) (cid:105) =
Q π ( s h , a h ) .
Finally, we prove any algorithm that solves these MDP instances and succeeds with probability at least 0 .
9 needs to sample at least 920 · 2 H trajectories.
We do so by providing a reduction from
INDQ 2 H − 1 to solving MDPs.
Suppose we have an algorithm for solving these MDPs, we show that such an algorithm can be transformed to solve INDQ 2 H − 1 .
For a speciﬁc choice of i ∗ in INDQ 2 H − 1 , there is a corresponding MDP instance with
[Equation]
otherwise
[Equation]
Notice that for all MDPs that we are considering, the transition and features are always the same.
Thus, the only thing that the learner needs to learn by interacting with the environment is the reward value.
Since the reward value is non-zero only for states in level H − 1 , each time the algorithm for solving MDP samples a trajectory that ends at state s i where s i is a state in level H − 1 , we query whether i ∗ =
i − 2 H − 1 + 1 or not in INDQ 2 H − 1 , and return reward value 1 if i ∗ =
i − 2 H − 1 +and 0 otherwise.
If the algorithm is guaranteed to return a 1 / 2 -optimal policy, then it must be able to ﬁnd i ∗ .
A. P ROOF OF L OWER B OUND FOR M ODEL - BASED L EARNING
In this section, we prove our hardness results for model-based learning.
Proof of Theorem 4.2.
We use the same construction as in the proof of Theorem 4.1.
Note we just need to verify the construction satisﬁes Assumption 4.3.
By construction, for all h ∈ { 1 , 2 , . . .
, H − 1 } , for each state s (cid:48) in level h , there exists a unique ( s, a ) pair such that playing action a transits s to s (cid:48) , and we take ψ ( s (cid:48) )
=
φ ( s, a ) .
We also take β h = 0 for h ∈ { 0 , 1 , . . .
, H − 4 , H − 3 } and β H − 2 =
φ ( s, a ) where ( s, a ) is the unique pair with R ( s, a )
= 1 .
Now, according to the design of φ ( · , · ) and Lemma A.1, Assumption 4.3 is satisﬁed.
A. P ROOF OF L OWER B OUND FOR P OLICY - BASED L EARNING
In this section, we prove our hardness results for policy-based learning.
We ﬁrst prove a weaker lower bound which only satisﬁes Assumption 4.4, and then prove Theoerem 4.3.
Warmup: Lower Bound for Linear Policy without Margin.
To present the hardness results, we ﬁrst give the construction of the hard instances.
The transitions and rewards functions of these MDP instances are exactly the same as those in Section A.1.
The main difference is in the deﬁnition of the feature map φ ( · , · ) .
For this lower bound, we deﬁne φ ( s, a ) = 1 ∈ R if a = a 1 and φ ( s, a ) =
−if a = a 2 .
By construction, these MDPs satisfy Assumption 3.1 with ρ = 1 .
We now show that no matter which state s in level H − 1 satisﬁes r ( s ) = 1 6 , the resulting MDP always satisﬁes
Assumption 4.4.
Verifying Assumption 4.4.
Recall that for each level h ∈
[ H ] , there is a unique state s h in level h and action a h ∈ { a 1 , a 2 } , such that Q ∗ ( s h , a h ) = 1 .
For all other ( s, a ) pairs such that s (cid:54) =
s h or a (cid:54)
=
a h , it is satisﬁed that Q ∗ ( s, a ) = 0 .
We simply take θ h to be 1 if a h = a 1 , and take θ h to be −if a h = a 2 .
Using the same lower bound argument (by reducing INDEX-QUERY to MDPs), we have the following theorem.
Theorem A.2.
There exists a family of MDPs and a feature map φ ( · , · ) that satisfy Assumption 4.
with d = 1 and Assumption 3.1 with ρ = 1 , such that any algorithm that returns a 1 / 2 -optimal policy with probability at least 0 .
9 needs to sample Ω (cid:0) 2 H (cid:1) trajectories.
Proof of Theoerem [-4.
-]4.3.
Now we prove Theoerem 4.3.
In order to prove Theoerem 4.3, we need the following geometric lemma whose proof is provided in Section B.3.
Lemma A.2.
Let d ∈ N + be a positive integer and (cid:15) ∈ (0 , 1) be a real number.
Then there exists a set of points N ⊂ S d − 1 with size |N| = Ω(1 /(cid:15) d/ 2 ) such that for every point x ∈ N ,
[Equation]
Now we are ready to prove Theorem 4.3.
In the proof we assume H =
d , since otherwise we can take H and d to be min { H, d } by decreasing the planning horizon H or adding dummy dimensions to the feature extractor φ .
Proof of Theorem 4.3.
We deﬁne a set of 2 H − 1 deterministic MDPs.
The transitions of these hard instances are exactly the same as those in Section A.1.
The main difference is in the deﬁnition of the feature map φ ( · , · ) and the reward function.
Again in the hard instances, r ( s, a ) = 0 for all s in the ﬁrst H − 2 levels.
Using the terminology in Section A.1, we have r ( s ) =
for all states in the ﬁrst
H − 1 levels.
Now we deﬁne r ( s ) for states s in level H − 1 .
We do so by recursively deﬁning the optimal value function V ∗ ( · ) .
The initial state s 0 in level 0 satisﬁes V ∗ ( s 0 )
= 1 / 2 .
For each state s i in the ﬁrst H − 2 levels, we have V ∗ ( s 2 i +1 )
=
V ∗ ( s i ) and V ∗ ( s 2 i +2 )
=
V ∗ ( s i ) − 1 / 2 H .
For each state s i in the level h
= H − 2 , we have r ( s 2 i +1 )
=
V ∗ ( s i ) and r ( s 2 i +2 )
=
V ∗ ( s i ) − 1 / 2 H .
This implies that ρ = 1 / 2 H .
In fact, this implies a stronger property that each state has a unique optimal action.
See Figure 2 for an example with H = 3 .
To deﬁne 2 H − 1 different MDPs, for each state s in level H − 1 of the MDP deﬁned above, we deﬁne a new MDP by changing r ( s ) from its original value to 1 .
This also affects the deﬁnition of the optimal
V function for states in the ﬁrst H − 1 levels.
In particular, for each level i ∈ { 0 , 1 , 2 , . . .
, H − 2 } , we have changed the V value of a unique state in level i from its original value (at most 1 / 2 ) to 1 .
By doing so we have deﬁned 2 H − 1 different MDPs.
See Figure 3 for an example with H = 3 .
Now we deﬁne the feature function φ ( · , · ) .
We invoke Lemma A.2 with (cid:15) = 8 (cid:52) and d = H/ 2 − 1 .
Since (cid:52) is sufﬁciently small, we have |N| ≥ 2 H .
We use P = { p 0 , p 2 , . .
, p 2 H − 1 } ⊂ R H/ 2 − 1 to denote an arbitrary subset of N with cardinality 2 H .
By Lemma A.2, for any p ∈ P , the distance between p and the convex hull of P \ { p } is at least 4 (cid:52) .
Thus, there exists a hyperplane L which separates p and P \ { p } , and for all points q ∈ P , the distance between q and L is at least 2 (cid:52) .
Equivalently, for each point p ∈ P , there exists n p ∈ R H/ 2 − 1 and o p ∈ R such that (cid:107) n p (cid:107)
= 1 , | o p | ≤ 1 and the linear function f p ( q ) =
(cid:104) q, n p (cid:105)
+ o p satisﬁes f p ( p ) ≥ 2 (cid:52) and f p ( q ) ≤ − 2 (cid:52) for all q ∈ P \ { p } .
Given the set P = { p 0 , p 2 , . . .
, p 2 H − 1 } ⊂ R H/ 2 − 1 , we construct a new set [Equation]
[Equation]
P = { p 0 , p 2 , . .
, p 2 H − 1 } ⊂ R H/ 2 , where p i =
[ p i ; 1] ∈ R H/ 2 .
Thus (cid:107) p
i (cid:107) 2 = √ 2 for all p i ∈ P .
Clearly, for each p ∈ P , there exists a vector ω p ∈ R H/ 2 such that (cid:104) ω p , p (cid:105) ≥ 2 (cid:52) and (cid:
) ω p , q (cid:105) ≤ − 2 (cid:52) for all q ∈ P \ { p } .
It is also clear that (cid:107) ω p (cid:107) 2 ≤ √ 2 .
We take φ ( s i , a 1 ) =
[0; p i ] ∈ R H and φ ( s i , a 2 ) =
[ p i ; 0] ∈ R H .
We now show that all the 2 H − 1 MDPs constructed above satisfy the linear policy assumption.
Namely, we show that for any state s in level H − 1 , after changing r ( s ) to be 1, the resulting MDP satisﬁes the linear policy assumption.
As in Section A.1, for each level h ∈ [ H ] , there is a unique state s h in level h and action a h ∈ { a 1 , a 2 } , such that Q ∗ ( s h , a h ) = 1 .
For all other ( s, a ) pairs such that s (cid:54) =
s h or a (cid:54)
=
a h , it is satisﬁed that Q ∗ ( s, a ) = 0 .
For each level h , if a h = a 1 , then we take ( θ h ) H/ 2 = 1 and ( θ h ) H = − 1 , and all other entries in θ h are zeros.
If a h = a 2 , we use p to denote the vector formed by the ﬁrst H/ 2 coordinates of φ ( s h , a 2 ) .
By construction, we have p ∈ P .
We take θ h =
[ ω p ; 0] in this case.
In any case, we have (cid:107) θ h (cid:107) 2 ≤ √ 2 .
Now for each level h , if a h = a 1 , then for all states s in level h , we have π ∗ ( s ) =
a 1 .
In this case, (cid:104) φ ( s, a 1 ) , θ h (cid:105)
=
1 and (cid:104) φ ( s, a 2 ) , θ h (cid:105) =
− 1 for all states in level h , and thus Assumption 4.5 is satisﬁed.
If a h = a 2 , then π ∗ ( s h ) =
a 2 and π ∗ ( s ) =
a 1 for all states s (cid:54) =
s h in level h .
By construction, we have (cid:104) θ h , φ ( s, a 1 ) (cid:105) = 0 for all states s in level h , since θ h and φ ( s, a 1 ) do not have a common non-zero entry.
We also have (cid:104) θ h , φ ( s h , a 2 ) (cid:105) ≥ 2 (cid:52) and (cid:104) θ h , φ ( s, a 2 ) (cid:105) ≤ − 2 (cid:52) for all states s (cid:54) =
s h in level h .
Finally, we normalize all θ h and φ ( s, a ) so that they all have unit norm.
Since (cid:107) φ ( s, a ) (cid:107) 2 = √ 2 for all ( s, a ) pairs before normalization,
Assumption 4.5 is still satisﬁed after normalization.
Finally, we prove any algorithm that solves these MDP instances and succeeds with probability at least 0 .
9 needs to sample at least Ω(2 H ) trajectories.
We do so by providing a reduction from
INDQ 2 H − 1 to solving MDPs.
Suppose we have an algorithm for solving these MDPs, we show that such an algorithm can be transformed to solve INDQ 2 H − 1 .
For a speciﬁc choice of i ∗ in INDQ 2 H − 1 , there is a corresponding MDP instance with r [Equation] (cid:26)
[Equation]
the original (recursively deﬁned) value otherwise .
Notice that for all MDPs that we are considering, the transition and features are always the same.
Thus, the only thing that the learner needs to learn by interacting with the environment is the reward value.
Since the reward value is non-zero only for states in level H − 1 , each time the algorithm for solving MDP samples a trajectory that ends at state s i where s i is a state in level H − 1 , we query whether i ∗ =
i − 2 H − 1 + 1 or not in INDQ 2 H − 1 , and return reward value 1 if i ∗ =
i − 2 H − 1 +
and it original reward value otherwise.
If the algorithm is guaranteed to return a 1 / 4 -optimal policy, then it must be able to ﬁnd i ∗ .
B T ECHNICAL P ROOFS B. P ROOF OF T HEOREM A.
Proof.
The proof is a straightforward application of Yao’s minimax principle Yao (1977).
We provide the full proof for completeness.
Consider an input distribution where i ∗ is drawn uniformly at random from [ n ] .
Suppose there is a 0 . 1 -correct algorithm for INDQ n with worst-case query complexity T such that T < 0 .
9 n .
By averaging, there is a deterministic algorithm A (cid:48) with worst-case query complexity T , such that
[Equation]
We may assume that the sequence of queries made by A (cid:48) is ﬁxed.
This is because (i) A (cid:48) is deterministic and (ii) before A (cid:48) correctly guesses i ∗ , all responses that A (cid:48) receives are the same (i.e., all guesses are incorrect).
We use S =
{ s 1 , s 2 , . .
, s m } to denote the sequence of queries made by A (cid:48) .
Notice that m is the worst-case query complexity of A (cid:48) .
Suppose m < 0 .
9 n , there exist 0 .
1 n distinct i ∈ [ n ] such that A (cid:48) will never guess i , and will be incorrect if i ∗ equals i , which implies
Pr
[Table]
B. P ROOF OF L EMMA A.
We need the following tail inequality for random unit vectors, which will be useful for the proof of
Lemma A.1.
Lemma B.1 (Lemma 2.2 in Dasgupta & Gupta (2003)) .
For a random unit vector u in R d and β > 1 , we have
[Equation]
In particular, when β ≥ 6 ,we have
[Equation]
Proof of Lemma A.1.
Let Q = { q 1 , q 2 , . . .
, q n } be a set of n independent random unit vectors in R d with d = (cid:100) 8 ln n/ε 2 (cid:101) .
We will prove that with probability at least 1 / 2 , Q satisﬁes the two desired properties as stated in Lemma A.1.
This implies the existence of such set P .
It is clear that (cid:107) q
i (cid:107) 2 = 1 for all i ∈ [ n ] , since each q i is drawn from the unit sphere.
We now prove that for any i, j ∈ [ n ] with i (cid:54) =
j , with probability at least 1 − 1 n 2 , we have |(cid:104) q i , q j (cid:105)| ≤ ε .
Notice that this is sufﬁcient to prove the lemma, since by a union bound over all the (cid:0) n 2 (cid:1) =
n ( n − 1) / 2 possible pairs of ( i, j ) , this implies that Q satisﬁes the two desired properties with probability at least 1 / 2 .
Now, we prove that for two independent random unit vectors u and v in R d with d = (cid:100) 8 ln n/ε 2 (cid:101) , with probability at least 1 − 1 n 2 , |(cid:104) u, v (cid:105)| ≤ ε .
By rotational invariance, we assume that v is a standard basis vector.
I.e., we assume v 1 =
and v i =
for all 1 < i ≤ d .
Notice that now (cid:104) u, v (cid:105) is the magnitude of the ﬁrst coordinate of u .
We ﬁnish the proof by invoking Lemma B.1 and taking β = 8 ln n > 6 .
B. P ROOF OF L EMMA A.
Proof of Lemma A.2.
Consider a √ (cid:15) -packing N with size Ω(1 /(cid:15) d/ 2 ) on the d -dimensional unit sphere S d − 1 (for the existence of such a packing, see, e.g., Lorentz (1966)).
Let o be the origin.
For two points x, x (cid:48) ∈ R d , we denote | xx (cid:48) | := (cid:107) x − x (cid:48) (cid:107) 2 the length of the line segment between x, x (cid:48) .
Note that every two points x, x (cid:48) ∈ N satisfy | xx (cid:48) | ≥ √ (cid:15) .
To prove the lemma, it sufﬁces to show that N satisﬁes the property equation 1 .
Consider a point x ∈ N , let A be a hyperplane that is perpendicular to x (notice that x is a also a vector) and separates x and every other points in N .
We let the distance between x and A be the largest possible, i.e., A contains a point in N\{ x } .
Since x is on the unit sphere
and N is a √ (cid:15) -packing, we have that x is at least √ (cid:15) away from every point on the spherical cap not containing x , deﬁned by the cutting plane A .
More formally, let b be the intersection point of the line segment ox and A .
Then
[Equation]
Indeed, by symmetry, ∀ y ∈ { y
[Equation]
where z ∈ N ∩ A .
Notice that the distance between x and the convex hull of N\{ x } is lower bounded by the distance between x and A , which is given by | bx | .
Consider the triangles deﬁned by x, z, o, b .
We have bz ⊥ ox (note that bz lies inside A ).
By Pythagorean theorem, we have
[Equation]
Solve the above three equations for | bx | , we have
[Equation]
as desired.
C E XACT L INEAR Q ∗ + G AP IN G ENERATIVE M ODEL
In this section we present and prove the following theorem.
Theorem C.1.
Under Assumption 3.1, Assumption 4.2 and Generative Model query model, the agent can ﬁnd the optimal π ∗ with poly (cid:16) d, H, 1 ρ , log (cid:0) 1 δ (cid:1)(cid:17) queries with probability 1 − δ for a given failure probability δ > 0 ,
Proof of Theorem C.1.
We ﬁrst describe the algorithm.
For each level, the agent ﬁrst construct a barycentric spanner Λ h (cid:44) (cid:8) φ ( s 1 h , a 1 h ) , . . .
φ ( s dh , a dh ) (cid:9) ⊂
Φ h (cid:44) { φ ( s, a ) } s ∈S h ,a ∈A (Awerbuch & Kleinberg, 2008).
We have the property that any φ ( s, a ) with s h ∈ S h , a ∈ A , we have c 1 s,a , . . .
, c ds,a ∈ [ − 1 , 1] such that φ ( s, a ) =
(cid:80) di
=1 c is,a φ ( s ih , a ih ) .
The algorithm learns the optimal policy from h
= H − 1 , . . .
At any level h , we assume the agent has learned the optimal policy π ∗ h (cid:48) at level h (cid:48)
=
h + 1 , . .
, H − 1 .
Now we present a procedure to show how to learn the optimal policy at level h .
At level h , the agent queries every vector φ ( s ih , a ih ) in Λ h for poly( d, 1 ρ , log (cid:0)
Hδ (cid:1) ) times and uses π ∗ h
+1 , . . .
, π ∗ H as the roll-out to get the on-the-go reward.
Note by the deﬁnition of π ∗ and Q ∗ , the on-the-go reward is an unbiased sample of Q ∗ ( s ih , a ih ) .
We denote (cid:98) Q ( s ih , a ih )
the average of these on-the-go rewards.
By Hoeffding inequality, it is easy to show with probability 1 − δH , for all i = 1 , . . .
, d , (cid:12)(cid:12)(cid:12) (cid:98) Q ( s ih , a ih ) − Q ∗ ( s ih , a ih ) (cid:12)(cid:12)(cid:12) ≤ poly (cid:0) 1 d , ρ (cid:1) .
Now we deﬁne our estimated Q ∗ at level h as follow: for any ( s, a ) ∈ S h × A , (cid:98) Q ( s, a )
= (cid:80) di
=1 c is,a (cid:98) Q ( s ih , a ih ) .
By the boundedness property of c s,a , we know for any ( s, a ) ∈ S h × A , (cid:98) Q ( s, a ) − Q ∗ ( s, a ) <
ρ 2 .
Note this implies the policy induced by (cid:98) Q is the same as π ∗ .
Therefore by induction we ﬁnish the proof.
D L INEAR Q π FOR ALL π IN G ENERATIVE M ODEL
In this section we present and prove the following theorem.
Theorem D.1.
Under Assumption 4.2 with δ = 0 , in the Generative Model query model, there is an algorithm that ﬁnds an (cid:15) -optimal policy ˆ π using poly (cid:0) d, H, 1 (cid:15) (cid:1) trajectories with probability 0 . 99 .
Proof of Theorem D.1.
The algorithm is the {+same as the one in Theorem C.
+}
We only need to change the analysis. Suppose we are learning at level h
and we have learned policies
π h +1 , . . .
, π H − 1 for level h + 1 , h + 2 , . . . , H − 1 , respectively. Because we use the roll-out policy π h +1 ◦ · · · ◦ π H − 1 , by Assumption 4.2 and the property of barycentric spanner, using the same argument in the proof of
Theorem C.1, we know with probability 1 − 0 .
01 /H , we can learn a policy π h with poly (cid:0) d, H, 1 (cid:15) (cid:1) samples such that for any s ∈ S h , we know π h is only sub-optimal by (cid:15) H from the ˜ π h where ˜ π h is the optimal policy at level h such that π h +1 ◦ · · · ◦ π H − 1 is the ﬁxed roll-out policy.
Now we can bound the sub-optimality of ˆ π (cid:44) π 0 ◦ · · · ◦ π H − 1 :
[Equation] The ﬁrst term is at least − (cid:15)H by our estimation bound, The second term is positive by deﬁnition of ˜ π 0 . We can just recursively apply this argument to obtain
[Equation]
[Table] [Table] (cid:15). [Figure]