Misspecified $Q$-Learning with Sparse Linear Function Approximation: Tight Bounds on Approximation Error

## Abstract

Abstract The recent work by Dong and Yang ( 2023 ) showed for misspecified sparse linear bandits, one can obtain an O ⁢ ( ϵ ) 𝑂 italic-ϵ O\left(\epsilon\right) italic_O ( italic_ϵ ) -optimal policy using a polynomial number of samples when the sparsity is a constant, where ϵ italic-ϵ \epsilon italic_ϵ is the misspecification error.
This result is in sharp contrast to misspecified linear bandits without sparsity, which require an exponential number of samples to get the same guarantee.
In order to study whether the analog result is possible in the reinforcement learning setting, we consider the following problem: assuming the optimal Q 𝑄 Q italic_Q -function is a d 𝑑 d italic_d -dimensional linear function with sparsity k 𝑘 k italic_k and misspecification error ϵ italic-ϵ \epsilon italic_ϵ , whether we can obtain an O ⁢ ( ϵ ) 𝑂 italic-ϵ O\left(\epsilon\right) italic_O ( italic_ϵ ) -optimal policy using number of samples polynomially in the feature dimension d 𝑑 d italic_d .
We first demonstrate why the standard approach based on Bellman backup or the existing optimistic value function elimination approach such as OLIVE (Jiang et al., 2017 ) achieves suboptimal guarantees for this problem.
We then design a novel elimination-based algorithm to show one can obtain an O ⁢ ( H ⁢ ϵ ) 𝑂 𝐻 italic-ϵ O\left(H\epsilon\right) italic_O ( italic_H italic_ϵ ) -optimal policy with sample complexity polynomially in the feature dimension d 𝑑 d italic_d and planning horizon H 𝐻 H italic_H .
Lastly, we complement our upper bound with an Ω ~ ⁢ ( H ⁢ ϵ ) ~ Ω 𝐻 italic-ϵ \widetilde{\Omega}\left(H\epsilon\right) over~ start_ARG roman_Ω end_ARG ( italic_H italic_ϵ ) suboptimality lower bound, giving a complete picture of this problem.

## 1 Introduction

Bandit and reinforcement learning (RL) problems in real-world applications, such as autonomous driving (Kiran et al., ), healthcare (Esteva et al., ), recommendation systems (Bouneffouf et al., ), and advertising (Schwartz et al., ), face challenges due to the vast state-action space. To tackle this, function approximation frameworks, such as using linear functions or neural networks, have been introduced to approximate the value functions or policies.
However, real-world complexities often mean that function approximation is agnostic; the function class captures only an approximate version of the optimal value function, and the misspecification error remains unknown. A fundamental problem is understanding the impact of agnostic misspecification errors in RL.

Prior works show even minor misspecifications can lead to exponential (in dimension) sample complexity in the linear bandit settings (Du et al., ; Lattimore et al., ) if the goal is to learn a policy within the misspecification error. That is, finding an $O(\epsilon)$-optimal action necessitates at least $\Omega(\exp(d))$ queries (or samples) to the environment, where $\epsilon$ is the misspecification error.
Recently, Dong and Yang () demonstrated that, by leveraging the sparsity structure of ground-truth parameters, one can overcome the exponential sample barrier in the linear bandit setting.
They showed that with sparsity $k$ in the ground-truth parameters, it is possible to learn an $O(\epsilon)$-optimal action with only $O\left(\left(d/\epsilon\right)^{k}\right)$ samples. In particular, when $k$ is a constant, their algorithm achieves a polynomial sample complexity guarantee.

A natural question is whether we can obtain a similar sample complexity guarantee in the RL setting.
This question motivates us to consider a more general question:

*Given a that the $Q^{*}$ function is a $d$-dimensional linear function with sparsity $k$ and misspecification error $\epsilon$, can we learn an $O\left(\epsilon\right)$-optimal policy using $\mathrm{poly}(d,1/\epsilon)$ samples, when $k$ is a constant?*

It turns out that by studying this question, we obtain a series of surprising results which cannot be explained by existing RL theories.

### 1.1 Our Contributions

In this paper, we propose an RL algorithm that can handle linear function approximation with sparsity structures and misspecification errors.
We also show that the suboptimality achieved by our algorithm is near-optimal, by proving information-theoretic hardness results.
Here we give a more detailed description of our technical contributions.

#### Our Assumption.

Throughout this paper, we assume the RL algorithm has access to a feature map where, for each state-action pair $(s,a)$, we have the feature $\phi(s,a)$ with $\|\phi(s,a)\|\leq 1$.
We make the following assumption, which states that there exists a sequence of parameters $\theta^{*}=(\theta^{*}_{0},\ldots,\theta^{*}_{H-1})$ where each $\theta^{*}_{h}\in\mathbb{S}^{d-1}$ is $k$-sparse, that approximates the optimal $Q$-function up to an error of $\epsilon$.

###### Assumption 1.1 .

There exists $\theta^{*}=(\theta^{*}_{0},\ldots,\theta^{*}_{H-1})$ where each $\theta^{*}_{h}\in\mathbb{S}^{d-1}$ is $k$-sparse, such that

$$ $|\langle\phi(s,a),\theta^{*}_{h}\rangle-Q^{*}(s,a)|\leq\epsilon$ $$

for all $h\in[H]$, all states $s$ in level $h$, and all actions $a$ in the action space.

We can approximate $\theta^{*}$ using an $\epsilon$-net of the sphere $\mathbb{S}^{k-1}$ and the set of all $k$-sized subset of $[d]$. Therefore, when $k$ is a constant, we may assume that each $\theta_{h}^{*}$ lies in a set with size polynomial in $d$.
Then, a natural idea is to enumerate all possible policies induced by the parameters in that finite set, and choose the one with the highest cumulative reward. However, although the number of parameter candidates in each individual level has polynomial size, the total number of induced policies would be exponential in $H$, and the sample complexity of such an approach would also be exponential in $H$.

###### Assumption 1.1 .

#### The Level-by-level Approach.

Note that when the horizon length $H=1$, the problem under consideration is equivalent to a bandit problem, which can be solved by previous approaches (Dong and Yang, ). For the RL setting, a natural idea is to first apply the bandit algorithm in Dong and Yang () on the last level, and then apply the same bandit algorithm on the second last level based on previous results and Bellman-backups, and so on.
However, we note that to employ such an approach, the bandit algorithm needs to provide a “for-all” guarantee, i.e., finding a parameter that approximates the rewards of all arms, instead of just finding a near-optimal arm.
On the other hand, existing bandit algorithms will amplify the approximation error of the input parameters by a constant factor, in order to provide a for-all guarantee.
Concretely, existing bandit algorithms can only find a parameter $\theta$ so that $\theta$ approximates the rewards of all arms by an error of $2\epsilon$.
As we have $H$ levels in the RL setting, the final error would be exponential in $H$, and therefore, such a level-by-level approach would result in a suboptimality that is exponential in $H$.

One may ask if we can further improve existing bandit algorithms, so that we can find a parameter $\theta$ that approximates the rewards of all arms by an error of $\epsilon$ plus a statistical error that can be made arbitrarily small, instead of $2\epsilon$.
The following theorem shows that this is information-theoretically impossible unless one pays a sample complexity proportional to the size of the action space.

###### Theorem 1.2 .

Under Assumption 1.1 with $d=k=1$, any bandit algorithm that returns an estimate $\hat{r}$ such that $|\hat{r}(a)-r(a)|<2\epsilon$ for all arms $a$ with probability at least $0.95$ requires at least $0.9n$ samples, where $n$ is the total number of arms.

Therefore, amplifying the approximation error by a factor of $2$ is not an artifact of existing bandit algorithms. Instead, it is information-theoretically impossible.

Geometric error amplification is a common issue in the design of RL algorithm with linear function approximation (Zanette et al., ; Weisz et al., ; Wang et al., , ).
It is interesting (and also surprising) that such an issue arises even when the function class has sparsity structures.

###### Theorem 1.2 .

#### Optimistic Value Function Elimination.

Another approach for the design of RL algorithm is based on optimistic value function elimination.
Such an approach was proposed by Jiang et al. () and was then generalized to broader settings (Sun et al., ; Du et al., ; Jin et al., ; Chen et al., ).
At each iteration of the algorithm, we pick the value functions in the hypothesis class with maximized value.
We then use the induced policy to collect a dataset, based on which we eliminate a bunch of value functions from the hypothesis class and proceed to the next iteration.

When applied to our setting, existing algorithms and analysis achieve a suboptimality that depends on the size of the parameter class, which could be prohibitively large.
Here, we use the result in Jiang et al. () as an example.
The suboptimality of their algorithm is $H\sqrt{M}\epsilon$, where $M$ is Bellman rank of the problem.
For our setting, we can show that there exists an MDP instance and a feature map that satisfies Assumption 1.1, whose induced Bellman rank is large.

###### Proposition 1.3 .

There exists an MDP instance $\mathcal{M}=(\mathcal{S},\mathcal{A},H,P,r)$ with $|\mathcal{A}|=2$, $H=\log d$, $|\mathcal{S}|=d-1$, with $d$-dimensional feature map $\phi$ satisfying Assumption 1.1 with $k=1$, such that its Bellman rank is $d$.

Given Proposition 1.3, if one naïvely applies the algorithm in Jiang et al. (), the suboptimality would be $O(H\sqrt{d}\epsilon)$ in our setting, which necessitates new algorithm and analysis.
In Section 4, we design a new RL algorithm whose performance is summarized in the following theorem.

###### Theorem 1.4 .

Under Assumption 1.1, with probability at least $1-\delta$, Algorithm 1
returns a policy with suboptimality at most $(4\epsilon_{\mathrm{stat}}+2\epsilon_{\mathrm{net}}+2\epsilon)H$ by taking $O(kd^{k}H^{3}\cdot\ln(dH/\epsilon_{\mathrm{net}}\delta)\cdot\epsilon_{\mathrm{
net}}^{-k}\epsilon_{\mathrm{stat}}^{-2})$ samples.

Here $\epsilon_{\mathrm{stat}}$ is the statistical error. Compared to the existing approaches, Theorem 1.4 achieves a much stronger suboptimality guarantee.
Later, we will also show that such a guarantee is near-optimal.

Although based on the same idea of optimistic value function elimination, our proposed algorithm differs significantly from existing approaches (Jiang et al., ; Sun et al., ; Du et al., ; Jin et al., ; Chen et al., ) to exploit the sparsity structure.
While existing approaches based on optimistic value function elimination try to find a sequence of parameters that maximize the value of the initial states, our new algorithm selects a parameter that maximizes the empirical roll-in distribution at all levels.
Also, existing algorithms eliminate a large set of parameters in each iteration, while we only eliminate the parameters selected during the current iteration in our algorithm.

These two modifications are crucial for obtaining a smaller suboptimality guarantee, smaller sample complexity, and shorter running time.
In existing algorithms, parameters at different levels are interdependent, i.e. the choice of parameter at level $h$ affects the choice of parameter at level $h+1$. Our new algorithm simplifies this by maintaining a parameter set for each level, so each level operates independently. Further, we can falsify and eliminate any parameter showing large Bellman error at any level $h$, since otherwise we would have found another parameter with larger induced value function at level $h+1$ to make the error small. Consequently, since we eliminate at least one parameter at each iteration, we obtain fewer iterations and enhanced sample complexity.

###### Proposition 1.3 .

###### Theorem 1.4 .

#### The Hardness Result.

One may wonder if the suboptimality guarantee can be further improved. In Section 3, we show that the suboptimality guarantee by Theorem 1.4 is near-optimal.

We first consider a weaker setting where the algorithm is not allowed to take samples, and the function class contains a single sequence of functions.
I.e., we are given a function $\hat{Q}:\mathcal{S}\times\mathcal{A}\to\mathbb{R}$, such that $|\hat{Q}(s,a)-Q^{*}(s,a)|\leq\epsilon$ for all $(s,a)\in\mathcal{S}\times\mathcal{A}$.

We show that for this weaker setting, simply choosing the greedy policy with respect to $\hat{Q}$, which achieves a suboptimality guarantee of $O(H\epsilon)$, is actually optimal.
To prove this, we construct a hard instance based on a binary tree. Roughly speaking, the optimal action for each level is chosen uniformly random from two actions $a_{1}$ and $a_{2}$. At all levels, the reward is $\epsilon$ if the optimal action is chosen, and is 0 0 otherwise.
For this instance, there exists a fixed $\hat{Q}$ that provides a good approximation to the optimal $Q$-function, regardless of the choice of the optimal actions.
Therefore, $\hat{Q}$ reveals no information about the optimal actions, and the suboptimality of the returned policy would be at least $\Omega(H\epsilon)$.
The formal construction and analysis and construction will be given in Section 3.1.

When the algorithm is allowed to take samples, we show that in order to achieve a suboptimality guarantee of $H/T\epsilon$, any algorithm requires $\exp(\Omega(T))$ samples, even when Assumption 1.1 is satisfied with $d=k=1$.
Therefore, for RL algorithms with polynomial sample complexity, the suboptimality guarantee of Theorem 1.4 is tight up to log factors.

To prove the above claim, we still consider the setting where $d=k=1$, i.e., a good approximation to the $Q$-function is given to the algorithm.
We also use a more complicated binary tree instance, where we divide all the $H$ levels into $H/T$ blocks, each containing $T$ levels. For each block, only one state-action pair at the last level has a reward of $\epsilon$, and all other state-action pairs in the block has a reward of 0 0. Therefore, the value of the optimal policy would be $H/T\cdot\epsilon$ since there are $H/T$ blocks in total. We further assume that there is a fixed function $\hat{Q}$, which provides a good approximation to the optimal $Q$-function universally for all instances under consideration.

Since $\hat{Q}$ reveals no information about the state-action pair with $\epsilon$ reward for all blocks, for an RL algorithm to return a policy with a non-zero value, it must search for a state-action pair with non-zero reward in a brute force manner, which inevitably incurs a sample complexity of $\exp(\Omega(T))$ since each block contains $T$ levels and $\exp(\Omega(T))$ state-action pairs at the last level.
The formal construction and analysis and construction will be given in Section 3.2.

### 1.2 Related Work

A series of studies have delved into MDPs that can be represented by linear functions of predetermined feature mappings, achieving sample complexity or regret that depends on the feature mapping’s dimension.
This includes linear MDPs, studied in Jin et al. (); Wang et al. (); Neu and Pike-Burke (), where both transition probabilities and rewards are linear functions of feature mappings on state-action pairs. Zanette et al. (, ) examines MDPs with low inherent Bellman error, indicating value functions that are almost linear with respect to these mappings. Another focus is on linear mixture MDPs (Modi et al., ; Jia et al., ; Ayoub et al., ; Zhou et al., ; Cai et al., ), characterized by transition probabilities that combine several basis kernels linearly. While these studies often assume known feature vectors, Agarwal et al. () investigates a more challenging scenario where both features and parameters of the linear model are unknown.

The literature has also witnessed a substantial surge of research in understanding how function general approximations can be applied efficiently in the reinforcement learning setting (Osband and Van Roy, ; Sun et al., ; Ayoub et al., ; Wang et al., ; Foster et al., ; Chen et al., , ; Zhong et al., ; Foster et al., ; Wagenmaker and Foster, ; Zhou and Gu, ; Jiang et al., ; Wang et al., ; Du et al., ; Jin et al., ; Kong et al., ; Dann et al., ; Zhong et al., ; Liu et al., ; Agarwal et al., ). To obtain good sample, error, or regret bounds, these approaches typically impose benign structures on values, models, or policies, along with benign misspecification. Amongst these works, Jiang et al. () is particularly related to our work as their elimination-based algorithm, OLIVE, can be directly applied to our setting. However, as mentioned in Section 1.1, the suboptimality guarantee of their algorithm is significantly worse than our result.

In another line of works, Du et al. (); Dong and Yang (); Lattimore et al. () specifically focuses on understanding misspecification in bandit and RL scenarios. Du et al. () illustrated that to find an $O(\epsilon)$-optimal policy in reinforcement learning with $\epsilon$-misspecified linear features, an agent must sample an exponential (in $d$) number of trajectories, applicable to both value-based and model-based learning. Relaxing this goal, Lattimore et al. () indicated that $\mathrm{poly}(d/\epsilon)$ samples could suffice to secure an $O(\epsilon\sqrt{d})$-optimal policy in a simulator model setting of RL, though achieving a policy with an error better than $O(\epsilon\sqrt{d})$ would still require an exponential sample size. Recently, Dong and Yang () introduced a solution, showing that incorporating structural information like sparsity in the bandit instance could address this issue, making it feasible to attain $O(\epsilon)$ with $O((d/\epsilon)^{k})$ sample complexity, which is acceptable when the sparsity $k$ is small. Another recent independent work (Amortila et al., ) also obtains a suboptimality guarantee of $O(H\epsilon)$. However, their result depends on a coverability assumption and uses a different technique called disagreement-based regression (DBR), which is distinct from our assumption and techniques.

## 2 Preliminaries

Throughout the paper, for a given positive integer $n$, we use $[n]$ to denote the set $\{0,1,2,\ldots,n-1\}$. In addition, $f(n)=O(g(n))$ denotes that there exists a constant $c>0$ such that $|f(n)|\leq c|g(n)|$. $f(n)=\Omega(g(n))$ denotes that there exists a constant $c>0$ such that $|f(n)|\geq c|g(n)|$.

### 2.1 Reinforcement Learning

Let $\mathcal{M}=\{\mathcal{S},\mathcal{A},H,P,r\}$ be a Markov Decision Process (MDP) where $\mathcal{S}$ is the state space,
$\mathcal{A}$ is the action space,
$H\in\mathbb{Z}_{+}$ is the planning horizon,
$P:\mathcal{S}\times\mathcal{A}\to\Delta(\mathcal{S})$ is the transition kernel which takes a state-action pair as input and returns a distribution over states,
$r:\mathcal{S}\times\mathcal{A}\to\Delta([0,1])$ is the reward distribution.
We assume $\sum_{h\in[H]}r_{h}\in[0,1]$ almost surely.
For simplicity, throughout this paper, we assume the initial state $s_{0}$ is deterministic.
To streamline our analysis, for each $h\in[H]$, we use $\mathcal{S}_{h}\subseteq\mathcal{S}$ to denote the set of states at level $h$, and assume $\mathcal{S}_{h}$ do not intersect with each other.

A policy $\pi:\mathcal{S}\to\mathcal{A}$ chooses an action for each state, and may induce a trajectory denoted by $(s_{0},a_{0},r_{0},\ldots,s_{H-1},a_{H-1},r_{H-1})$, where $s_{h+1}\sim P(s_{h},a_{h})$, $a_{h}=\pi(s_{h})$, and $r_{h}\sim r(s_{h},a_{h})$ for all $h\in[H]$. Given a policy $\pi$ and $h\in[H]$, for a state-action pair $(s,a)\in\mathcal{S}_{h}\times\mathcal{A}$, the $Q$-function and value function is defined as

$$ $Q^{\pi}(s,a)=\mathbb{E}\left[\sum_{h^{\prime}=h}^{H-1}r(s_{h^{\prime}},a_{h^{ \prime}})|s_{h}=s,a_{h}=a,\pi\right],V^{\pi}(s)=\mathbb{E}\left[\sum_{h^{ \prime}=h}^{H-1}r(s_{h^{\prime}},a_{h^{\prime}})|s_{h}=s,\pi\right].$ $$

We use $V^{\pi}$ to denote the value of the policy $\pi$, i.e., $V^{\pi}=V^{\pi}(s_{0})$.
We use $\pi^{*}$ to denote the optimal policy.
For simplicity, for a state $s\in\mathcal{S}$, we denote $V^{*}(s)=V^{\pi^{*}}(s)$, and for a state-action pair $(s,a)\in\mathcal{S}\times\mathcal{A}$, we denote $Q^{*}(s,a)=Q^{\pi^{*}}(s,a)$.
The suboptimality of a policy $\pi$ is defined as the difference between the value of $\pi$ and that of $\pi^{*}$, i.e. $V^{*}-V^{\pi}$.

For any sequence of $k$-sparse parameter $\theta=(\theta_{0},\ldots,\theta_{H-1})$, we define $\pi_{\theta}$ to be the greedy strategy based on $\theta$.
In other words, for each $h\in[H]$, a state $s\in\mathcal{S}_{h}$,
$\pi_{\theta}(s)=\mathrm{argmax}_{a\in\mathcal{A}}\langle\phi(s,a),\theta_{h}\rangle.$
For each $h\in[H]$, a parameter $\theta_{h}$, and a state $s\in\mathcal{S}_{h}$, we also write
$V_{\theta_{h}}(s)=\max_{a\in\mathcal{A}}\langle\phi(s,a),\theta_{h}\rangle$.

We will prove lower bounds for deterministic systems, i.e., MDPs with deterministic transition $P$ and deterministic reward $r$. In this setting, $P$ and $r$ can be regarded as functions rather than distributions. Since deterministic systems can be considered as a special case for general stochastic MDPs, our lower bounds still hold for general MDPs.

#### Interacting with an MDP.

An RL algorithm takes the feature function $\phi$ and sparsity $k$ as the input, and interacts with the underlying MDP by taking samples in the form of a trajectory.
To be more specific, at each round, the RL algorithm decides a policy $\pi$ and receives a trajectory $(s_{0},a_{0},r_{0},\ldots,s_{H-1},a_{H-1},r_{H-1})$ as feedback.
Here one trajectory corresponds to $H$ samples.
We define the total number of samples required by an RL algorithm as its sample complexity.
Our goal is to design an algorithm that returns a near-optimal policy while minimizing its sample complexity.

#### The Bandits Setting.

In this paper, we also consider the bandit setting, which is equivalent to an MDP with $H=1$.
Let $\mathcal{A}$ be the action space, and $r:\mathcal{A}\to\Delta([0,1])$ be the reward distribution.
At round $t$, the algorithm chooses an action $a_{t}\in\mathcal{A}$ and receives a reward $r_{t}\sim r(a_{t})$.
In this case, Assumption 1.1 asserts that there exists $\theta^{*}$, such that $\left|\langle\phi(a),\theta^{*}\rangle-\mathbb{E}[r(a)]\right|\leq\epsilon$ for all $a\in\mathcal{A}$.

## 3 Hardness Results

We prove our hardness results.
In Section 3.1, we prove that the suboptimality of any RL algorithm is $\Omega(H\epsilon)$ if the algorithm is not allowed to take samples. This serves as a warmup for the more complicated construction in Section 3.2, where we show that for any $T$ satisfying $1\leq 2T\leq H$, any RL algorithm requires $\exp(\Omega(T))$ samples in order to achieve a suboptimality of $\Omega(H/T\cdot\epsilon)$.

### 3.1 Warmup: Hardness Result for RL without Samples

We prove that the suboptimality of any RL algorithm without sample is $\Omega(H\epsilon)$.

###### Theorem 3.1 .

Given a MDP instance satisfying Assumption 1.1, the suboptimality of the policy returned by any RL algorithm is $\Omega(H\epsilon)$ with a probability of 0.99 if the algorithm is not allowed to take samples. This holds even when the dimension and sparsity satisfies $d=k=1$ and the underlying MDP is a deterministic system.

The formal proof of Theorem 3.1 is given in Section A.1 in the Appendix.
Below we give the construction of the hard instance together with an overview of the hardness proof.

###### Theorem 3.1 .

#### The Hard Instance.

Figure: Figure 1: Illustration of the hard instance for Theorem 3.1.
Refer to caption: extracted/5738609/fig/3.1_sparse.png

Our hardness result is based on a binary tree instance. There are $H$ levels of states, and level $h\in[H]$ contains $2^{h}$ distinct states. Thus we have $2^{H}-1$ states in total.
We use $s_{0},...,s_{2^{H}-2}$ to denote all the states, where $s_{0}$ is the unique state at level 0, and $s_{1},s_{2}$ are the states at level 1, etc.
Equivalently, $\mathcal{S}_{h}=\{s_{2^{h}-1},\ldots,s_{2^{h+1}-2}\}$. The action space $\mathcal{A}$ contains two actions, $a_{1}$ and $a_{2}$.
For each $h\in[H-1]$, a state $s_{i}\in\mathcal{S}_{h}$, we have $P(s_{i},a_{1})=s_{2i+1}$ and $P(s_{i},a_{2})=s_{2i+2}$.

For each $h\in[H]$, there exists an action $a_{h}^{*}\in\{a_{1},a_{2}\}$, such that $\pi^{*}(s)=a_{h}^{*}$ for all $s\in\mathcal{S}_{h}$.
Based on $a_{0}^{*},a_{1}^{*},\ldots,a_{H-1}^{*}$, for a state $s\in\mathcal{S}_{h}$, we define the reward function as $r(s,a)=\epsilon$ if $a=a_{h}^{*}$ and $r(s,a)=0$ otherwise. The corresponding Q-function is $Q^{*}(s,a)=(H-h)\epsilon$ if $a=a_{h}^{*}$ and $Q^{*}(s,a)=(H-h-1)\epsilon$ otherwise.

Now we define the $1$-dimensional feature function $\phi$.
For each $h\in[H]$, for all $(s,a)\in\mathcal{S}_{h}\times\mathcal{A}$, $\phi(s,a)=(H-h-1)\epsilon$.
Clearly, by taking $\theta^{*}=1$, Assumption 1.1 is satisfied for our $\mathcal{\phi}$.
This finishes the construction of our hard instance.

#### The Lower Bound.

Since the RL algorithm is not allowed to take samples, the only information that the algorithm receives is the feature function $\phi$.
However, $\phi$ is always the same no matter how we set $a_{0}^{*},a_{1}^{*},\ldots,a_{H-1}^{*}$, which means the RL algorithm can only output a fixed policy.
On the other hand, if $a_{h}^{*}$ is drawn uniformly at random from $\{a_{1},a_{2}\}$, for any fixed policy $\pi$, its expected suboptimality will be $H\epsilon/2$, which proves Theorem 3.1.
Our formal proof in Section A.1 of the Supplementary Material is based on Yao’s minimax principle in order to cope with randomized algorithms.

### 3.2 Hardness Result for RL with Samples

In this section, we show that for any $1\leq 2T\leq H$, any RL algorithm requires $\exp(\Omega(T))$ samples in order to achieve a suboptimality of $\Omega(H/T\cdot\epsilon)$.

###### Theorem 3.2 .

Given a RL problem instance satisfying Assumption 1.1 and $1\leq 2T\leq H$, any algorithm that returns a policy with suboptimality less than $H/(2T)\cdot\epsilon$ with probability at least $0.9$ needs least $0.1\cdot T\cdot 2^{T}$ samples.

In the remaining part of this section, we give an overview of the proof of Theorem 3.2. We first define the MULTI-INDEX-QUERY problem, which can be seen as a direct product version of the INDEX-QUERY problem introduced in Du et al. ().

###### Definition 3.3 .

(MULTI-INDEX-QUERY) In the $m\text{-INDQ}_{n}$ problem,
we have a sequence of $m$ indices $(i_{0}^{*},i_{1}^{*},\ldots,i_{m-1}^{*})\in[n]^{m}$.
In each round, the algorithm guesses a pair $(j,i)\in[m]\times[n]$ and queries whether $i=i_{j}^{*}$.
The goal is to output $(j,i^{*}_{j})$ for any $j\in[m]$, using as few queries as possible.

###### Definition 3.4 .

($\delta$-correct) For $\delta\in(0,1)$, we say a randomized algorithm $A$ is $\delta$-correct for $m\text{-INDQ}_{n}$ if for any $i^{*}=\{i^{*}_{j}\}_{j\in[m]}$, with probability at least $1-\delta$, ${A}$ outputs $(j,i_{j}^{*})$ for some $j$.

We first prove a query complexity lower bound for solving $m\text{-INDQ}_{n}$.

###### Lemma 3.5 .

Any $0.1$-correct algorithm that solves $m\text{-INDQ}_{n}$ requires at least $0.9n$ queries.

Similar to the proof of the query complexity lower bound of the INDEX-QUERY problem (Du et al., ), our proof is based on Yao’s minimax principle (Yao, ). See Section A.2 for the full proof.

Now we give the construction of our hard instance, together with the high-level intuition of our hardness proof.
For simplicity, here we assume $T$ is an integer that divides $H$.

Figure: Figure 2: Illustration of the hard instance for Theorem 3.2.
Refer to caption: extracted/5738609/fig/fig_3.2.png

###### Theorem 3.2 .

###### Definition 3.3 .

###### Definition 3.4 .

###### Lemma 3.5 .

#### The Hard Instance.

Again, our hardness result is based on a binary tree instance.
The state space, action space, and the transition kernel of our hard instance are exactly the same as the instance in Section 3.1.
Moreover, similar to the instance in Section 3.1, for each $h\in[H]$, there exists an action $a_{h}^{*}\in\{a_{1},a_{2}\}$, such that $\pi^{*}(s)=a_{h}^{*}$ for all $s\in\mathcal{S}_{h}$.

To define the reward function $r$, we first define an operator $P^{*}$, which can be seen as applying the transition kernel for multiple steps by following the optimal policy. For some $q\in[H/T]$, a state $s\in\mathcal{S}_{kT}$, and an integer $t\in[T]$, define $P^{*}(s,t)=s$ if $t=0$ and $P^{*}(s,t)=P(P^{*}(s,t-1),a_{qT+t-1}^{*})$ otherwise.
The reward function $r(s,a)$ is then defined to be $\epsilon$ if $s=P^{*}(s^{\prime},T-1)$ for some $s^{\prime}\in\mathcal{S}_{qT}$ where $q\in[H/T]$ and $a=a_{qT+T-1}^{*}$. For all other $(s,a)\in\mathcal{S}\times\mathcal{A}$, we define $r(s,a)=0$.
Accordingly, for each $(q,t)\in[H/T]\times[T]$,
$s\in\mathcal{S}_{qT+t}$, and $a\in\mathcal{A}$, we have
$Q^{*}(s,a)=(H/T-q)\epsilon$ if $s=P^{*}(s^{\prime},t)$ for some $s^{\prime}\in\mathcal{S}_{qT}$ and $a=a_{qT+t}^{*}$.
For all other $(s,a)\in\mathcal{S}\times\mathcal{A}$, we have $Q^{*}(s,a)=(H/T-q-1)\epsilon$.
This also implies that the value of the optimal policy is $H/T\cdot\epsilon$.

We define the $1$-dimensional feature function $\phi$ such that,
for each $(q,t)\in[H/T]\times[T]$,
$s\in\mathcal{S}_{qT+t}$ and $a\in\mathcal{A}$,
$\phi(s,a)=(H/T-q)\epsilon$.
Clearly, Assumption 1.1 is satisfied when taking $\theta^{*}=1$.
This finishes the construction of our hard instance. An illustration is given in Figure 2.

#### The Lower Bound.

Now we show that for our hard instance, if there is an RL algorithm that returns a policy with suboptimality less than $H/T\cdot\epsilon$, then there is an algorithm that solves $m\text{-INDQ}_{n}$ with $n=2^{T}$ and $m=H/T$.
Therefore, the correctness of Theorem 3.2 is implied by Lemma 3.5.

We first note that there exists a bijection between $\{a_{1},a_{2}\}^{T}$ and $[2^{T}]$. We use $g:[2^{T}]\to\{a_{1},a_{2}\}^{T}$ to denote such a bijection.
Given an instance of $m\text{-INDQ}_{n}$ with $n=2^{T}$ and $m=H/T$, for each $q\in[H/T]$,
we set
$(a_{qT}^{*},a_{qT+1}^{*},\ldots,a_{(q+1)T-1}^{*})=g(i_{q}^{*}),$
where $(i_{0}^{*},i_{1}^{*},i_{2}^{*},\ldots,i_{H/T-1}^{*})$ are the target indices in the instance of $m\text{-INDQ}_{n}$.
Each time the RL algorithm samples a trajectory $(s_{0},a_{0},r_{0},\ldots,s_{H-1},a_{H-1},r_{H-1})$, we make $H/T$ sequential queries $(0,i_{0}),(1,i_{1}),\ldots,(H/T-1,i_{H/T-1})$ to $m\text{-INDQ}_{n}$, where for each $q\in[H/T]$, $i_{q}$ is the unique integer in $[2^{T}]$ with
$g(i_{q})=(a_{qT},a_{qT+1},\ldots,a_{(q+1)T-1}).$
For each $h\in[H]$, we have $r_{h}=\epsilon$ if $h=(q+1)T-1$ and $i_{k}=i_{q}^{*}$ for some $k\in[H/T]$. Otherwise, we have $r_{h}=0$.

Suppose there is an RL algorithm that returns a policy $\pi$ with suboptimality less than $H/T\cdot\epsilon$, and since the value of the optimal policy is $H/T\cdot\epsilon$,
we must have $r_{h}=\epsilon$ for some $h\in[H]$ where $(s_{0},a_{0},r_{0},\ldots,s_{H-1},a_{H-1},r_{H-1})$ is the trajectory obtained by following the policy $\pi$. This implies the existence of $q\in[H/T]$ with
$g(i_{q}^{*})=(a_{qT},a_{qT+1},\ldots,a_{(q+1)T-1}).$
Therefore, if there is an RL algorithm that returns a policy with suboptimality less than $H/T\cdot\epsilon$ for our hard instance, then there is an algorithm for solving $m\text{-INDQ}_{n}$ with $n=2^{T}$ and $m=H/T$.

## 4 Main Algorithm

Figure: Algorithm 1 Elimination Algorithm for Finding the Optimal Hypotheses

#### Overview.

Here we give an overview of the design of Algorithm 1.

First, we approximate all candidate parameter $\theta$ with a finite set by creating a maximal $\epsilon_{\mathrm{net}}/2$-separated subset of the euclidean sphere $\mathbb{S}^{k-1}$, denoted by $\mathcal{N}^{k}$, and a set of all $k$-sized subset of $[d]$.
Then, for each $h\in[H]$, we maintain a set of parameter candidates $\mathcal{P}_{h}$.
Initially, $\mathcal{P}_{h}$ is set to be all parameters approximated by $\mathcal{N}^{k}$ and $k$-sized subset of $[d]$, i.e. $\mathcal{P}_{h}^{0}=\{\theta:\theta_{\mathcal{M}}\in\mathbb{S}^{k},|\mathcal{M
}|=k,\mathcal{M}\subseteq[d]\}$ where $\theta_{\mathcal{M}}$ is the $k$-dimension sub-vector of $\theta$ with indices corresponding to $\mathcal{M}$. The set $\mathcal{P}_{h}^{0}$ is then finite for all $h\in[H]$: $|\mathcal{P}_{h}^{0}|\leq(1+4/\epsilon_{\mathrm{net}})^{k}\cdot\binom{d}{k}$ (Dong and Yang, ).

During the execution of Algorithm 1, for all $h\in[H]$, we eliminate parameter candidates $\theta$ from $\mathcal{P}_{h}$ if we are certain that $\theta\neq\hat{\theta}_{h}^{*}$, where $\hat{\theta}^{*}=(\hat{\theta}_{0}^{*},\hat{\theta}_{1}^{*},\ldots,\hat{\theta
}_{H-1}^{*})$ is a sequence of parameters that is in $\mathcal{P}_{h}^{0}$ and is closest to the $\theta^{*}$ that satisfies Assumption 1.1, i.e. $\hat{\theta}^{*}_{h}=\mathrm{argmin}_{\theta\in\mathcal{P}_{h}^{0}}\|\theta^{*
}_{h}-\theta\|$.
Therefore, in Algorithm 1, we only consider $\theta=(\theta_{0},\theta_{1},\ldots,\theta_{H-1})$ if $\theta_{h}\in\mathcal{P}_{h}$ for all $h\in[H]$.

In the $t$-th iteration of the algorithm, we choose a parameter $\theta^{t}=(\theta^{t}_{0},\theta^{t}_{1},\ldots,\theta^{t}_{H-1})$ so that $\theta^{t}_{h}$ maximizes $\mathbb{E}[V_{\theta^{t}_{h}}(s_{h})]$ and $\theta^{t}_{h}\in\mathcal{P}_{h}$ for all $h\in[H]$.
We then collect $m$ trajectories to form a dataset $\mathcal{D}^{t}_{H}$ by following the policy induced by $\theta^{t}$.
Based on $\mathcal{D}^{t}_{H}$, we calculate the empirical Bellman error $\mathcal{\hat{E}}_{h}^{t}$ for each $h\in[H]$, which is the empirical estimate of the average Bellman error defined as follows.

###### Definition 4.1 (Average Bellman error) .

For a sequence of parameters $\theta^{t}=(\theta^{t}_{0},\theta^{t}_{1},\ldots,\theta^{t}_{H-1})$, the average Bellman error of $\theta^{t}$ is defined as

$$ $\displaystyle\mathcal{E}^{t}_{h}=\begin{cases}\mathbb{E}[\langle\phi(s_{h},a_{ h}),\theta^{t}_{h}\rangle-r(s_{h},a_{h})-V_{f^{t}_{h+1}}(s_{h+1})],~{}~{}& \text{for }h\in[H-1]\\ \mathbb{E}[\langle\phi(s_{H-1},a_{H-1}),\theta^{t}_{H-1}\rangle-r(s_{H-1},a_{H -1})],~{}~{}&\text{if }h=H-1.\end{cases}$ $$

Here, $(s_{0},a_{0},r_{0},\ldots,s_{H-1},a_{H-1},r_{H-1})$ is a trajectory obtained by following $\pi_{\theta^{t}}$.

Intuitively, the Bellman error at level $h$ measures the consistency of $\theta^{t}_{h}$ and $\theta^{t}_{h+1}$ for the state-action distribution induced by $\pi_{\theta^{t}}$. In each iteration of Algorithm 1, we check if $\mathcal{\hat{E}}_{h}^{t}$ is small for all $h\in[H]$. If so, the algorithm terminates and returns the policy $\pi_{\theta^{t}}$. Otherwise, for all levels $h\in[H]$ where $\mathcal{\hat{E}}_{h}^{t}$ is large, we eliminate $\theta^{t}_{h}$ from $\mathcal{P}_{h}$ and proceed to the next iteration.

Now we give the analysis of Algorithm 1.

###### Definition 4.1 (Average Bellman error) .

#### Sample Complexity.

To bound the sample complexity of Algorithm 1, it suffices to give an upper bound on the number of iterations, since in each iteration, the number of trajectories sampled by the algorithm is simply $H^{2}\cdot m=16H^{2}(k\ln((1+4/\epsilon_{\mathrm{net}}){d})+\ln(H/\delta))/(
\epsilon_{\mathrm{stat}}^{2})$.
The following lemma gives an upper bound on the number of iterations of Algorithm 1. The proof is given in Section B.1.

###### Lemma 4.2 .

For any MDP instance with horizon $H$ and satisfying Assumption 1.1 with sparsity $k$, Algorithm 1 runs for at most $(1+4/\epsilon_{\mathrm{net}})^{k}\binom{d}{k}H$ iterations.

###### Lemma 4.2 .

#### Suboptimality of the Returned Policy.

We now show that with probability at least $1-\delta$, the suboptimality of the returned policy is at most $(2\epsilon+2\epsilon_{\mathrm{net}}+4\epsilon_{\mathrm{stat}})H$.
First, we define a high probability event $E$, which we will condition on in the remaining part of the analysis.

###### Definition 4.3 .

Define $E$ as the event that $|\mathcal{E}_{h}^{t}-\mathcal{\hat{E}}_{h}^{t}|\leq\epsilon_{\mathrm{stat}}$ and $|\mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h})-\sum_{i\in[m]}V_{\theta}(s
_{h}^{i})|\leq\epsilon_{\mathrm{stat}}$ (where $s_{h}^{i}$ is from $\mathcal{D}_{h}^{t}$) for all iterations $t$, horizon $h\in[H]$, and parameter $\theta\in\mathcal{P}_{h}^{0}$.

###### Lemma 4.4 .

Event $E$ holds with probability at least $1-\delta$.

To prove Lemma 4.4, we first consider a fixed level $h$ and iteration $t$. Since the empirical Bellmen error $\mathcal{\hat{E}}_{h}^{t}$ is simply the empirical estimate of $\mathcal{E}^{t}_{h}$, and $\sum_{i\in[m]}V_{\theta}(s_{h}^{i})$ is simply an empirical estimate of $\mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h})$, applying the Chernoff-Hoeffding inequality respectively would suffice. Moreover, the number of iterations has an upper bound given by Lemma 4.2. Therefore, Lemma 4.4 follows by applying a union bound over all $h\in[H]$, $t\in[(1+4/\epsilon_{\mathrm{net}})^{k}\binom{d}{k}H]$ and parameter $\theta\in\mathcal{P}_{h}^{0}$.

We next show that, conditioned on event $E$ defined above, for the sequence of parameters $\theta^{*}=(\theta_{0}^{*},\theta_{1}^{*},\ldots,\theta_{H-1}^{*})$ that satisfies Assumption 1.1, we never eliminate $\hat{\theta}_{h}^{*}$ from $\mathcal{P}_{h}$, for all $h\in[H]$.

###### Lemma 4.5 .

Conditioned on event $E$ defined in Definition 4.3, for a sequence of parameters $(\theta_{0}^{*},\theta_{1}^{*},\ldots,\theta_{H-1}^{*})$ that satisfies Assumption 1.1, and their approximations $\hat{\theta}^{*}_{h}=\mathrm{argmin}_{\theta\in\mathcal{P}_{h}^{0}}\|\theta^{*
}_{h}-\theta\|$, during the execution of Algorithm 1, $\hat{\theta}_{h}^{*}$ is never eliminated from $\mathcal{P}_{h}$ for all $h\in[H]$.

To prove Lemma 4.5, the main observation is that, for $h\in[H-1]$ the average Bellman error induced by $\hat{\theta}_{h}^{*}$ and $\theta_{h+1}^{t}=\mathrm{argmax}_{\theta\in\mathcal{P}_{h+1}}\mathbb{E}_{s_{h+
1}}[V_{\theta}(s_{h+1})]$ is always upper bounded by $2(\epsilon+\epsilon_{\mathrm{net}})$, regardless of the distribution of $(s_{h},a_{h})$ (cf. Definition 4.1).
Conditioned on event $E$, the empirical Bellman error induced by $\hat{\theta}_{h}^{*}$ and $\theta_{h+1}^{t}$ is at most $2\epsilon+2\epsilon_{\mathrm{net}}+3\epsilon_{\mathrm{stat}}$. Similarly, the empirical Bellman error induced by $\hat{\theta}_{H-1}^{*}$ is at most $\epsilon+\epsilon_{\mathrm{net}}+\epsilon_{\mathrm{stat}}$. In Algorithm 1, we eliminate function $\theta_{h}^{t}$ only when the empirical Bellman error is larger than these (Line 15).
Thus, $\hat{\theta}_{h}^{*}$ is never eliminated.

We now show the suboptimality of the policy returned by Algorithm 1 is at most $(2\epsilon+2\epsilon_{\mathrm{net}}+4\epsilon_{\mathrm{stat}})H$.

###### Lemma 4.6 .

For any MDP instance satisfying Assumption 1.1, conditioned on event $E$ defined in Definition 4.3,
Algorithm 1 returns a policy $\pi$ satisfying
$V^{*}-V^{\pi}\leq(2\epsilon+2\epsilon_{\mathrm{net}}+4\epsilon_{\mathrm{stat}}
)H.$

To prove Lemma 4.6, we first recall the policy loss decomposition lemma (Lemma 1 in Jiang et al. ()), which states that, for a policy induced by a sequence of parameters $\theta=(\theta_{0},\theta_{1},\ldots,\theta_{H-1})$, $V_{\theta_{0}}(s_{0})-V^{\pi_{\theta}}$ is upper bounded by the summation of average Bellman error over all levels $h\in[H]$. When Algorithm 1 terminates, the empirical Bellman error must be small for all $h\in[H]$, and therefore, the average Bellman error is small by definition of the event $E$.
Moreover, in Line 5 of Algorithm 1, we always choose a parameter $\theta$ that maximizes $V_{\theta}(s_{0})$.
Since the sequence of functions $\hat{\theta}^{*}=(\hat{\theta}_{0}^{*},\hat{\theta}_{1}^{*},\ldots,\hat{\theta
}_{H-1}^{*})$ is never eliminated by Lemma 4.5,
we must have
$V_{\theta_{0}}(s_{0})\geq V_{\theta^{*}_{0}}(s_{0})\geq V^{*}-\epsilon-
\epsilon_{\mathrm{net}},$
which gives an upper bound on the suboptimality of the policy returned by Algorithm 1.
Combining Lemma 4.2, Lemma 4.4 and Lemma 4.6, we can prove Theorem 1.4.

###### Definition 4.3 .

###### Lemma 4.4 .

###### Lemma 4.5 .

###### Lemma 4.6 .

#### Implications.

We can think of the bandit setting as an MDP with $H=1$ and derive the following:

###### Corollary 4.7 .

For the bandit setting satisfying Assumption 1.1, Algorithm 1 returns an action $\hat{a}$ such that $r(a^{*})-r(\hat{a})\leq 2\epsilon+2\epsilon_{\mathrm{net}}+4\epsilon_{\mathrm{
stat}}$.

###### Remark 4.8 .

Here we compare Corollary 4.7 with the result in Dong and Yang ().
Scrutinizing the analysis in Dong and Yang (), the suboptimality achieved by their algorithm is $4\epsilon+\epsilon_{\mathrm{stat}}$, which is worse than our suboptimality guarantee.
On the other hand, the algorithm in Dong and Yang () also returns a parameter $\theta$ such that $|\langle\phi(a),\theta\rangle-r(a)|\leq 2\epsilon+\epsilon_{\mathrm{stat}}$ for all $a\in\mathcal{A}$ (which is the best possible according to Theorem 1.2), where our algorithm only returns a near-optimal action.

###### Corollary 4.7 .

###### Remark 4.8 .

## 5 Conclusion

We studied RL problem where the optimal $Q$-functions can be approximated by linear function with constant sparsity $k$, up to an error of $\epsilon$. We design a new algorithm with polynomial sample complexity, while the suboptimality of the returned policy is $O(H\epsilon)$, which is shown to be near-optimal by a information-theoretic hardness result.

Although the suboptimality guarantee achieved by our algorithm is near-optimal, the sample complexity can be further improved. As an interesting future direction, it would be interesting to design an RL algorithm with the same suboptimality guarantee, while obtaininig tighter dependece on the horizon length $H$.

## Appendix A Proofs in Section 3

### A.1 Proof of Theorem 3.1

###### Proof.

Consider an input distribution where $a^{*}_{h}$ is drawn uniformly random from $\{a_{1},a_{2}\}$. By Yao’s minimax principle, it suffices to consider the best deterministic algorithm, say ${A}$. Note that, since we have no sampling ability, a deterministic algorithm in this setting can be seen as a function that takes in feature function $\phi$ and returns a policy $\pi$. Also, for all instances supported by this distribution, their inputs $\phi$ are the same. Thus, the policy returned by ${A}$ is fixed. Denote the policy as $\pi$, and denote the trajectory following $\pi$ as $(s_{0},a_{0},r_{0},s_{1},a_{1},r_{1},\ldots,s_{H-1},a_{H-1},r_{h-1})$. The suboptimality of $\pi$ can be written as

$$ $\displaystyle V^{*}-V^{\pi}=\sum_{h=0}^{H-1}\epsilon\cdot\mathbb{I}[a^{*}_{h} \neq a_{h}]$ $$

Since $a_{h}$ is fixed and $a^{*}_{h}$ is drawn uniformly random from $\{a_{1},a_{2}\}$, $\mathbb{I}[a^{*}_{h}\neq a_{h}]=1$ with probability $1/2$. Thus, $(V^{*}-V^{\pi})/\epsilon$ is a binomial random variable, or $(V^{*}-V^{\pi})/\epsilon\sim B(H,1/2)$. The expectation of $(V^{*}-V^{\pi})$ is then $H\epsilon/2$, and its variance is $H\epsilon^{2}/4$.
Using Chebyshev inequality, with probability $0.99$, we have

$$ $\displaystyle V^{*}-V^{\pi}\geq\frac{1}{2}H\epsilon-5\epsilon\sqrt{H}=\Omega(H\epsilon)$ $$

for sufficiently large $H\geq 100$.
∎

###### Proof.

### A.2 Proof of Lemma 3.5

###### Proof.

Consider an input distribution where $i^{*}=(i^{*}_{0},i^{*}_{2},\ldots,i^{*}_{m-1})$ is drawn uniformly random from $[n]^{m}$. Let $c(i^{*},a)$ be the query complexity of running algorithm $a$ to solve the problem with correct indices $i^{*}$. Assume there exists a $0.1$-correct algorithm $\mathcal{A}$ for $m\text{-INDQ}_{n}$ that queries less than $0.9n$ times in the worst case. Then, using Yao’s minimax principle, there exists a deterministic algorithm $\mathcal{A}^{\prime}$ with $c(i^{*},\mathcal{A^{\prime}})<0.9n$ for all $i^{*}\in[n]^{m}$, such that

$$ $\displaystyle\mathbb{P}[\mathcal{A}^{\prime}\text{outputs $(j,i^{*}_{j})$ for some $j\in[m]$}]\geq 0.9.$ $$

We may assume that the sequence of queries made by $\mathcal{A}^{\prime}$ is fixed until it correctly guesses one of $i^{*}_{j}$. This is because $\mathcal{A}^{\prime}$ is deterministic, and the responses $\mathcal{A}^{\prime}$ receives are the same (i.e. all guesses are incorrect) until it correctly queries $(j,i^{*}_{j})$ for some $j$. Let $S=\{s_{1},\ldots,s_{k}\}$ be the sequence of first $k$ guesses made by $\mathcal{A}^{\prime}$, and let $I_{BAD}\subset[n]^{m}$ be a set of all possible $i^{*}$’s such that the guesses in $S$ are all incorrect. Denote the number of guesses on $\text{INDQ}_{n}^{(j)}$ in $S$ by $n_{j}$, then $n_{j}$’s are also fixed, and $\sum_{j\in[m]}n_{j}=k$. The size of $I_{BAD}$ then satisfies

$$ $\displaystyle|I_{BAD}|=\Pi_{j=0}^{m-1}(n-n_{j})\geq(n-k)n^{m-1}$ $$

Set $k$ as the worst-case query complexity of $\mathcal{A}^{\prime}$. Then, for all $i^{*}\in I_{BAD}$, the output of $\mathcal{A}^{\prime}$ is incorrect. Since $i^{*}$ is drawn uniformly random from $[n]^{m}$, the probability of $\mathcal{A}^{\prime}$ being incorrect is

$$ $\displaystyle\mathbb{P}[\mathcal{A}^{\prime}\text{ is incorrect}]=\frac{|I_{ BAD}|}{|[n]^{m}|}\geq\frac{(n-k)n^{m-1}}{n^{m}}>\frac{(n-0.9n)n^{m-1}}{n^{m}}> 0.1,$ $$

where in the second to last inequality we used $k<0.9n$.

However, this contradicts with the fact that $\mathbb{P}[\mathcal{A}^{\prime}\text{outputs $(j,i^{*}_{j})$ for some $j\in[m]
$}]\geq 0.9$. Thus, there does not exist a $0.1$-correct algorithm that solves the problem with less than $0.9n$ queries in the worst case.
∎

###### Proof.

### A.3 Proof of Theorem 3.2

###### Proof.

First, we prove our claim based on the assumption that $T$ is an integer that divides $H$. We can create the hard instance described in Section 3.2.

We reduce the problem to $H/T\text{-INDQ}_{2^{T}}$. Assume there exists an algorithm $\mathcal{A}$ that takes less than $0.9\cdot 2^{T}\cdot T$ samples, such that, with probability at least $0.9$, it outputs a policy $\pi$ with suboptimality $V^{*}-V^{\pi}<H/T\cdot\epsilon$. By definition, at round $i$, $\mathcal{A}$ interacts with the MDP instance by following a trajectory $(s_{0},a_{0}^{i},r_{0}^{i},...,s_{H-1}^{i},a_{H-1}^{i},r_{H-1}^{i})$. Based on $\mathcal{A}$, we create an algorithm $\mathcal{A}^{\prime}$ for $H/T\text{-INDQ}_{2^{T}}$ as follows. Consider $\mathcal{A}$ is querying the trajectory $(s_{0},a_{0}^{i},r_{0}^{i},...,s_{H-1}^{i},a_{H-1}^{i},r_{H-1}^{i})$. For each $q\in\{0,\ldots,H/T-1\}$, we can map $(a_{qT}^{i},\ldots,a_{(q+1)T-1}^{i})$ to an index in $[2^{T}]$ using the bijection $g$. Thus, we make a sequence of $H/T$ guesses, $\{(q,g(a_{qT}^{i},\ldots,a_{(q+1)T-1}^{i}))\}_{q=0}^{H/T-1}$, to the $H/T\text{-INDQ}_{2^{T}}$. If the guess $(q,g(a_{qT}^{i},\ldots,a_{(q+1)T-1}^{i}))$ is correct for some $q$, $\mathcal{A}$ receives a reward of $\epsilon$ at level $(q+1)T-1$, i.e. $r_{(q+1)T-1}^{i}=r(s_{(q+1)T-1}^{i},a_{(q+1)T-1}^{i})=\epsilon$. For all other state-action pairs in the trajectory, algorithm $\mathcal{A}$ receives zero reward. Since $\mathcal{A}$ takes less than $0.9\cdot 2^{T}\cdot T$ samples, it queries less than $0.9\cdot 2^{T}\cdot T/H$ trajectories, corresponding $0.9\cdot 2^{T}$ guesses to $H/T\text{-INDQ}_{2^{T}}$ in total. Recall that $\mathcal{A}$ outputs a policy $\pi$ with suboptimality $V^{*}-V^{\pi}<H/T\cdot\epsilon$ with probability at least 0.9. This means the sequence of guesses to $H/T\text{-INDQ}_{2^{T}}$ made by $\pi$ must have at least one of them being correct. Thus, $\mathcal{A}^{\prime}$ is a $0.1$-correct algorithm that solves $H/T\text{-INDQ}_{2^{T}}$ with less than $0.9\cdot 2^{T}$ guesses. However, by Lemma 3.5, such an algorithm does not exist, so $\mathcal{A}$ does not exist. We conclude that any algorithm that returns a policy with suboptimality less than $H/T\cdot\epsilon$ with probability at least $0.9$ needs to sample at least $0.9\cdot T\cdot 2^{T}$ times.

Now we consider when $T$ is not an integer that divides $H$. There are two cases. First, consider $T$ as an integer that does not divide $H$. Let $H^{\prime}=\lfloor H/T\rfloor\cdot T$, then we can make the same construction as above for the first $H^{\prime}$ horizons, and set the reward as zero for all the state-action pairs in the remaining $H-H^{\prime}$ levels. Because the rewards are the same for levels $H^{\prime}$ through $H-1$, different values of $\{\pi_{H^{\prime}},\ldots,\pi_{H-1}\}$ do not make a difference to $V^{\pi}$. Therefore, we only care about the first $H^{\prime}$ levels, so we can conclude from our above analysis that, any algorithm that returns a policy with suboptimality less than $H^{\prime}/T\cdot\epsilon=\lfloor H/T\rfloor\cdot\epsilon$ with probability at least $0.9$ needs to sample at least $0.9\cdot T\cdot 2^{T}$ times. For the second case, we consider when $T$ is not an integer. Let $T^{\prime}=\lfloor T\rfloor$, we can apply our conclusion from the previous case. That is, any algorithm that returns a policy with suboptimality less than $\lfloor H/T^{\prime}\rfloor\cdot\epsilon$ with probability at least $0.9$ needs to sample at least $0.9\cdot T^{\prime}\cdot 2^{T^{\prime}}$ times.
Since $2T\leq H$, we have $\lfloor H/T^{\prime}\rfloor\cdot\epsilon\geq\lfloor H/T\rfloor\cdot\epsilon
\geq\frac{H\epsilon}{2T}$. Also observing that $0.9\cdot T^{\prime}\cdot 2^{T^{\prime}}\geq 0.1\cdot T\cdot 2^{T}$, we finish the proof.
∎

###### Proof.

## Appendix B Proofs in Section 4

### B.1 Proof of Lemma 4.2

###### Proof.

In each iteration, we either output a policy or delete at least one function in $\mathcal{P}_{h}$ for some $h\in[H-1]$. Since there are
$\sum_{h\in[H-1]}\left(|\mathbb{S}^{k}|\times\binom{d}{k}\right)\leq(1+4/
\epsilon_{\mathrm{net}})^{k}\binom{d}{k}H$
functions in total initially, the algorithm is guaranteed to terminate within $(1+4/\epsilon_{\mathrm{net}})^{k}\binom{d}{k}H$ iterations.
∎

###### Proof.

### B.2 Proof of Lemma 4.4

###### Lemma B.1 (Deviation bound for $\mathcal{E}_{h}$ ) .

For fixed iteration $t$ and horizon $h\in[H]$,
with probability at least $1-\delta^{\prime}$, we have

$$ $|\mathcal{E}_{h}^{t}-\mathcal{\hat{E}}_{h}^{t}|\leq 4\sqrt{\frac{\ln 2-\ln \delta^{\prime}}{2m}}.$ $$

Hence, we can set $m>\frac{16(\ln 2-\ln(\delta^{\prime}))}{2\epsilon_{\mathrm{stat}}^{2}}$ to guarantee that $|\mathcal{E}_{h}^{t}-\mathcal{\hat{E}}_{h}^{t}|<\epsilon_{\mathrm{stat}}$

###### Proof.

Recall that the batch dataset $\mathcal{D}_{t}=\{(a_{0}^{i},r_{0}^{i},s_{1}^{i},...,a_{H-1}^{i},r_{H-1}^{i})
\}_{i=1}^{m}$ is collected by playing policy $\pi_{\theta^{t}}$. We define $\mathcal{\hat{E}}_{h}^{t,i}=\langle\phi(s^{i}_{h-1},a^{i}_{h}),\theta_{h}^{t}
\rangle-r(s^{i}_{h},a^{i}_{h})-V_{\theta^{t}_{h+1}}(s^{i}_{h+1})$, then $\mathcal{\hat{E}}_{h}^{t}=\frac{1}{m}\sum_{i=1}^{m}\mathcal{\hat{E}}_{h}^{t,i}$. By definition of $\mathcal{E}_{h}^{t}$, it satisfies

$$ $\displaystyle\mathcal{E}_{h}^{t}=\mathbb{E}[\mathcal{\hat{E}}_{h}^{t,i}].$ $$

Further, since $\langle\phi(s,a),\theta^{t}\rangle\in[-1,1]$ and $r(s,a)\in[0,1]$ for any state-action pair $(s,a)$, we have $\mathcal{\hat{E}}_{h}^{t,i}\in[-3,1]$. Thus, using Chernoff-Hoeffding inequality, we get, with probability $1-\delta^{\prime}$,

$$ $\displaystyle|\mathcal{E}_{h}^{t}-\mathcal{\hat{E}}_{h}^{t}|=\left|\frac{1}{m} \sum_{i=1}^{m}\left(\mathcal{\hat{E}}_{h}^{t,i}-\mathbb{E}[\mathcal{\hat{E}}_{ h}^{t}]\right)\right|\leq 4\sqrt{\frac{\ln 2-\ln\delta^{\prime}}{2m}}.$ $$

∎

###### Lemma B.2 (Deviation bound for $\mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h})$ ) .

For fixed iteration $t$, horizon $h\in[H]$, and parameter $\theta\in\mathcal{P}_{h}$,
with probability at least $1-\delta^{\prime}$, we have

$$ $\left|\mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h})-\frac{1}{m}\sum_{i\in [m]}V_{\theta}(s_{h}^{i})\right|\leq\sqrt{\frac{\ln 2-\ln\delta^{\prime}}{2m}}.$ $$

Hence, we can set $m>\frac{\ln 2-\ln(\delta^{\prime})}{2\epsilon_{\mathrm{stat}}^{2}}$ to guarantee that $|\mathcal{E}_{h}^{t}-\mathcal{\hat{E}}_{h}^{t}|<\epsilon_{\mathrm{stat}}$

###### Proof.

Recall that the batch dataset $\mathcal{D}_{h}^{t}=\{(s_{0}^{i},a_{0}^{i},r_{0}^{i},\ldots,s_{h-1}^{i},a_{h-1
}^{i},r_{h-1}^{i},s_{h}^{i})\}_{i=1}^{m}$ is collected by playing policy $\pi_{h}^{t}$. By definition, it satisfies

$$ $\displaystyle\mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h})=\mathbb{E}_{ \mathcal{D}_{h}^{t}}\left[\frac{1}{m}\sum_{i\in[m]}V_{\theta}(s_{h}^{i})\right].$ $$

Further, since $V_{\theta}(s)\in[0,1]$ for any state $s$, using Chernoff-Hoeffding inequality, we have with probability $1-\delta^{\prime}$,

$$ $\left|\mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h})-\frac{1}{m}\sum_{i\in [m]}V_{\theta}(s_{h}^{i})\right|\leq\sqrt{\frac{\ln 2-\ln\delta^{\prime}}{2m}}.$ $$

∎

###### Proof.

Define $E^{\mathcal{E}}_{t,h}$ to be the event

$$ $\displaystyle E^{\mathcal{E}}_{t,h}=\{|\mathcal{E}_{h}^{t}-\mathcal{\hat{E}}_{ h}^{t}|\leq\epsilon_{\mathrm{stat}}\},$ $$

then by Lemma B.1, $\mathbb{P}(E^{\mathcal{E}}_{t,h})\geq 1-\delta/(2(1+4/\epsilon_{\mathrm{net}})
^{2k}\binom{d}{k}^{2}H^{2})$ for all iterations $t\in[(1+4/\epsilon_{\mathrm{net}})^{k}\binom{d}{k}H]$ and horizon $h\in[H]$.

Define $E^{V}_{t,h,\theta}$ to be the event

$$ $\displaystyle E^{V}_{t,h,\theta}=\left\{\left|\mathbb{E}_{s_{h}\sim\pi_{h}^{t} }V_{\theta}(s_{h})-\frac{1}{m}\sum_{i\in[m]}V_{\theta}(s_{h}^{i})\right|\leq \epsilon_{\mathrm{stat}}\right\},$ $$

then by Lemma B.2, $\mathbb{P}(E^{V}_{t,h,f})\geq 1-\delta/(2(1+4/\epsilon_{\mathrm{net}})^{2k}
\binom{d}{k}^{2}H^{2})$ for all iterations $t\in[(1+4/\epsilon_{\mathrm{net}})^{k}\binom{d}{k}H]$, horizon $h\in[H]$, and $\theta\in\mathcal{P}_{h}$.

We can lower bound the probability of $E$ by union bound

$$ $\displaystyle\mathbb{P}(E)\geq$ $\displaystyle 1-\sum_{t}\sum_{h\in[H]}\mathbb{P}(\bar{E}^{\mathcal{E}}_{t,h})- \sum_{t}\sum_{h\in[H]}\sum_{\theta\in\mathcal{P}_{h}}\mathbb{P}(\bar{E}^{V}_{t ,h,\theta})\geq 1-\delta.$ $$

∎

###### Lemma B.1 (Deviation bound for ℰ h subscript ℰ ℎ \mathcal{E}_{h} caligraphic_E start_POSTSUBSCRIPT italic_h end_POSTSUBSCRIPT ) .

###### Proof.

###### Lemma B.2 (Deviation bound for 𝔼 s h ∼ π h t ⁢ V θ ⁢ ( s h ) subscript 𝔼 similar-to subscript 𝑠 ℎ superscript subscript 𝜋 ℎ 𝑡 subscript 𝑉 𝜃 subscript 𝑠 ℎ \mathbb{E}_{s_{h}\sim\pi_{h}^{t}}V_{\theta}(s_{h}) blackboard_E start_POSTSUBSCRIPT italic_s start_POSTSUBSCRIPT italic_h end_POSTSUBSCRIPT ∼ italic_π start_POSTSUBSCRIPT italic_h end_POSTSUBSCRIPT start_POSTSUPERSCRIPT italic_t end_POSTSUPERSCRIPT end_POSTSUBSCRIPT italic_V start_POSTSUBSCRIPT italic_θ end_POSTSUBSCRIPT ( italic_s start_POSTSUBSCRIPT italic_h end_POSTSUBSCRIPT ) ) .

###### Proof.

###### Proof.

### B.3 Proof of Lemma 4.5

###### Proof.

Let $\hat{\theta}^{*}=(\hat{\theta}^{*}_{0},\ldots,\hat{\theta}^{*}_{H-1})$ be the sequence of parameters such that, for each $h\in[H]$, the non-zero sub-vector of $\hat{\theta}^{*}_{h}$ is in $\mathcal{N}^{k}$ and is closest to the non-zero indices in $\theta^{*}$. Then, since $\mathcal{N}^{k}$ is $\epsilon_{\mathrm{net}}/2$-maximal, we have by Assumption 1.1 that

$$ $\displaystyle|\langle\phi(s,a),\hat{\theta}^{*}_{h}\rangle-Q^{*}(s,a)|\leq| \langle\phi(s,a),\theta^{*}_{h}\rangle-Q^{*}(s,a)|+|\langle\phi(s,a),\hat{ \theta}^{*}_{h}\rangle-\langle\phi(s,a),\theta^{*}_{h}\rangle|\leq\epsilon+ \epsilon_{\mathrm{net}},$ $$

for all $s$ in horizon $h$ and action $a\in\mathcal{A}$.

At iteration $t$, algorithm 1 deletes $\hat{\theta}^{*}_{h}$ if and only if one of the following two cases happens: (1) $h<H-1$, $\theta_{h}^{t}=\hat{\theta}^{*}_{h}$, and $\mathcal{\hat{E}}^{t}_{h}>2\epsilon+2\epsilon_{\mathrm{net}}+3\epsilon_{
\mathrm{stat}}$, (2) $h=H-1$, $\theta^{t}_{H-1}=\hat{\theta}^{*}_{h+1}$ and $\mathcal{\hat{E}}^{t}_{H-1}>\epsilon+\epsilon_{\mathrm{net}}+\epsilon_{\mathrm
{stat}}$.

For any state-action pair $(s_{h},a_{h})$ at level $h$ where $h\in[H-1]$, we observe by definition that

$$ $\displaystyle Q^{*}(s_{h},a_{h})-\mathbb{E}[r(s_{h},a_{h})]-\mathbb{E}[V^{*}_{ h+1}(s_{h+1})]=0.$ $$

Thus, we can upper bound $\mathcal{E}^{t}_{h}$ by

$$ $\displaystyle\mathcal{E}^{t}_{h}=$ $\displaystyle\mathbb{E}[\langle\phi(s_{h},a_{h}),\hat{\theta}^{*}_{h}\rangle-r (s_{h},a_{h})-V_{\theta_{h+1}}(s_{h+1})]$ $\displaystyle\leq$ $\displaystyle\mathbb{E}[(Q^{*}(s_{h},a_{h})+\epsilon+\epsilon_{\mathrm{net}})- r(s_{h},a_{h})-V_{\theta_{h+1}}(s_{h+1})]$ (By Assumption 1.1 ) $$

Here, $(s_{0},a_{0},r_{0},\ldots,s_{h},a_{h},r_{h})$ is a trajectory following $\pi_{\theta^{t}}$, and $s_{h+1}\sim P(s_{h},a_{h})$.

Recall that $\theta_{h}^{t}$ is chosen by taking the function that gives maximum empirical value at level $h$, so

$$ $\frac{1}{m}\sum_{i\in[m]}V_{\theta_{h}^{t}}(s_{h}^{i})\geq\frac{1}{m}\sum_{i \in[m]}V_{\hat{\theta}_{h}^{*}}(s_{h}^{i}),$ $$

where $s_{h}^{i}$ are taken from the dataset $\mathcal{D}_{h}^{t}$. Moreover, we are conditioned under event $E$, so we have

$$ $\displaystyle\mathbb{E}[V_{\theta^{*}_{h}}(s_{h})]-\mathbb{E}[V_{\theta_{h}^{t }}(s_{h})]\leq\left(\frac{1}{m}\sum_{i\in[m]}V_{\theta_{h}^{t}}(s_{h}^{i})+ \epsilon_{\mathrm{stat}}]\right)-\left(\frac{1}{m}\sum_{i\in[m]}V_{\theta_{h}^ {*}}(s_{h}^{i})-\epsilon_{\mathrm{stat}}\right)\leq 2\epsilon_{\mathrm{stat}}$ $$

for all $h$ and $t$.

For the first case, we consider $h\in[H-1]$. We have

$$ $\displaystyle\mathcal{E}_{h}^{t}\leq$ $\displaystyle\mathbb{E}[(Q^{*}(s_{h},a_{h})+\epsilon+\epsilon_{\mathrm{net}})- r(s_{h},a_{h})-V_{\theta^{t}_{h+1}}(s_{h+1})]$ $\displaystyle\leq$ $\displaystyle\mathbb{E}[Q^{*}(s_{h},a_{h})-r(s_{h},a_{h})-(V_{f^{*}_{h+1}}(s_{ h+1})-2\epsilon_{\mathrm{stat}})]+\epsilon+\epsilon_{\mathrm{net}}$ $\displaystyle=$ $\displaystyle\mathbb{E}[Q^{*}(s_{h},a_{h})-r(s_{h},a_{h})-f^{*}_{h+1}(s_{h+1}, \pi^{*}_{h+1}(s_{h+1}))]+\epsilon+\epsilon_{\mathrm{net}}+2\epsilon_{\mathrm{ stat}}$ (since $V_{f^{*}_{h+1}}=\max_{a\in\mathcal{A}}f^{*}_{h+1}(s_{h+1},a)$ ) $\displaystyle\leq$ $\displaystyle\mathbb{E}[Q^{*}(s_{h},a_{h})-r(s_{h},a_{h})-(Q^{*}(s_{h+1},\pi^{ *}_{h+1}(s_{h+1}))-\epsilon-\epsilon_{\mathrm{net}})]+\epsilon+\epsilon_{ \mathrm{net}}+2\epsilon_{\mathrm{stat}}$ (By Assumption 1.1 ) $\displaystyle=$ $\displaystyle\mathbb{E}[Q^{*}(s_{h},a_{h})-r(s_{h},a_{h})-Q^{*}(s_{h+1},\pi^{* }_{h}(s_{h+1}))]+2\epsilon+2\epsilon_{\mathrm{net}}+2\epsilon_{\mathrm{stat}}$ $\displaystyle=$ $\displaystyle 2\epsilon+2\epsilon_{\mathrm{net}}+2\epsilon_{\mathrm{stat}}.$ (since $Q^{*}(s_{h+1},\pi^{*}_{h+1}(s_{h+1}))=V_{h+1}^{*}(s_{h+1})$ ) $$

Given that we are conditioned under event $E$, $\mathcal{\hat{E}}^{t}_{h}-\mathcal{E}^{t}_{h}\leq\epsilon_{\mathrm{stat}}$ for all iteration $t$ and all horizon $h$. Thus, $\mathcal{\hat{E}}^{t}_{h}<2\epsilon+2\epsilon_{\mathrm{net}}+3\epsilon_{
\mathrm{stat}}$.

For the second case, we consider $h=H-2$. We have

$$ $\displaystyle\mathcal{E}^{t}_{H-1}\leq\mathbb{E}[(r(s_{H-1},a_{H-1})+\epsilon) -r(s_{H-1},a_{H-1})]=\epsilon+\epsilon_{\mathrm{net}},$ $$

because $H-1$ is the last level.

Again, given that we are conditioned under event $E$, we have $\mathcal{\hat{E}}^{t}_{H-1}-\mathcal{E}^{t}_{H-1}\leq\epsilon_{\mathrm{stat}}$, so $\mathcal{\hat{E}}^{t}_{H-1}<\mathcal{E}^{t}_{H-1}+\epsilon_{\mathrm{stat}}\leq
\epsilon+\epsilon_{\mathrm{net}}+\epsilon_{\mathrm{stat}}$.
∎

###### Proof.

### B.4 Proof of Lemma 4.6

###### Proof.

Algorithm 1 terminates and returns a policy at iteration $t$ only if $\theta^{t}$ satisfies the conditions in line 6, and by Lemma 4.5, there always exists a nice sequence of functions $\{\hat{\theta}_{h}^{*}\}_{h=0}^{H-1}$ that satisfies these conditions. Also, Lemma 4.2 indicates that the algorithm terminates within a finite number of iterations. Thus, algorithm 1 is guaranteed to terminate and return a policy.

Let the output policy be $\pi_{\theta^{t}}$, i.e. $\mathcal{\hat{E}}^{t}_{h}\leq 2\epsilon+2\epsilon_{\mathrm{net}}+3\epsilon_{
\mathrm{stat}}$ for all $h\in[H-2]$ and $\mathcal{\hat{E}}^{t}_{H-1}\leq\epsilon+\epsilon_{\mathrm{net}}+\epsilon_{
\mathrm{stat}}$. The loss of this policy can be bounded by

$$ $\displaystyle V^{*}(s_{0})-V^{\pi_{\theta_{t}}}(s_{0})=$ $\displaystyle Q^{*}(s_{0},\pi^{*}(s_{0}))-V^{\pi_{\theta^{t}}}(s_{0})$ $\displaystyle\leq$ $\displaystyle(\langle\phi(s_{0},\pi^{*}(s_{0})),\hat{\theta}^{*}_{0}\rangle+ \epsilon+\epsilon_{\mathrm{net}})-V^{\pi_{\theta^{t}}}(s_{0})$ (By Assumption 1.1 ) $\displaystyle\leq$ $\displaystyle(\langle\phi(s_{0},\pi_{\theta^{t}_{0}}(s_{0})),\theta^{t}_{0} \rangle+\epsilon+\epsilon_{\mathrm{net}})-\mathbb{E}[\sum_{h=0}^{H-1}r(s_{h},a _{h})]$ (since $\theta^{t}_{0}$ is chosen by taking the maximum) $\displaystyle=$ $\displaystyle\epsilon+\epsilon_{\mathrm{net}}+\mathbb{E}\Big{[}\sum_{h=0}^{H-1 }\langle\phi(s_{h},a_{h}),\theta^{t}_{h}\rangle-r(s_{h},a_{h})-\langle\phi(s_{ h+1},a_{h+1}),\theta^{t}_{h+1}\rangle\Big{]}$ (telescoping sum) $\displaystyle=$ $\displaystyle\epsilon+\epsilon_{\mathrm{net}}+\sum_{h=0}^{H-1}\mathbb{E}\Big{[ }\langle\phi(s_{h},a_{h}),\theta^{t}_{h}\rangle-r(s_{h},a_{h})-\langle\phi(s_{ h+1},a_{h+1}),\theta^{t}_{h+1}\rangle\Big{]}$ (linearity of expectation) $\displaystyle=$ $\displaystyle\epsilon+\epsilon_{\mathrm{net}}+\sum_{h=0}^{H-1}\mathcal{E}^{t}_ {h}\leq\epsilon+\epsilon_{\mathrm{net}}+\sum_{h=0}^{H-1}(\mathcal{\hat{E}}^{t} _{h}+\epsilon_{\mathrm{stat}})\leq(2\epsilon+2\epsilon_{\mathrm{net}}+4 \epsilon_{\mathrm{stat}})H$ $$

∎

###### Proof.

## Appendix C Additional Proofs

### C.1 Proof of Theorem 1.2

###### Proof.

We construct a hard instance as follows.
For each $a\in\mathcal{[}n]$, define $\phi(a)=\epsilon$. Let $\theta^{*}$ be randomly selected from $\{-1,1\}$, and let $a^{*}$ is uniformly chosen from $\mathcal{A}$. The reward $r$ is deterministic and is defined as

$$ $\displaystyle r(a)=\begin{cases}2\theta^{*}\epsilon&\text{ if }a=a^{*}\\ 0&\text{otherwise}.\end{cases}$ $$

Therefore $|r(a)-\theta^{*}\cdot\phi(a)|\leq\epsilon$ holds true for all actions $a\in\mathcal{A}$.

By Yao’s minimax principle, it suffices to consider deterministic algorithms. Let $A$ be a deterministic algorithm that, by taking less than $0.9n$ samples, returns a $\hat{r}$ with $|\hat{r}(a)-r(a)|<2\epsilon$ for all $a\in\mathcal{A}$ with probability at least $0.95$. We can say the sequence of actions made by $A$ is fixed until it receives a reward $r(a_{t})\neq 0$ at some round $t$. This is because $A$ is deterministic, and the responses $A$ receives are the same (i.e. all actions have reward 0 0) until it queries $a^{*}$. Let $S=(a_{1},\ldots,a_{t})$ be the sequence of actions made by $A$. Let $\mathcal{A}_{BAD}\subset\mathcal{A}$ be the set of actions that are not in S. We have

$$ $\displaystyle\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}]=$ $\displaystyle\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}|a^ {*}\in\mathcal{A}_{BAD}]\mathbb{P}[a^{*}\in\mathcal{A}_{BAD}]$ $\displaystyle+\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}|a ^{*}\notin\mathcal{A}_{BAD}]\mathbb{P}[a^{*}\notin\mathcal{A}_{BAD}]$ $\displaystyle<$ $\displaystyle\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}|a^ {*}\in\mathcal{A}_{BAD}]\mathbb{P}[a^{*}\in\mathcal{A}_{BAD}]$ $\displaystyle+(1-\mathbb{P}[a^{*}\in\mathcal{A}_{BAD}])$ $$

Since $t<0.9n$ and $a^{*}$ is chosen uniformly random from $\mathcal{A}$, the probability that $a^{*}\in\mathcal{A}_{BAD}$ is

$$ $\mathbb{P}[a^{*}\in\mathcal{A}_{BAD}]=\frac{|\mathcal{A}_{BAD}|}{|\mathcal{A}| }>\frac{1-0.9n}{n}=0.1.$ $$

When $a^{*}\in\mathcal{A}_{BAD}$, the output of our deterministic algorithm must be fixed. We denote such output by $r^{\prime}$. Consider a fixed $a^{*}\in\mathcal{A}_{BAD}$, if we have $|r^{\prime}(a^{*})-2\epsilon|<2\epsilon$, then $r^{\prime}(a^{*})\in(0,4\epsilon)$, and $|r^{\prime}(a^{*})-(-2\epsilon))|>2\epsilon$. Similarly, if we have $|r^{\prime}(a^{*})-(-2\epsilon)|<2\epsilon$, then $|r^{\prime}(a^{*})-2\epsilon|>2\epsilon$. Since $\theta^{*}$ is chosen uniformly random in $\{-1,1\}$, we know $r(a^{*})$ is chosen uniformly random in $\{-2\epsilon,2\epsilon\}$. Thus,

$$ $\displaystyle\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}|a^ {*}\in\mathcal{A}_{BAD}]\leq\mathbb{P}[|\hat{r}(a^{*})-r(a^{*})|<2\epsilon|a^{ *}\in\mathcal{A}_{BAD}]=0.5.$ $$

We have

$$ $\displaystyle\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}]<$ $\displaystyle 0.5\cdot\mathbb{P}[a^{*}\in\mathcal{A}_{BAD}]+(1-\mathbb{P}[a^{* }\in\mathcal{A}_{BAD}])$ $\displaystyle<$ $\displaystyle 0.5\cdot 0.1+0.9=0.95.$ $$

However, by our assumption on algorithm $A$, we have $\mathbb{P}[|\hat{r}(a)-r(a)|<2\epsilon,\forall a\in\mathcal{A}]>0.95$.
∎

###### Proof.

## Appendix D Bellman Rank

The following definition of the general average Bellman error is helpful for our proofs in this section.

###### Definition D.1 .

Given any policy $\pi:\mathcal{S}\rightarrow\mathcal{A}$, feature function $\phi:\mathcal{S}\times\mathcal{A}\rightarrow\mathbb{R}^{d}$ and
a sequence of parameters $\theta=(\theta_{0},\ldots,\theta_{H-1})$, the average Bellman error of $\theta$ under roll-in policy $\pi$ at level $h$ is defined as

$$ $\displaystyle\mathcal{E}_{h}(\theta,\pi)=\mathbb{E}[\langle\phi(s_{h},a_{h}), \theta_{h}\rangle-r_{h}-\max_{a\in\mathcal{A}}\langle\phi(s_{h+1},a),\theta_{h +1}\rangle].$ $$

Here, $(s_{0},a_{0},r_{0},\ldots,s_{h},a_{h},r_{h})$ is a trajectory by following $\pi$, and $s_{h+1}\sim P(s_{h},a_{h})$.

###### Definition D.2 (Bellman Rank) .

For a given MDP $\mathcal{M}$, we say that our
parameter space $\mathcal{F}=\{\theta\in\mathbb{R}^{d}:\theta\text{ is $k$-sparse, }\|\theta\|_
{2}=1\}$
has a Bellman rank of dimension $d$ if, for all $h\in[H]$, there exist functions $X_{h}:\mathcal{F}\rightarrow\mathbb{R}^{d}$ and $Y_{h}:\mathcal{F}\rightarrow\mathbb{R}^{d}$ such that for all $\theta,\theta^{\prime}\in\mathcal{F}$,

$$ $\mathcal{E}_{h}(\theta,\pi_{\theta^{\prime}})=\langle X_{h}(\theta),Y_{h}( \theta^{\prime})\rangle.$ $$

For each $h\in[H]$, define $W_{h}\in\mathbb{R}^{d\times d}$ as the Bellman error matrix at level $h$, where the $i,j$-th index of $W_{h}$ is $\mathcal{E}_{h}(\theta_{i},\pi_{\theta_{j}})$. Then, the Bellman rank of $\mathcal{F}$ is the maximum among the rank of the matrices $\{W_{h}\}_{h\in[H]}$.

We prove Proposition 1.3.

###### Proof.

We again construct a deterministic MDP instance with binary trees. For simplicity, we assume $d$ is a power of $2$, and we construct the instance with horizon $H=\log d$. Thus, we have $|\mathcal{S}|=2^{H}-1=d-1$ states. We also assume the sparsity is $k=1$, so the parameter space $|\mathcal{F}|=d$. The rest details of state space, action space, and the transition kernel are exactly the same as in Section 3.1.

The reward is defined as $r(s,a_{1})=r(s,a_{2})=\epsilon$ for $s\in\mathcal{S}_{H-1}$, and $r(s,a)=0$ for all other state-action pairs. Correspondingly, the $Q$-function satisfies that $Q^{*}(s,a)=\epsilon$ for all $(s,a)\in\mathcal{S}\times\mathcal{A}$.

For feature at horizon $h\in[H]$, for $j\geq 2^{h+1}$, we define the $j$-th index of $\phi(s,a)$ as $\phi(s,a)[j]=j\epsilon$ for all $(s,a)\in\mathcal{S}_{h}\times\mathcal{A}$.
For $i\in[2^{h+1}]$ and $i$ is even, $\phi(s_{2^{h}-1+i},a_{1})[i]=\epsilon$ and $\phi(s_{2^{h}-1+i},a_{2})[i]=0$. If $i\in[2^{h+1}]$ and $i$ is odd, then $\phi(s_{2^{h}-1+i},a_{1})[i]=0$ and $\phi(s_{2^{h}-1+i},a_{2})[i]=\epsilon$. We also define $\phi(s,a)[i]=0$ for all other state-action pairs.

Notice that, for any $h\in[H]$ and $i\in[2^{h+1}]$, we have can let $\theta$ be the one-hot vector with $i$-th index being $1$, then $|\langle\phi(s,a),\theta\rangle-Q^{*}(s,a)|\leq\epsilon$ for all $(s,a)\in\mathcal{S}_{h}\times\mathcal{A}$, so our construction satisfies assumption 1.1.

Clearly, for each pair $(s,a)\in\mathcal{S}_{H-1}\times\mathcal{A}$, we can find $\theta=(\theta_{0},\ldots,\theta_{H-1})$ such that the trajectory created by following $\pi_{\theta}$, denoted by $(s_{0},a_{0},r_{0},\ldots,s_{H-1},a_{H-1},r_{H-1})$, satisfies $s_{H-1}=s$ and $a_{H-1}=a$.

Consider two parameter candidates $\theta,\theta^{\prime}$. Let $(s_{H-1},a_{H-1})$ be the state and action at level $H-1$ when following $\pi_{\theta^{\prime}}$. Since we are considering deterministic MDP, we can calculate the Bellman error at level $H-1$ as follows

$$ $\displaystyle\mathcal{E}_{H-1}(\theta,\pi_{\theta^{\prime}})=$ $\displaystyle\langle\phi(s_{H-1},a_{H-1}),\theta_{H-1}\rangle-r(s_{H-1},a_{H-1 })-\max_{a\in\mathcal{A}}\langle\phi(s_{H},a),\theta_{H}\rangle$ $\displaystyle=$ $\displaystyle\langle\phi(s_{H-1},a_{H-1}),\theta_{H-1}\rangle-\epsilon$ (since $H-1$ is the last level) $\displaystyle=$ $\displaystyle\begin{cases}0&\text{, if $\theta_{H-1}=\theta_{H-1}^{\prime}$}\\ -\epsilon&\text{, if $\theta_{H-1}\neq\theta_{H-1}^{\prime}$}.\end{cases}$ $$

Here, the last equality holds because, for each $\theta_{H-1}$, there is only one unique $(s,a)\in\mathcal{S}_{H-1}\times\mathcal{A}$ such that $\langle\phi(s,a),\theta_{H-1}\rangle=\epsilon$.

Thus, at level $H-1$, a submatrix of the Bellman error matrix, $W\in\mathbb{R}^{d\times d}$, satisfies

$$ $\displaystyle W_{ij}=\mathcal{E}_{H-1}(\theta_{i},\pi_{\theta_{j}})=\begin{ cases}0&\text{, if $i=j$}\\ -\epsilon&\text{, otherwise.}\end{cases}$ $$

In other words, $W=\epsilon(I-J)$ where $I$ is the identity matrix and $J$ is a $d\times d$ matrix with all $1$s. Define matrix $W^{\prime}=\frac{1}{\epsilon}(I-1/(n-1)J)$, then we have

$$ $\displaystyle WW^{\prime}$ $\displaystyle=(I-J)(I-\frac{1}{n-1}J)$ $\displaystyle=I-\frac{1}{n-1}J-J+\frac{n}{n-1}J=I.$ $$

This means $W^{\prime}$ is the inverse matrix of $W$, and $W$ is full rank. Thus, the Bellman rank is at least $d$.
∎

###### Definition D.1 .

###### Definition D.2 (Bellman Rank) .

###### Proof.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1) I don't understand the word 'MDP without sample.' Without any trajectory, how could a learning agent learn something? You mean, 'without learning' the error is bounded by $\Omega(H\epsilon)$?

2) Also, it is interesting that this algorithm eliminates the 'most promising candidate' first. In bandits, the elimination eliminates all the suboptimal candidates that show less upper bound than the largest lower bound (eliminate an arm i which is max_j LCB_t(j) > UCB_t (i)). Why does this difference happen?

3) So what is the optimal size of the parameters, $\epsilon_{net}$ and $\epsilon_{stat}$? I guess they also should be in the scale of $\epsilon$. 

3-1) Also just to clarify, what is $\epsilon$-optimal in here, does this mean $V^* - V(\pi) \leq \epsilon$? If so, according to your final result (Lemma 4.4), for the error $\epsilon'$, one should set $\epsilon/H$. This means now $m$ is proportional to $H^2$ too and the overall sample complexity also should include $H^2$, I believe. 

3-2) In that sense, the line 438 is very confusing. Why it is $H^2 \cdot m$, including the $\epsilon_{stat}^2$ in the denominator? You repeat $m$ samplings for $H$ iterations. Shouldn't it be $H\cdot m$?
soundness: 3
strengths: 1) Clarity & Soundness: Their writing was clear on these points. 
- They clearly stated their novelty and significant difference from the misspecified bandit algorithm proposed by Dong & Yang.
- They tried to demonstrate how they set the lower bound instance by high-level, but an explicit explanation throughout Section 3, with a nice figure. (and also the main difference from Du et al. 2020)
- The algorithm itself is also quite simple - it follows a traditional method of elimination algorithms, and thanks to the detailed explanation, I could easily get a sketch about how the proof goes on. The technique is also using some simple Hoeffding's inequality. 

2) Significance & Novelty: Even though their results are clearly written and easy to understand, many of their results are quite fresh and counter-intuitive. One cannot extend bandit algorithms in this case was quite interesting indeed.
summary: The authors found a misspecified sparse linear bandit algorithm based on elimination. They first proved that the traditional approaches such as OLIVE work suboptimally in this environment, and also a naive extension from the previous bandit work [Dong & Yang, 2023] fails. After that, the authors propose a lower bound from the MDP without sample to RL with sample, using the INDQ problem as a mediator. This lower bound matches with the upper bound of their algorithm, showing that their algorithm has a near-optimal rate.
weaknesses: 1) Computationally intractable. If I understood correctly, they use an $\epsilon$-net on the candidates for $\theta_h$ - $P_h^0$ starts from all possible $k$-sparse vectors. After that, for each iteration, this algorithm is searching for argmax over all candidates. Also, eventually they proposed an algorithm that provides $\epsilon$-optimal.

2) Even though they tried to show their process transparently, there are some parts that I cannot understand. Please check the 'Questions' below.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 4
questions: Overall, I do think the results are interesting and not necessarily obvious a-priori---they certainly piqued my curiosity. Some questions I was inspired to think about based on the results are as follows:

* Can we get similar guarantees beyond linear function approximation? My thought would be that if we assume that Q*_h is eps-approximately realizable by a class \mathcal{F}_h, then perhaps we can get H*eps error while paying for roughly max_h{Covering-Number(\cF_h, eps)} in the sample complexity using a generalization of the algorithm. If so, this would suggest that the linear structure is actually not that important.

* Have the authors thought about whether there exists an algorithm that achieves the H/T*eps error vs exp(T) sample complexity tradeoff in the lower bound?

* Is there any hope of achieving just d^{k} sample complexity instead of (d/eps)^k sample complexity?
soundness: 4
strengths: This paper makes a reasonable contribution to the theory of reinforcement learning. Guarantees in the linearly (approximately) realizable setting the authors consider are non-trivial and often somewhat surprising, so I think this paper makes an interesting contribution by filling in another piece of the landscape.
summary: This paper considers the problem of online reinforcement learning with linear function approximation. It is well known if that in the presence of epsilon-misspecification (in the sense that Q* is eps-approximately linear), the best one can hope for is a an error guarantee that scales with \sqrt{d}*eps, where $d$ is the feature dimension, even in the bandit setting where $H=1$. The main result in this paper is to show that if we additionally assume that the optimal parameter is $k$ sparse, it is possible to improve upon this guarantee. In particular:

* 1) The author show that it is possible to achieve an error guarantee that scales as H*eps (with no dependence on dimension), albeit with sample complexity and runtime scaling as roughly (d/eps)^{k}.

* 2) The authors show that the error guarantee above cannot be improved further, in the sense that achieving H/T*eps for any T requires exp(T) sample complexity.
weaknesses: The main drawbacks preventing me from giving a higher score are as follows:

* On the upper bound side, the significance of the algorithmic techniques is somewhat narrow. Concretely, the authors consider a setting where we have a separate parameter $\theta*_h$ for each step $h\in[H]$. If we instead assume that there is a shared parameter $\theta*$ for all steps $h$, then I believe that simply enumerating over an epsilon-net for the parameter space and trying each policy one-by-one would be sufficient to achieve the approximation and sample complexity guarantees the authors get. So, the only reason why a non-trivial algorithm is required at all is because there is no parameter sharing across the steps $h$. Indeed, without parameter sharing, an epsilon-net would have size at least 2^H and lead to 2^H sample complexity, so the authors' contribution can be viewed as removing this exponential dependence on $H$ for this setting.

* The problem setting in the paper is fairly niche, and will probably only be interesting/compelling to research working on core RL theory. Broader impact is unclear.

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 2
questions: Does the proposed method exploit the sparseness except through the cardinality of the epsilon net?
soundness: 3
strengths: - An interesting work on the RL learnability under limited knowledge of environment.
- The theoretical results are strong in the sense that almost-matching upper and lower bounds are presented.
summary: In this work, the authors study RL where Q-function is sparse codable up to $\epsilon$ error.
Their main contributions are
i) showing the existence of a hard instance where achieving suboptimality less than $H \epsilon / C$ requires sample complexity exponential to C,
ii) establishing a theoretical method achieving suboptimality of $2H \epsilon + o(1)$ with polynomial sample.
weaknesses: - The sample complexity grows exponentially to the sparseness $k$, which is unavoidable with the present set of assumptions but undesirable in practice.
- The construction of the hard instance depends on exponentially large state space. This is not uncommon in the theoretical analysis, but worth discussing if similar results hold with smaller state space.

Some mathematical definitions are confusing: 
- Def of $\Delta(\cdot)$ lacking?
- Why parameters restricted on sphere? (I suspect the authors are confusing sphere and ball)
- How s_0 is sampled? Is it fixed?

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: Do the authors have a guess whether the exponential dependency on $k$ in the sample complexity is necessary?
soundness: 3
strengths: The error guarantee of the algorithm proposed is shown to be optimal though it has a surprising linear scale with the number of steps $H$. The lower bound argument is quite interesting. They first demonstrate a suboptimality gap assuming that the RL algorithm is given no samples using hard instances based on binary trees. They further show that the instance can be modified so that the reward-signal is exponentially sparse. Hence, the algorithm must search the space in a brute-force manner to extract useful information.
summary: $\textbf{Background}$ In Q-learning with function approximation, it is assumed that the optimal Q-value function can be written as a linear function of the feature of each state, action pair, i.e., $Q^*(s, a) = <  \theta^*,  \psi(s, a)>$.
In the misspecified setting, the assumption is relaxed to be such that the optimal Q-value function is $\epsilon$-close to some linear function of the features, i.e., $| Q^* - <  \theta^*,  \psi(s, a)> | < \epsilon $.
Unfortunately, it has been shown that exponentially many samples are required in the misspecified setting even when the MDP only has $H=1$ step, which simplifies to the linear bandit setting.
Yet, a prior work shows that the hardness result can be circumvented in the linear bandit setting provided that the optimal secrete vector $\theta^*$ is further assumed to be $k$-sparse for some constant $k$. In such cases, the sample complexity for linear bandit has been improved to $O( (d/\epsilon)^k )$.

$\textbf{Contribution of this work}$ In this work, it has been shown results with a similar favor hold for general multi-step Q-learning as well. In particular, they give an algorithm that uses polynomially many samples and returns an $O(H \epsilon)$-optimal policy, where $H$ is the number of steps of the MDP.  Interestingly, the error $H \epsilon$ has been shown to be optimal up to polylogarithmic factors.

The main novelty of the proposed algorithm, compared to the prior work, is in how it chooses the policy to execute. In particular, the policy is chosen to maximize the so-called “empirical roll-in distribution” at all levels. After that, similar to prior work, the algorithm proceeds to compute average bellman error, and eliminate parameters that lead to large Bellman error (though the algorithm is a bit more conservative in the sense that it always eliminates at most one candidate parameter per level in every iteration).
weaknesses: The algorithm is structurally similar to the algorithm from Jiang et al., 2017. Since the algorithm eliminates one parameter per level every iteration, it is almost doing a brute-force search over the entire parameter space. As a result, the sample complexity and runtime of the algorithm both scales exponentially with the sparsity parameter $k$ of the problem.

Meta-review: This paper present a elimination-based algorithm and polynomial sample complexity bound for reinforcement learning with sparse linear function approximation. The sample complexity is polynomial in the feature dimension d and planning horizon H when the sparsity level is constant. A lower bound matching to logarithmic factors is also provided to complement the result. The problem is important and technical result is solid. All reviewers are supportive of this work, we thus recommend acceptance.

Decision: Accept (Poster)