Lower Bounds for Finite-Armed Bandits
Why no algorithm can beat certain regret rates. Worst-case versus instance-dependent lower bounds; minimax regret, minimax optimality and Pareto optimality; reducing bandits to two-point hypothesis testing (competition versus similarity). The information-theoretic toolkit — relative entropy for general measures, the Bretagnolle–Huber inequality and its proof via Le Cam's inequality, Pinsker, Hellinger and χ², chain rule and data processing, Neyman–Pearson. The divergence decomposition D(Pν,Pν′) = Σ E[Tᵢ(n)] D(Pᵢ,Pᵢ′); the minimax bound √((k−1)n)/27 for Gaussian bandits, Fisher information and why KL is quadratic in the gap, Le Cam and Assouad methods, and lower bounds for Bernoulli bandits, small horizons and ETC. Consistency, d_inf and the Lai–Robbins/Burnetas–Katehakis asymptotic lower bound c*(ν) = Σ Δᵢ/d_inf; finite-time instance-dependent bounds for nearly minimax-optimal policies; sharpness of UCB-V and a variance–optimality trade-off. High-probability lower bounds for stochastic and adversarial bandits, why knowing δ in advance helps, and the near-tightness of Exp3-IX.
Corresponds to Lattimore & Szepesvári, Part IV introduction and Chapters 13–17. Chapter 14 (foundations of information theory) is condensed to what the lower bounds actually use. The coding view of entropy and relative entropy is in entropy-mutual-information, information-inequalities and data-compression.
Motivation: the real truth is in the lower bounds
ImportantWhy prove lower bounds
- An upper bound doesn’t tell you what you’re missing. Only a matching lower bound shows an algorithm is (nearly) optimal.
- Lower bounds are usually right first. Historically, upper bounds improve step by step until one finally meets a long-known lower bound.
- They reveal what makes a problem hard. The authors’ advice: on a new problem, try the lower bound first. The right algorithm often falls out of it.
DefinitionThe two flavours of lower bound
| Flavour | Form of the claim | Use |
|---|---|---|
| Worst-case (minimax) | “For any policy you give me, I’ll give you an instance with regret at least .” | Robustness: adversarial in spirit. |
| Instance-dependent | ”For any reasonable policy, the regret on every instance is at least .” | Refined: shows is unimprovable. |
“Reasonable” can’t be dropped. For any , the policy that always plays ‘s optimal arm has zero regret there and linear regret wherever another arm is optimal.
| Chapter | Bound | Main tool |
|---|---|---|
| 13 | Heuristic | Two-point hypothesis testing |
| 14 | — | Relative entropy, Bretagnolle–Huber |
| 15 | Minimax | Divergence decomposition |
| 16 | Asymptotic ; finite-time versions | Consistency, |
| 17 | High-probability, stochastic and adversarial | The same two-point argument on tail events |
Basic ideas (Chapter 13)
DefinitionWorst-case regret, minimax regret, minimax optimality
For a class of stochastic bandits and the set of all policies:
is minimax optimal for if .
| Component | Detail |
|---|---|
| Signature | |
| Meaning | The best worst-case guarantee any policy can have. |
| Small | The class is easy in the worst case. |
| Depends on | The class and the horizon. Minimax optimality is a property of (policy, class, horizon), not of a policy alone. |
RemarkPractical caveats
- Computing a minimax policy is usually infeasible. We settle for “minimax optimal up to constant (or logarithmic) factors”: for all (or , logarithmic in and ).
- Exactly minimax policies may not even be desirable. In classical statistics, minimizing the worst case often gives a flat risk profile: the same regret on easy instances as on hard ones. In practice we want low regret on easy bandits (gaps large or tiny) and higher regret only on hard ones (Chapter 16).
DefinitionGame-theoretic view and Pareto optimality
- The minimax regret is the value of a sequential zero-sum game: the protagonist proposes , the antagonist inspects it and picks , and the antagonist’s payoff is the regret. Its value for the antagonist is .
- Regret over a class is a multi-objective criterion. is Pareto optimal if no has for all with strict inequality somewhere.
ExamplePareto optimality is weak (Exercise 13.2)
On Gaussian bandits, “always play arm 1” is Pareto optimal. Any at least as good would need zero regret whenever arm 1 is uniquely optimal, so it must play arm 1 almost surely on those instances. Gaussian outcome laws on different instances are mutually absolutely continuous, so it must do the same everywhere, which makes . A terrible policy can still be Pareto optimal. (Argument worked here.)
TheoremTheorem 13.1 — Minimax lower bound (proved in Chapter 15)
Let be the -armed unit-variance Gaussian bandits with means in . There is a universal such that for all and . Together with Theorem 9.1, this makes MOSS minimax optimal up to constants.
Hypothesis testing: how many samples to tell two means apart?
ExampleTwo Gaussian means
i.i.d. with . The natural test guesses whichever value is closer to. Under it errs iff , and , so
using Abramowitz–Stegun’s tail bounds (13.4).
Reading: once , the error probability falls exponentially. But if , the test fails with constant probability. Nearest-mean is in fact the minimax test (Exercise 13.1; ML rule).
ImportantThe recipe: competition versus similarity
Pick two bandit instances that are
- competing: what is good in one is bad in the other (different optimal arms), and
- similar: close enough that the policy can’t reliably tell which one it faces.
These pull in opposite directions (separated means versus close means), and the lower bound comes from optimizing the trade-off.
DerivationThe heuristic argument
Instance 1: , with regret (13.2).
Find the neglected arm: let . Since , we have .
Instance 2: the same, except , so arm is now optimal by . Then (13.3).
Tune to the information available: the instances differ only on arm , sampled about times. Choose , which is exactly the undetectable scale. Then :
- if : ;
- otherwise: .
Sloppy points: is random, and “can’t tell apart” isn’t quantified. Chapters 14–15 fix both.
The information-theoretic toolkit (Chapter 14, condensed)
NoteCoding interpretation, briefly
Entropy (in nats; in bits) is the optimal expected code length per symbol, with Huffman within one bit, . Relative entropy is the extra expected length from using the code built for when the data come from . Details in data-compression and data-compression. Kraft’s inequality justifies restricting to prefix codes (Exercises 14.1, 14.3).
DefinitionRelative entropy for general measures
For probability measures on , discretize and take the worst case:
over measurable maps , with the push-forward. (Dobrushin: generating fields suffice.)
TheoremTheorem 14.1 — Density form
With a common dominating measure (for example ), (14.6).
| Fact | Detail |
|---|---|
| Nonnegativity | , with equality iff (Gibbs) |
| Not a metric | Asymmetric; no triangle inequality |
| Finite needs | but doesn’t guarantee finiteness on infinite spaces (Exercise 14.2) |
| Gaussians, common variance | |
| Gaussians, general (Ex. 14.7) | |
| Bernoulli | (KL-UCB) |
TheoremTheorem 14.2 — Bretagnolle–Huber inequality
For probability measures on the same space and any event ,
The roles of and can be swapped, which helps since is asymmetric.
IntuitionClose distributions can’t be separated by any event
is the error of “declare on ” when the truth is , and is the error when the truth is . If is small, every test has substantial total error. If , the sum is exactly 1; the bound gives .
ProofLe Cam’s inequality, then Jensen
Trivial if , so assume . Let , , . It’s enough to show , because .
Step 1 (Le Cam): . Since , Cauchy–Schwarz gives , and .
Step 2 (Jensen):
Absolute continuity ensures .
∎
ExampleNo test of a weak signal is reliable
One observation from (call it ) or (call it ), with . For any rejection region , , so , whatever the test.
RemarkRefinements and relatives
- Equality case / Neyman–Pearson: is an equality for , the likelihood-ratio test. More generally, likelihood-ratio tests are the most powerful at each significance level, and essentially the only ones (Exercises 14.14–14.15; LRTs).
- Sharper versions: (14.11), which dominates (14.7). For small , Pinsker is better.
- Pinsker: , so (14.12–14.13). That is vacuous for large , where Bretagnolle–Huber still works.
- Other distances: total variation , Hellinger , and : Each is tight for some pair. Bounded integrands obey (Exercise 14.4).
- Data processing: for any sub-σ-algebra (Exercise 14.10; data processing).
- Chain rule: (Exercise 14.12), and it holds with a stopping time in place of (Exercise 14.13).
Minimax lower bounds (Chapter 15)
Relative entropy between bandits
LemmaLemma 15.1 — Divergence decomposition
Fix a policy and bandits , , with outcome laws , on the canonical model. Then
ProofThe policy terms cancel in the likelihood ratio
Step 1: Densities. With respect to , the outcome density is , and the same for with . The policy is the same, so
Step 2: Condition on the action. Given , under , so .
Step 3: Regroup by arm. . If some with positive expected pulls, both sides are infinite.
∎
IntuitionInformation accrues only where you look
Distinguishing from costs exactly the per-sample divergence of each arm times how often the policy samples it. An arm that is rarely pulled is an arm about which and may disagree undetected. This is the regret decomposition’s information-theoretic twin.
RemarkGeneralizations
For general action spaces, (Exercise 15.8). With a stopping time, for any -measurable , (Exercise 15.7).
The minimax lower bound
TheoremTheorem 15.2 — Minimax lower bound for Gaussian bandits
Let and . For every policy there is with
where is the unit-variance Gaussian bandit with means . Hence .
ProofTwo instances, Bretagnolle–Huber, divergence decomposition
Step 1: Instances. with . Let , so . Set except .
Step 2: Regret in terms of one event. By the regret decomposition,
(in , every pull of arm 1 costs ).
Step 3: Bretagnolle–Huber with .
Step 4: Divergence decomposition. Only arm differs:
Step 5: Tune. (using ) makes the exponent . So the sum of the two regrets is at least , and the larger of the two is at least half that, .
∎
ImportantWhy the antagonist must look at the policy
The second instance perturbs the arm this policy neglects. A fixed pair of instances (classical Le Cam) can’t capture how a sequential policy distributes its samples. Choosing after seeing is what produces the .
RemarkWhy Gaussians are not special: Fisher information
All the proof used was for small gaps. For a smooth parametric family indexed by its mean, Taylor-expanding in gives
The first-order term vanishes because total mass is constant; is the Fisher information. So for any sufficiently rich, non-bizarre class, the KL is quadratic in the gap and the minimax regret is .
Note versus : no contradiction
The logarithmic upper bounds carry factors . The hard instances here have , where is of order , up to logs.
RemarkLe Cam’s method and Assouad’s method
- Le Cam: for estimating from i.i.d. samples under a metric , any two give (15.5). The bandit version differs in being sequential and in choosing after seeing the algorithm.
- Assouad-style proof (Exercise 15.2): compare all instances against . Pinsker and Exercise 14.4 give ; summing with Jensen gives . So some instance has . This version is due to Auer et al.
TheoremFurther minimax facts (Exercises 15.3–15.6)
- Small horizon (): some instance has regret at least .
- Bernoulli bandits: for . Bound KL by to handle Bernoulli divergences near the boundary.
- The term in MOSS’s bound can’t be removed: pull counts are integers, and each arm must be tried.
- ETC is not minimax optimal: for every exploration length , some instance has .
RemarkHistory
Vogel (1960) gave a precise minimax analysis of two-armed Bernoulli bandits. Bretagnolle–Huber entered bandits with Bubeck et al. (2013). The proof above follows Gerchinovitz–Lattimore (2016).
Instance-dependent lower bounds (Chapter 16)
IntuitionYou can’t be great everywhere
Order instances by difficulty. Minimax optimality says no policy can stay entirely below the flat line. Instance optimality says something stronger: any policy that beats the instance-dependent line on some instances must pay above it on others. “Always play arm 1” has zero regret when arm 1 is optimal and linear regret otherwise, an extreme over-specialization. This trade-off is the nature of bandits.
Asymptotic bounds
DefinitionConsistent policy (Def. 16.1)
is consistent over if for every and every ,
(subpolynomial regret everywhere). UCB is consistent on . “Always play arm 1” is consistent only if arm 1 is always optimal.
WarningConsistency is purely asymptotic
A consistent policy could play arm 1 for the first rounds. Consistency supports only asymptotic lower bounds. Finite-time versions need a finite-time analogue (Section 16.2).
Definition: the cheapest way to make an arm look optimal
For a set of distributions with means, with mean :
The smallest divergence from to any distribution in the class whose mean beats the current best.
| Component | Detail |
|---|---|
| Signature | |
| Meaning | Information per pull needed to rule out “arm is secretly optimal”. |
| Small | The arm is hard to dismiss, so many pulls are needed. |
| One pull can rule it out (see the Rademacher example). |
TheoremTheorem 16.2 — Asymptotic lower bound (Lai–Robbins; Burnetas–Katehakis)
Let be unstructured and consistent over . For every ,
ProofPerturb the suboptimal arm until it becomes optimal; consistency forces enough pulls
It suffices to show for each suboptimal arm , with .
Step 1: The alternative. Fix and let equal except arm has with and mean . It stays in because the class is unstructured. By Lemma 15.1, .
Step 2: Two regrets, one event. With (bad in , good in ),
Step 3: Rearrange.
Step 4: Consistency kills the last term. For every , eventually, so the limsup is at most , hence 0. Then let .
∎
IntuitionWhy pulls, and why that constant
A consistent policy must stay alert to the possibility that arm is secretly the best, which is the alternative , where neglecting arm would cost linear regret. To keep the chance of missing that alternative below , it needs , i.e. . Each such pull costs .
| Class | (mean ) | |
|---|---|---|
| Gaussian, known variance | ||
| Gaussian, unknown variance | ||
| Bernoulli | ||
| Uniform |
DefinitionAsymptotic optimality
is asymptotically optimal on if for all (16.3). For most classes such a policy exists (Burnetas–Katehakis). Examples: UCB with on unit-variance Gaussians (, Chapter 8), and KL-UCB on Bernoulli ().
WarningETC and elimination are not asymptotically optimal
However they are tuned, they pay an extra multiplicative factor of 2 on Gaussian bandits (Garivier et al. 2016): committing in phases wastes information.
RemarkScope
- Unstructured classes only. With structure, pulling one arm informs about others, and lower bounds must be derived case by case.
- Nonparametric classes: solved exactly for bounded support (Honda–Takemura 2010), partly for semi-bounded support, and up to constants for bounded kurtosis.
- Exponential families: the KL-UCB-type bound of Exercise 10.4 is tight (Exercise 16.3).
Finite-time bounds
LemmaLemma 16.3 — Finite-time pull lower bound
Let differ only in arm , with suboptimal in and uniquely optimal in , and let . For any policy,
This is Bretagnolle–Huber plus divergence decomposition, without taking limits.
TheoremTheorem 16.4 — Nearly minimax-optimal policies can’t beat UCB by much
Let be a Gaussian bandit with means and gaps , and . If for all in some set and all (with ), then for and ,
ProofApply Lemma 16.3 with the arm raised to just above optimal
For suboptimal , take with , so , , and . With ,
Multiply by and sum (regret decomposition).
∎
IntuitionRobustness costs at most a constant factor
Assuming only that the policy is not terrible on nearby instances (polynomial regret with exponent ), it must pay about . For , any nearly minimax policy, that is about half the asymptotic constant. The gap may be real: this larger class of policies includes ones tuned to particular instances.
ExampleEdge cases (Exercises 16.2, 16.4, 16.6–16.8)
- Infinite gives bounded regret. For shifted Rademacher rewards ( each with probability ), distributions with different means have disjoint supports, so , and a policy with for all exists. The Fisher-information heuristic assumed a smooth, “not too bizarre” family, which this is not.
- Unknown subgaussian constant gives . On the class of all subgaussian distributions (any ), every consistent policy has . Yet for any some policy achieves : consistent, just not logarithmic.
- Refining lower-order terms (two arms): if on all instances with , then . The form of MOSS-type bounds is essentially necessary.
- UCB-V’s bound is sharp: no policy can have (no gap dependence) or (no range term) on all -bounded bandits. Both terms of are needed.
- Optimality costs variance: if on Gaussian bandits, then some instance has pseudo-regret variance at least about . Being asymptotically optimal () forces the unstable regret seen in MOSS’s second problem.
High-probability lower bounds (Chapter 17)
Setting expectations. Exp3-IX gave two kinds of high-probability bound:
| Algorithm | Guarantee with probability | Can be integrated to bound ? |
|---|---|---|
| One algorithm for all | (17.1) | Yes: |
| Tuned to a given | (17.2) | Only via , giving |
The question is whether the order of quantifiers really matters. It does: both bounds are tight up to constants.
Stochastic bandits
DefinitionRandom pseudo-regret
, random through the pull counts. Here denotes -armed unit-variance Gaussian bandits with gaps at most 1.
TheoremTheorem 17.1 — Low expected regret forces heavy tails
If for all , then for every there is with
ProofThe same two-instance argument, on a tail event
Step 1: , with the least-pulled suboptimal arm. By the regret decomposition and the assumption, (17.5).
Step 2: except . Then .
Step 3: forces in , and its complement forces in . By Bretagnolle–Huber,
with . One of the two probabilities is at least .
∎
CorollaryCorollary 17.2 — Tuning for one δ can’t do better than
For any and with , some has
Proof by contradiction: otherwise , and Theorem 17.1 with produces exactly such an instance.
CorollaryCorollary 17.3 — A single algorithm can’t have sub-exponential tails
For and , no policy satisfies for all , and . Such tails would integrate to , and then Theorem 17.1 gives a tail of order , which grows faster in than . Small expected regret forces the tail to grow linearly in . The authors conjecture that is achievable.
ImportantKnowing δ in advance really helps
A single all- algorithm pays ; a -tuned algorithm pays . Both are tight. The price of the all- guarantee is , small but real. It buys integrability, i.e. an expected-regret bound.
Adversarial bandits
TheoremTheorem 17.4 — High-probability lower bound against an adversary
For suitable universal constants , if , then for every policy there is a reward sequence with
No assumption on the algorithm is needed.
ProofSketch: random clipped-Gaussian adversaries
Two difficulties compared with the stochastic case: rewards must lie in , and the target is the adversarial regret against the best arm in hindsight, not the pseudo-regret.
Claim 17.5 (averaging): if a random reward table gives tail probability at least on average, some fixed table does too. So it suffices to randomize the adversary.
Construction: let be a common noise term for each round. Arm 1 pays , arm (in instance ) pays , and the rest pay . Arms are correlated within a round but i.i.d. across rounds.
Claim 17.6: with , some has . This is the stochastic argument with a new KL computation.
Relating to the regret: within a round, the shared noise makes the gaps exact unless clipping occurs:
Claim 17.7: with , and , clipping occurs in at least rounds with probability at most . Combining the claims gives . (Proofs: Exercise 17.1; details in Gerchinovitz–Lattimore 2016.)
∎
IntuitionThe best arm is best in every round, and it doesn’t help
Under , arm has the highest reward in every round, not just on average. Yet with bandit feedback the learner sees one reward per round, and the shared noise hides which arm is best, so it can’t exploit this.
ImportantExp3-IX is nearly tight
If an algorithm has , then for small some adversary forces . That matches the term of Exp3-IX’s all- bound up to constants. Gerchinovitz–Lattimore also give lower bounds for structured loss matrices (low variance, similar arms).
Quick reference
| Object | Statement | Note |
|---|---|---|
| Minimax regret | depends on (class, horizon) | |
| Pareto optimal | no policy weakly better everywhere, strictly somewhere | ”always arm 1” qualifies |
| Testing two means | error ; constant if | (13.1) |
| Recipe | competing and similar instances | perturb the least-pulled arm |
| Relative entropy | if , else | Gaussian: |
| Bretagnolle–Huber | Le Cam + Jensen | |
| Pinsker | better for small | |
| Distance chain | ||
| Divergence decomposition | policy terms cancel | |
| Minimax bound | ||
| Fisher information | so is generic | |
| ETC lower bound | not minimax optimal | |
| Consistency | for all , on all instances | asymptotic notion |
| per-pull information to rule an arm out | ||
| Lai–Robbins | unstructured classes | |
| Gaussian | UCB is optimal | |
| Bernoulli | KL-UCB is optimal | |
| Finite time | if nearby | half the constant at |
| High probability, stochastic | ⇒ tail w.p. | no tails |
| δ-tuned | at least | matches Exp3-IX (tuned) |
| Adversarial | clipped common-noise construction |
Facts to keep to hand
- Every bound here is a two-point test. Pick a second instance that perturbs exactly the arm the policy samples least, bound the KL between the outcome laws by pulls times per-sample KL, and apply Bretagnolle–Huber to an event that is bad in one instance and good in the other.
- Information accrues only where you sample. The divergence decomposition turns “the policy can’t tell” into “the policy didn’t pull that arm enough”. That is why the antagonist chooses its perturbation after seeing the policy.
- KL is quadratic in the gap for smooth families. Detecting a gap needs about samples, which gives in the worst case and per arm on instances. Non-smooth families (disjoint supports) or overly rich ones (unknown scale) break this, in opposite directions.
- Instance optimality is a balance, not a free lunch. Consistency (or near-minimax robustness) forces pulls of each suboptimal arm. Doing better on some instances costs linear regret on others, and pushing to the exact constant costs regret variance.
- Tails are part of the guarantee. Small expected regret forces tails that grow linearly in . Fixing in advance buys instead, at the cost of integrability.
References
- Lattimore & Szepesvári, Bandit Algorithms — Part IV introduction; Chapters 13–17
- Tsybakov, Introduction to Nonparametric Estimation (2008) — information-theoretic lower bounds in statistics