Lean module · EXP3
BanditRLProof.Exp3ExpectedRegret
# Tuned predictable EXP3 regret This module keeps parameter algebra separate from the generated trajectory and conditional-law proof. The first theorem simplifies the unoptimized budget when `eta = gamma / |A|`; the second applies that deterministic fact to the compiled predictable EXP3 endpoint.
Module map
Imports
BanditRLProof.Exp3PredictableIntegration
Imported by
Declarations
Open an item to read its exact compact statement and source link. Detailed teaching notes are linked when registered.
theorem
BanditRLProof.Exp3.expectedRegretBudget_le_four_mul_gamma_mul_horizon
Compiled
Deterministic EXP3 parameter algebra. If `eta = gamma / K`, exploration is at most one half, and `gamma^2 T` covers `K log K`, then the unoptimized budget is at most `4 gamma T`.
theorem expectedRegretBudget_le_four_mul_gamma_mul_horizon (K T logK eta gamma : Real) (hK : 0 < K) (hT : 0 <= T) (hgamma_pos : 0 < gamma) (hgamma_le_half : gamma <= 1 / 2) (heta : eta = gamma / K) (hlog_budget : K * logK <= gamma ^ 2 * T) : logK / eta + (eta * (1 / (1 - gamma))) * (K * T) + gamma * T <= 4 * gamma * T
def
BanditRLProof.Exp3.tunedExplorationRate
Compiled
Square-root exploration scale used by the tuned corollary.
noncomputable def tunedExplorationRate (K T : Real) : Real
def
BanditRLProof.Exp3.tunedLearningRate
Compiled
Learning rate paired with `tunedExplorationRate`.
noncomputable def tunedLearningRate (K T : Real) : Real
theorem
BanditRLProof.Exp3.tunedExplorationRate_pos
Compiled
No declaration docstring is present; use the chapter context and exact statement below.
theorem tunedExplorationRate_pos (K T : Real) (hK_one : 1 < K) (hT : 0 < T) : 0 < tunedExplorationRate K T
theorem
BanditRLProof.Exp3.tunedExplorationRate_le_half
Compiled
No declaration docstring is present; use the chapter context and exact statement below.
theorem tunedExplorationRate_le_half (K T : Real) (hT : 0 < T) (hscale : 4 * K * Real.log K <= T) : tunedExplorationRate K T <= 1 / 2
theorem
BanditRLProof.Exp3.tunedLearningRate_pos
Compiled
No declaration docstring is present; use the chapter context and exact statement below.
theorem tunedLearningRate_pos (K T : Real) (hK_one : 1 < K) (hT : 0 < T) : 0 < tunedLearningRate K T
theorem
BanditRLProof.Exp3.tunedExplorationRate_sq_mul_eq
Compiled
No declaration docstring is present; use the chapter context and exact statement below.
theorem tunedExplorationRate_sq_mul_eq (K T : Real) (hK_one : 1 < K) (hT : 0 < T) : tunedExplorationRate K T ^ 2 * T = K * Real.log K
theorem
BanditRLProof.Exp3.tunedExplorationRate_mul_eq_sqrt_mul
Compiled
No declaration docstring is present; use the chapter context and exact statement below.
theorem tunedExplorationRate_mul_eq_sqrt_mul (K T : Real) (hK_one : 1 < K) (hT : 0 < T) : tunedExplorationRate K T * T = Real.sqrt (K * T * Real.log K)
theorem
BanditRLProof.Exp3.sampledPredictable_expectedRegret_le_four_mul_gamma_mul_horizon
Compiled
The generated predictable EXP3 trajectory has regret at most `4 gamma horizon` when `eta = gamma / |arms|` and the exploration budget dominates `|arms| log |arms|`.
theorem sampledPredictable_expectedRegret_le_four_mul_gamma_mul_horizon {Env : Type u} {Action : Type v} [MeasurableSpace Env] [StandardBorelSpace Env] [MeasurableSpace Action] [MeasurableSingletonClass Action] [StandardBorelSpace Action] [Nonempty Action] [DecidableEq Action] (prior : Measure Env) [IsProbabilityMeasure prior] (arms : Finset Action) (harms : arms.Nonempty) (gamma : Real) (hgamma_pos : 0 < gamma) (hgamma_le_half : gamma <= 1 / 2) (loss : PredictableLossVector Env Action) (horizon : Nat) (hlog_budget : (arms.card : Real) * Real.log arms.card <= gamma ^ 2 * (horizon : Real)) (comparator : Action) (hcomparator : comparator ∈ arms) : let eta := gamma / (arms.card : Real) let mu := prior ⊗ₘ sampledImportanceWeightedTrajectoryKernel arms harms eta gamma hgamma_pos.le (by linarith) loss.environment integral mu (fun sample => (Finset.range horizon).sum (fun t => sampledTrajectoryExploredPredictableLossAt arms eta gamma loss t sample) - (Finset.range horizon).sum (fun t => predictableLossAt loss t sample comparator)) <= 4 * gamma * (horizon : Real)
def
BanditRLProof.Exp3.tunedPredictableTrajectoryKernel
Compiled
Generated predictable EXP3 kernel at the square-root exploration and learning rates. The large-horizon hypotheses discharge the kernel's `0 <= gamma <= 1` contract internally.
noncomputable def tunedPredictableTrajectoryKernel {Env : Type u} {Action : Type v} [MeasurableSpace Env] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Nonempty Action] [DecidableEq Action] (arms : Finset Action) (harms : arms.Nonempty) (hcard_two : 2 <= arms.card) (loss : PredictableLossVector Env Action) (horizon : Nat) (hhorizon_pos : 0 < horizon) (hscale : 4 * (arms.card : Real) * Real.log arms.card <= (horizon : Real)) : Kernel Env (Nat -> Action × Real)
theorem
BanditRLProof.Exp3.sampledPredictable_expectedRegret_le_four_mul_sqrt
Compiled
Tuned generated-trajectory expected predictable-regret bound. Under the large-horizon regime `4 |A| log |A| <= T`, the square-root exploration and learning rates give the classical `sqrt(|A| T log |A|)` scale.
theorem sampledPredictable_expectedRegret_le_four_mul_sqrt {Env : Type u} {Action : Type v} [MeasurableSpace Env] [StandardBorelSpace Env] [MeasurableSpace Action] [MeasurableSingletonClass Action] [StandardBorelSpace Action] [Nonempty Action] [DecidableEq Action] (prior : Measure Env) [IsProbabilityMeasure prior] (arms : Finset Action) (harms : arms.Nonempty) (hcard_two : 2 <= arms.card) (loss : PredictableLossVector Env Action) (horizon : Nat) (hhorizon_pos : 0 < horizon) (hscale : 4 * (arms.card : Real) * Real.log arms.card <= (horizon : Real)) (comparator : Action) (hcomparator : comparator ∈ arms) : let K := (arms.card : Real) let T := (horizon : Real) let gamma := tunedExplorationRate K T let eta := tunedLearningRate K T let mu := prior ⊗ₘ tunedPredictableTrajectoryKernel arms harms hcard_two loss horizon hhorizon_pos hscale integral mu (fun sample => (Finset.range horizon).sum (fun t => sampledTrajectoryExploredPredictableLossAt arms eta gamma loss t sample) - (Finset.range horizon).sum (fun t => predictableLossAt loss t sample comparator)) <= 4 * Real.sqrt (K * T * Real.log K)