Formalization: Chebyshev Rollout Schedules for Polynomial Extrapolation under Low-Order Interference

The complete Lean development behind this paper — every definition, lemma, and theorem of its module, including helpers the paper text never cites. Identifiers link within this page, into the Causalean library, or out to the official Mathlib docs.

Basic 13 declarations The randomization π is a FiniteDesign Ω: a PMF on a finite assignment space with finite-sum E/Var/Cov.

Environment S1 — finite-population monotone-Bernoulli rollout DESIGN world

The randomization π is a FiniteDesign Ω: a PMF on a finite assignment space with finite-sum E/Var/Cov. The round means bar_Y_j : Ω → ℝ are real random variables of the realized assignment; Var_pi(bar_Y_j) is FiniteDesign.Var (barY j), and the exact covariance form w'Γ_P(p)w is FiniteDesign.Var (fun z => ∑ j, w j * barY j z). The potential outcomes Y_i(z), the rollout assignment vectors Z_j, the population U_n, the mean curve m_P, its polynomial coefficients a_{P,ℓ}, and the target τ_P are all exposed at this abstract FiniteDesign level (matching the paper's honest scope: the novelty is the design object, not new PO machinery).

@env: S1

def StaticRolloutConsistency Assumption 1 in the paper ↗

Static rollout potential outcomes with no carryover (CortezRodriguezEichhornYu2024): the observed round mean equals bar_Y_j = n⁻¹ ∑_{i∈U_n} Y_i(Z_j), with the potential outcomes depending on the contemporaneous assignment vector Z_j (the argument of Y) but not on earlier rollout steps. Inherited setup; threaded Prop, never discharged. @realizes bar_Y_j(barY j z = n⁻¹ ∑ Y_i(Z_j)) @realizes Y_i(z)(Y : units → assignment → ℝ) @realizes Z_j(Z j z : assignment vector at round j) @realizes U_n(unit index Fin n)

Definition (Lean source)
def StaticRolloutConsistency (n k : ℕ) {Ω : Type*} [Fintype Ω] (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) : Prop := ∀ (j : Fin (k + 1)) (z : Ω), barY j z = (n : ℝ)⁻¹ * ∑ i, Y i (Z j z)
CausalSmith.Experimentation.RolloutChebyshev.StaticRolloutConsistency · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:56
def BetaOrderPolynomial Assumption 2 in the paper ↗

β-order rollout polynomial identity (CortezEichhornYu2022): the rollout mean curve is a degree-β polynomial m_P(u) = ∑_{ℓ=0}^β a_{P,ℓ} uˡ on [0,1]. Inherited setup; threaded Prop. @realizes m_P(m u = ∑ a_ℓ uˡ on [0,1]) @realizes a_{P,0}, ..., a_{P,beta}(coefficient vector a : ℕ → ℝ, indices 0..β)

Definition (Lean source)
def BetaOrderPolynomial (beta : ℕ) (m : ℝ → ℝ) (a : ℕ → ℝ) : Prop := ∀ u : ℝ, u ∈ Icc (0 : ℝ) 1 → m u = ∑ ell ∈ range (beta + 1), a ell * u ^ ell
CausalSmith.Experimentation.RolloutChebyshev.BetaOrderPolynomial · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:70
def RoundMeanVarianceEnvelope Assumption 3 in the paper ↗

NOVEL total-variation design envelope: for every round j, the design variance of the round mean is bounded by σ₀²/n. The paper's declared TV envelope INPUT, not a proof obligation; threaded Prop, never discharged. @realizes sigma_0^2(envelope constant σ₀² with Var_pi(barY j) ≤ σ₀²/n)

Definition (Lean source)
def RoundMeanVarianceEnvelope (n k : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (barY : Fin (k + 1) → Ω → ℝ) (sigma0sq : ℝ) : Prop := ∀ j : Fin (k + 1), D.Var (barY j) ≤ sigma0sq / (n : ℝ)
CausalSmith.Experimentation.RolloutChebyshev.RoundMeanVarianceEnvelope · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:78

Low-budget regime cap: q ≤ q_max < 1, with the ambient budget-cap range q_max ∈ (0,1). The leading conjunct 0 < q_max realizes the core space of q_max (which is (0,1), not just (-∞,1)); every consumer taking LowBudgetCap q qmax inherits 0 < q_max by name. Threaded modeling Prop. @realizes q_max(low-budget cap 0 < q_max < 1)

Definition (Lean source)
def LowBudgetCap (q qmax : ℝ) : Prop := 0 < qmax ∧ q ≤ qmax ∧ qmax < 1
CausalSmith.Experimentation.RolloutChebyshev.LowBudgetCap · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:87
def BudgetedSchedule Definition 1 in the paper ↗

Budgeted rollout schedules S_{k,q} = { p ∈ [0,1]^(k+1) : p₀ = 0, 0 < p₁ < ... < p_k = q }. The paper's ambient schedule range p ∈ [0,1]^(k+1) is carried by the first conjunct (each coordinate lies in [0,1]). The budget q is the treated endpoint p (last k) = q; combined with p 0 = 0, StrictMono p and p j ∈ [0,1] this pins the core space q ∈ (0,1] (0 = p 0 < p (last k) = q ≤ 1). @realizes p(schedule Fin (k+1) → [0,1]: carrier ℝ + Icc range clause) @realizes q(carrier ℝ; range (0,1] via p (last k) = q with p 0 = 0, StrictMono p, Icc clause) @realizes S_{k,q}(p j ∈ Icc 0 1, p 0 = 0, StrictMono p, p (last k) = q)

Definition (Lean source)
def BudgetedSchedule (k : ℕ) (q : ℝ) (p : Fin (k + 1) → ℝ) : Prop := (∀ j, p j ∈ Icc (0 : ℝ) 1) ∧ p 0 = 0 ∧ StrictMono p ∧ p (last k) = q
CausalSmith.Experimentation.RolloutChebyshev.BudgetedSchedule · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:103

Linear-unbiased rollout weights W_β(p) = { w : ∑ⱼ wⱼ pⱼ⁰ = 0, ∑ⱼ wⱼ pⱼˡ = 1, ℓ=1..β }. @realizes W_beta(p)(∑ wⱼ pⱼ⁰ = 0 and ∑ wⱼ pⱼˡ = 1 for 1≤ℓ≤β) @realizes w(weight vector Fin (k+1) → ℝ)

Definition (Lean source)
def UnbiasedWeights (beta k : ℕ) (p w : Fin (k + 1) → ℝ) : Prop := (∑ j : Fin (k + 1), w j * (p j) ^ (0 : ℕ) = 0) ∧ (∀ ell : ℕ, 1 ≤ ell → ell ≤ beta → ∑ j : Fin (k + 1), w j * (p j) ^ ell = 1)
CausalSmith.Experimentation.RolloutChebyshev.UnbiasedWeights · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:115
def chebyshevSchedule Definition 4 in the paper ↗

Shifted Chebyshev-Lobatto rollout schedule pⱼ^Ch(k,q) = q(1 - cos(π j / k))/2. Carrier Fin (k+1) → ℝ (the closed-form grid). Its core space p^Ch(k,q) ∈ [0,1]^(k+1) is NOT free from the formula alone: since 1 - cos ∈ [0,2], each coordinate lands in [0,q] ⊆ [0,1] precisely when k ≥ 1 and q ∈ (0,1]. This range clause is realized by chebyshev_schedule_admissible, whose conclusion BudgetedSchedule k q (p^Ch(k,q)) carries the [0,1]^(k+1) membership ∀ j, p^Ch(k,q) j ∈ Set.Icc 0 1 (its first conjunct) together with p 0 = 0, StrictMono, p (last k) = q — so the carrier def here plus that admissibility lemma together pin p^Ch(k,q) to its declared space. The budget parameter q (carrier q : ℝ) has space (0,1], pinned by the same admissibility range predicate hq : 0 < q ∧ q ≤ 1. @realizes p^Ch(k,q)(carrier q(1 - cos(π j/k))/2; range [0,1]^(k+1) via chebyshev_schedule_admissible → BudgetedSchedule Icc clause, k≥1, q∈(0,1]) @realizes q(carrier ℝ; range 0 < q ≤ 1 pinned by chebyshev_schedule_admissible.hq)

Definition (Lean source)
noncomputable def chebyshevSchedule (k : ℕ) (q : ℝ) : Fin (k + 1) → ℝ := fun j => q * (1 - cos (pi * (j : ℝ) / (k : ℝ))) / 2
CausalSmith.Experimentation.RolloutChebyshev.chebyshevSchedule · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:123
def amplification

Total-variation amplification of a fixed schedule A_β(p) = inf_{w∈W_β(p)} (∑ⱼ|wⱼ|)². @realizes A_beta(p)(inf over W_β(p) of (∑|wⱼ|)²)

Definition (Lean source)
noncomputable def amplification (beta k : ℕ) (p : Fin (k + 1) → ℝ) : ℝ := sInf { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ v = (∑ j, |w j|) ^ 2 }
CausalSmith.Experimentation.RolloutChebyshev.amplification · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:139
def minimaxAmplification Definition 5 in the paper ↗

Minimax amplification over budgeted schedules M_{β,k,q} = inf_{p∈S_{k,q}} A_β(p). @realizes M_{beta,k,q}(inf over S_{k,q} of A_β(p))

Definition (Lean source)
noncomputable def minimaxAmplification (beta k : ℕ) (q : ℝ) : ℝ := sInf { v : ℝ | ∃ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p ∧ v = amplification beta k p }
CausalSmith.Experimentation.RolloutChebyshev.minimaxAmplification · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:145
def rhoCh

Minimal low-budget exponential base ρ_Ch(c,q_max) = inf { ρ ≥ 1 : sup_{β≥1} sup_{q∈(0,q_max]} qᵝ A_β(p^Ch(⌈cβ⌉,q))^{1/2} ρ^{-β} < ∞ }. The named minimax base of the shifted Chebyshev-Lobatto schedule. Carrier ; its core space [1,∞) is realized by the CONJUNCTION of (i) the 1 ≤ ρ conjunct in the set predicate, which makes 1 a lower bound of the defining set, and (ii) the range lemma one_le_rhoCh proved after chebyshev_minimax, which discharges the sInf value itself to 1 ≤ ρ_Ch (the element-wise 1 ≤ ρ conjunct alone does NOT pin the infimum, since sInf ∅ = 0; the value ≥ 1 needs the set to be nonempty, from the Chebyshev upper bound). The sup < ∞ is encoded as boundedness ∃ M, ∀ …, qᵝ A_β^{1/2} ≤ M·ρᵝ (equivalent to qᵝ A_β^{1/2} ρ^{-β} ≤ M since ρ ≥ 1 > 0). @realizes rho_Ch(c,q_max)(carrier ℝ; def = minimal base infimum over the [1,∞)-predicate set)

Definition (Lean source)
noncomputable def rhoCh (c qmax : ℝ) : ℝ := sInf { rho : ℝ | 1 ≤ rho ∧ ∃ M : ℝ, ∀ beta : ℕ, 1 ≤ beta → ∀ q : ℝ, 0 < q → q ≤ qmax → q ^ beta * sqrt (amplification beta ⌈c * (beta : ℝ)⌉₊ (chebyshevSchedule ⌈c * (beta : ℝ)⌉₊ q)) ≤ M * rho ^ beta }
CausalSmith.Experimentation.RolloutChebyshev.rhoCh · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:150
structure RolloutLawClass

The static β-order rollout TV-envelope law class P_β, bundling the three member assumptions plus the defining pinning of the mean curve m_P to the law (E_pi[bar_Y_j] = m_P(p_j), the schedule-point restriction of m_P(u) = E_pi(bar_Y_j∣p_j=u); required so m is not a free auxiliary widening the class). @realizes P_beta(bundle of static-rollout, β-polynomial, variance-envelope + mean-curve pinning) @realizes m_P(mean_curve : E_pi[barY j] = m (p j))

Definition (Lean source)
n k beta :
Ω :
Type*
D :
Y :
Fin n → (Fin n → Bool) → ℝ
Z :
Fin (k + 1) → Ω → (Fin n → Bool)
barY :
Fin (k + 1) → Ω → ℝ
m :
ℝ → ℝ
a :
ℕ → ℝ
sigma0sq :
p :
Fin (k + 1) → ℝ
Member: static rollout consistency (`ass:static-rollout-consistency`).
static_rollout :
Member: β-order rollout polynomial (`ass:beta-order-polynomial`).
beta_polynomial :
Member: round-mean TV variance envelope (`ass:round-mean-variance-envelope`).
variance_envelope :
RoundMeanVarianceEnvelope n k D barY sigma0sq
Defining pinning of the law functional `m_P` to the design: the round mean at round `j` has design expectation `m_P(p_j)`.
mean_curve :
∀ j : Fin (k + 1), D.E (barY j) = m (p j)
CausalSmith.Experimentation.RolloutChebyshev.RolloutLawClass · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:167

Exact finite-population nested-rollout minimax risk handle R_exact(β,k,q) = inf_{p∈S_{k,q}} inf_{w∈W_β(p)} sup_{P∈P_β} w'Γ_P(p)w, where w'Γ_P(p)w = Var_pi(∑ⱼ wⱼ bar_Y_j) is the exact design variance under the monotone-Bernoulli rollout π = D. The supremum ranges over laws P (fixed potential outcomes / round means on the common randomization D) in the class RolloutLawClass. @realizes R_exact(beta,k,q)(inf_p inf_w sup_P w'Γ_P(p)w) @realizes Gamma_P(p)(w'Γ_P(p)w = D.Var (∑ wⱼ barYⱼ))

Definition (Lean source)
noncomputable def exactNestedRisk (n k beta : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (q sigma0sq : ℝ) : ℝ := sInf { rp : ℝ | ∃ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p ∧ rp = sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } }
CausalSmith.Experimentation.RolloutChebyshev.exactNestedRisk · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:188
theorem rollout_polynomial_identity Lemma 1 in the paper ↗

Under static rollout consistency and the β-order polynomial identity, τ_P = m_P(1) - m_P(0) = ∑_{ℓ=1}^β a_{P,ℓ} (polynomial endpoint evaluation). Inherited setup from CortezEichhornYu2022; recalled only to reduce τ_P to a degree-β endpoint functional.

Formal statement
n k beta :
Ω :
Type*
Y :
Fin n → (Fin n → Bool) → ℝ
Z :
Fin (k + 1) → Ω → (Fin n → Bool)
barY :
Fin (k + 1) → Ω → ℝ
m :
ℝ → ℝ
a :
ℕ → ℝ
hcons :
hpoly :
m 1 - m 0 = ∑ ell ∈ Icc 1 beta, a ell
Proof (Lean source)
lemma rollout_polynomial_identity (n k beta : ℕ) {Ω : Type*} [Fintype Ω] (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ) (hcons : StaticRolloutConsistency n k Y Z barY) (hpoly : BetaOrderPolynomial beta m a) : m 1 - m 0 = ∑ ell ∈ Icc 1 beta, a ell := by have _ : StaticRolloutConsistency n k Y Z barY := hcons have h1 : m 1 = ∑ ell ∈ range (beta + 1), a ell := by simpa using hpoly 1 (by norm_num) have h0 : m 0 = a 0 := by calc m 0 = ∑ ell ∈ range (beta + 1), a ell * 0 ^ ell := hpoly 0 (by norm_num) _ = a 0 := by rw [Finset.sum_eq_single 0] · simp · intro b hb hbne simp [zero_pow hbne] · simp have hsplit : (∑ ell ∈ range (beta + 1), a ell) = a 0 + ∑ ell ∈ Icc 1 beta, a ell := by clear hpoly h1 h0 induction beta with | zero => simp | succ beta ih => rw [Finset.sum_range_succ] rw [ih] rw [Finset.sum_Icc_succ_top (Nat.succ_pos beta)] ring rw [h1, h0, hsplit] ring
CausalSmith.Experimentation.RolloutChebyshev.rollout_polynomial_identity · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Basic.lean:208
Helpers.Amplification 3 declarations
theorem amplification_dual_norm Lemma 3 in the paper ↗

ℓ¹/ℓ∞ duality: for a schedule p with distinct nodes and nonempty W_β(p), the minimal total-variation norm of a representing weight vector equals the dual (Chebyshev) norm sup{ |r(1)-r(0)| : deg r ≤ β, max_j |r(p_j)| ≤ 1 }, and A_β(p) is its square. Matching the note, the only premises are that the nodes are distinct and that W_β(p) is nonempty (feasibility of the primal); there is no β ≤ k side-condition on the statement.

Formal statement
beta k :
p :
Fin (k + 1) → ℝ
hp :
hne :
∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w
sInf { s : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ s = ∑ j, |w j| }
= sSup { t : ℝ | ∃ r : Polynomial ℝ, r.natDegree ≤ beta ∧ (∀ j, |r.eval (p j)| ≤ 1) ∧ t = |r.eval 1 - r.eval 0| } ∧
amplification beta k p
= (sSup { t : ℝ | ∃ r : Polynomial ℝ, r.natDegree ≤ beta ∧ (∀ j, |r.eval (p j)| ≤ 1) ∧ t = |r.eval 1 - r.eval 0| }) ^ 2
Proof (Lean source)
lemma amplification_dual_norm (beta k : ℕ) (p : Fin (k + 1) → ℝ) (hp : Injective p) (hne : ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w) : sInf { s : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ s = ∑ j, |w j| } = sSup { t : ℝ | ∃ r : Polynomial ℝ, r.natDegree ≤ beta ∧ (∀ j, |r.eval (p j)| ≤ 1) ∧ t = |r.eval 1 - r.eval 0| } ∧ amplification beta k p = (sSup { t : ℝ | ∃ r : Polynomial ℝ, r.natDegree ≤ beta ∧ (∀ j, |r.eval (p j)| ≤ 1) ∧ t = |r.eval 1 - r.eval 0| }) ^ 2 := by have _ : Injective p := hp -- Bridge the run's `UnbiasedWeights` to the duality substrate's `MomentSol`. have key : ∀ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ↔ w ∈ MomentSol p beta := by intro w simp only [UnbiasedWeights, MomentSol, Set.mem_setOf_eq] constructor · rintro ⟨h0, hpos⟩ ℓ hℓ rcases Nat.eq_zero_or_pos ℓ with hz | hℓpos · subst hz; simpa using h0 · rw [if_neg (by omega : ℓ ≠ 0)]; exact hpos ℓ hℓpos hℓ · intro h refine ⟨?_, ?_⟩ · have h0 := h 0 (zero_le _); simpa using h0 · intro ℓ h1 hℓ have hh := h ℓ hℓ rwa [if_neg (by omega : ℓ ≠ 0)] at hh -- The run's primal set is the substrate's `primalNormSet`; its dual set is `dualValSet`. have hprimal_set : { s : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ s = ∑ j, |w j| } = primalNormSet p beta := by ext s simp only [primalNormSet, Set.mem_setOf_eq] exact ⟨fun ⟨w, hw, hs⟩ => ⟨w, (key w).mp hw, hs⟩, fun ⟨w, hw, hs⟩ => ⟨w, (key w).mpr hw, hs⟩⟩ have hmoment_nonempty : (MomentSol p beta).Nonempty := by rcases hne with ⟨w, hw⟩ exact ⟨w, (key w).mp hw⟩ refine ⟨?_, ?_⟩ · -- First conjunct: exactly the ℓ¹/ℓ∞ duality identity. rw [hprimal_set] exact l1_repr_eq_sup_dual_of_momentSol_nonempty hmoment_nonempty · -- Second conjunct: compare the squared infimum directly with the dual square. let A : Set ℝ := { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ v = (∑ j, |w j|) ^ 2 } have hA_bdd : BddBelow A := by refine ⟨0, ?_⟩ intro v hv rcases hv with ⟨w, _hw, rfl⟩ exact sq_nonneg _ have hA_nonempty : A.Nonempty := by rcases hne with ⟨w, hw⟩ exact ⟨(∑ j, |w j|) ^ 2, w, hw, rfl⟩ have hD_nonneg : 0 ≤ sSup (dualValSet p beta) := dual_nonneg_of_momentSol_nonempty hmoment_nonempty have hdual_eq : sInf (primalNormSet p beta) = sSup (dualValSet p beta) := l1_repr_eq_sup_dual_of_momentSol_nonempty hmoment_nonempty have hAmp_lower : (sSup (dualValSet p beta)) ^ 2 ≤ sInf A := by refine le_csInf hA_nonempty ?_ intro v hv rcases hv with ⟨w, hw, rfl⟩ have hwM : w ∈ MomentSol p beta := (key w).mp hw have hnorm_mem : (∑ j, |w j|) ∈ primalNormSet p beta := ⟨w, hwM, rfl⟩ have hD_le_norm : sSup (dualValSet p beta) ≤ ∑ j, |w j| := by rw [← hdual_eq] exact csInf_le primalNormSet_bddBelow hnorm_mem have hnorm_nonneg : 0 ≤ ∑ j, |w j| := sum_nonneg (fun j _ => abs_nonneg (w j)) exact sq_le_sq' (by linarith) hD_le_norm have hAmp_upper : sInf A ≤ (sSup (dualValSet p beta)) ^ 2 := by obtain ⟨w, hw, hw_norm⟩ := exists_moment_le_dual_of_momentSol_nonempty hmoment_nonempty have hw_unbiased : UnbiasedWeights beta k p w := (key w).mpr hw have hnorm_nonneg : 0 ≤ ∑ j, |w j| := sum_nonneg (fun j _ => abs_nonneg (w j)) have hsq : (∑ j, |w j|) ^ 2 ≤ (sSup (dualValSet p beta)) ^ 2 := sq_le_sq' (by linarith) hw_norm calc sInf A ≤ (∑ j, |w j|) ^ 2 := csInf_le hA_bdd ⟨w, hw_unbiased, rfl⟩ _ ≤ (sSup (dualValSet p beta)) ^ 2 := hsq unfold amplification change sInf A = (sSup (dualValSet p beta)) ^ 2 exact le_antisymm hAmp_upper hAmp_lower
CausalSmith.Experimentation.RolloutChebyshev.amplification_dual_norm · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/Amplification.lean:25
theorem lagrange_endpoint_weights_unbiased

Lagrange endpoint weights on any k+1 distinct nodes reproduce the endpoint contrast for all polynomials of degree at most β when β ≤ k, hence satisfy the moment equations for W_β(p).

Formal statement
beta k :
p :
Fin (k + 1) → ℝ
hk :
beta ≤ k
hp :
UnbiasedWeights beta k p (fun j => (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 1 - (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 0)
Proof (Lean source)
lemma lagrange_endpoint_weights_unbiased (beta k : ℕ) (p : Fin (k + 1) → ℝ) (hk : beta ≤ k) (hp : Injective p) : UnbiasedWeights beta k p (fun j => (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 1 - (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 0) := by classical let w : Fin (k + 1) → ℝ := fun j => (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 1 - (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 0 have hmoment : ∀ ell : ℕ, ell ≤ beta → ∑ j : Fin (k + 1), w j * (p j) ^ ell = (1 : ℝ) ^ ell - (0 : ℝ) ^ ell := by intro ell hle let P : Polynomial ℝ := (Polynomial.X : Polynomial ℝ) ^ ell have hdeg : P.degree < (Finset.univ : Finset (Fin (k + 1))).card := by dsimp [P] rw [Fintype.card_fin, Polynomial.degree_X_pow] norm_cast exact Nat.lt_succ_of_le (le_trans hle hk) have hinterp : P = Lagrange.interpolate (Finset.univ : Finset (Fin (k + 1))) p (fun j => P.eval (p j)) := by exact Lagrange.eq_interpolate (s := (Finset.univ : Finset (Fin (k + 1)))) (v := p) hp.injOn hdeg have h1 := congrArg (fun Q : Polynomial ℝ => Q.eval 1) hinterp have h0 := congrArg (fun Q : Polynomial ℝ => Q.eval 0) hinterp have hsum1 : (1 : ℝ) ^ ell = ∑ j : Fin (k + 1), (p j) ^ ell * (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 1 := by simpa [P, Lagrange.interpolate_apply, Polynomial.eval_finset_sum, Polynomial.eval_mul, mul_comm, mul_left_comm, mul_assoc] using h1 have hsum0 : (0 : ℝ) ^ ell = ∑ j : Fin (k + 1), (p j) ^ ell * (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 0 := by simpa [P, Lagrange.interpolate_apply, Polynomial.eval_finset_sum, Polynomial.eval_mul, mul_comm, mul_left_comm, mul_assoc] using h0 calc ∑ j : Fin (k + 1), w j * (p j) ^ ell = ∑ j : Fin (k + 1), ((p j) ^ ell * (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 1 - (p j) ^ ell * (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 0) := by apply Finset.sum_congr rfl intro j _ simp [w] ring _ = (∑ j : Fin (k + 1), (p j) ^ ell * (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 1) - (∑ j : Fin (k + 1), (p j) ^ ell * (basis (Finset.univ : Finset (Fin (k + 1))) p j).eval 0) := by rw [Finset.sum_sub_distrib] _ = (1 : ℝ) ^ ell - (0 : ℝ) ^ ell := by rw [← hsum1, ← hsum0] constructor · simpa [w] using hmoment 0 (by omega) · intro ell hell hle have h := hmoment ell hle simpa [w, one_pow, zero_pow (ne_of_gt hell)] using h
CausalSmith.Experimentation.RolloutChebyshev.lagrange_endpoint_weights_unbiased · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/Amplification.lean:116
theorem unbiased_weight_set_nonempty Lemma 8 in the paper ↗

For β ≥ 1 and k ≥ β, the linear-unbiased weight set W_β(p) is nonempty for every budgeted schedule p ∈ S_{k,q}: distinct nodes make the (β+1)×(k+1) moment matrix full row rank (a nonzero degree-≤β polynomial cannot vanish at k+1 ≥ β+1 distinct points), so w ↦ Bw is surjective onto the target moment vector.

Formal statement
beta k :
q :
p :
Fin (k + 1) → ℝ
_hbeta :
1 ≤ beta
hk :
beta ≤ k
hp :
∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w
Proof (Lean source)
lemma unbiased_weight_set_nonempty (beta k : ℕ) (q : ℝ) (p : Fin (k + 1) → ℝ) (_hbeta : 1 ≤ beta) (hk : beta ≤ k) (hp : BudgetedSchedule k q p) : ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w := by exact ⟨_, lagrange_endpoint_weights_unbiased beta k p hk hp.2.2.1.injective⟩
CausalSmith.Experimentation.RolloutChebyshev.unbiased_weight_set_nonempty · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/Amplification.lean:176
Helpers.ChebyshevEndpoint 5 declarations
theorem chebyshev_eval_eq_lambda_average Lemma chebyshev_eval_eq_lambda_average in the paper ↗

Closed form for the Chebyshev polynomial outside its oscillation interval: at any point x ≥ 1, writing λ = x + √(x² - 1) for the associated growth factor, the degree-n Chebyshev polynomial satisfies T_n(x) = (λⁿ + λ⁻ⁿ)/2. Equivalently, setting x = cosh a gives T_n(x) = cosh(n a) and λ = eᵃ.

Formal statement
n :
x :
hx :
1 ≤ x
(T ℝ (n : ℤ)).eval x
= ((x + sqrt (x ^ 2 - 1)) ^ n + ((x + sqrt (x ^ 2 - 1)) ^ n)⁻¹) / 2
Proof (Lean source)
lemma chebyshev_eval_eq_lambda_average (n : ℕ) (x : ℝ) (hx : 1 ≤ x) : (T ℝ (n : ℤ)).eval x = ((x + sqrt (x ^ 2 - 1)) ^ n + ((x + sqrt (x ^ 2 - 1)) ^ n)⁻¹) / 2 := by let a := Real.arcosh x have hcosh : Real.cosh a = x := by simpa [a] using Real.cosh_arcosh hx have hexp : exp a = x + sqrt (x ^ 2 - 1) := by simpa [a] using Real.exp_arcosh hx calc (T ℝ (n : ℤ)).eval x = (T ℝ (n : ℤ)).eval (Real.cosh a) := by rw [hcosh] _ = Real.cosh ((n : ℤ) * a) := by simp _ = (exp ((n : ℤ) * a) + exp (-((n : ℤ) * a))) / 2 := by rw [Real.cosh_eq] _ = ((x + sqrt (x ^ 2 - 1)) ^ n + ((x + sqrt (x ^ 2 - 1)) ^ n)⁻¹) / 2 := by rw [Real.exp_neg] have hcast : ((n : ℤ) : ℝ) = (n : ℝ) := by norm_num rw [hcast, Real.exp_nat_mul, hexp]
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_eval_eq_lambda_average · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevEndpoint.lean:19

The endpoint growth factor is larger for tighter budgets: writing λ(q) = x_q + √(x_q² - 1) with x_q = 2/q - 1, one has λ(q_max) ≤ λ(q) whenever 0 < q ≤ q_max < 1.

Formal statement
q qmax :
hq :
0 < q
hqq :
q ≤ qmax
hqmax_lt :
qmax < 1
(2 / qmax - 1) + sqrt ((2 / qmax - 1) ^ 2 - 1)
≤ (2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)
Proof (Lean source)
lemma endpoint_lambda_mono {q qmax : ℝ} (hq : 0 < q) (hqq : q ≤ qmax) (hqmax_lt : qmax < 1) : (2 / qmax - 1) + sqrt ((2 / qmax - 1) ^ 2 - 1) ≤ (2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1) := by have hqmax_pos : 0 < qmax := lt_of_lt_of_le hq hqq let xq := 2 / q - 1 let xm := 2 / qmax - 1 have hxm_pos : 0 < xm := by have hdiv : 1 < 1 / qmax := one_lt_one_div hqmax_pos hqmax_lt dsimp [xm] nlinarith [show 2 / qmax = 2 * (1 / qmax) by ring] have hxm_one : 1 ≤ xm := by have hdiv : 1 < 1 / qmax := one_lt_one_div hqmax_pos hqmax_lt dsimp [xm] nlinarith [show 2 / qmax = 2 * (1 / qmax) by ring] have hxq_one : 1 ≤ xq := by have hq_lt_one : q < 1 := lt_of_le_of_lt hqq hqmax_lt have hdiv : 1 < 1 / q := one_lt_one_div hq hq_lt_one dsimp [xq] nlinarith [show 2 / q = 2 * (1 / q) by ring] have hxm_le_xq : xm ≤ xq := by have hinv : 1 / qmax ≤ 1 / q := one_div_le_one_div_of_le hq hqq dsimp [xm, xq] nlinarith [show 2 / q = 2 * (1 / q) by ring, show 2 / qmax = 2 * (1 / qmax) by ring] have harc : Real.arcosh xm ≤ Real.arcosh xq := by exact (Real.arcosh_le_arcosh hxm_pos (lt_of_lt_of_le zero_lt_one hxq_one)).2 hxm_le_xq have hexp_le : exp (Real.arcosh xm) ≤ exp (Real.arcosh xq) := Real.exp_monotone harc simpa [xq, xm, Real.exp_arcosh hxm_one, Real.exp_arcosh hxq_one] using hexp_le
CausalSmith.Experimentation.RolloutChebyshev.endpoint_lambda_mono · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevEndpoint.lean:46
theorem chebyshev_lambda_average_add_one_le Lemma chebyshev_lambda_average_add_one_le in the paper ↗

Upper envelope for the endpoint value: for a growth factor λ ≥ 1 and an order n ≥ 1, (λⁿ + λ⁻ⁿ)/2 + 1 ≤ 2 λⁿ.

Formal statement
lam :
hlam :
1 ≤ lam
n :
_hn :
1 ≤ n
(lam ^ n + (lam ^ n)⁻¹) / 2 + 1 ≤ 2 * lam ^ n
Proof (Lean source)
lemma chebyshev_lambda_average_add_one_le {lam : ℝ} (hlam : 1 ≤ lam) {n : ℕ} (_hn : 1 ≤ n) : (lam ^ n + (lam ^ n)⁻¹) / 2 + 1 ≤ 2 * lam ^ n := by have hpow_ge_one : 1 ≤ lam ^ n := one_le_pow₀ hlam have hinv_le : (lam ^ n)⁻¹ ≤ lam ^ n := by calc (lam ^ n)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hpow_ge_one _ ≤ lam ^ n := hpow_ge_one nlinarith
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_lambda_average_add_one_le · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevEndpoint.lean:84
theorem chebyshev_lambda_average_sub_one_ge Lemma chebyshev_lambda_average_sub_one_ge in the paper ↗

Matching lower envelope for the endpoint value, with a constant that depends only on a floor for the growth factor: if λ ≥ λ₀ > 1 and the order satisfies n ≥ 1, then (λⁿ + λ⁻ⁿ)/2 - 1 ≥ ½ (1 - λ₀⁻¹)² λⁿ.

Formal statement
lam lam0 :
h0 :
1 < lam0
hge :
lam0 ≤ lam
n :
hn :
1 ≤ n
(lam ^ n + (lam ^ n)⁻¹) / 2 - 1 ≥ (1 / 2) * (1 - lam0⁻¹) ^ 2 * lam ^ n
Proof (Lean source)
lemma chebyshev_lambda_average_sub_one_ge {lam lam0 : ℝ} (h0 : 1 < lam0) (hge : lam0 ≤ lam) {n : ℕ} (hn : 1 ≤ n) : (lam ^ n + (lam ^ n)⁻¹) / 2 - 1 ≥ (1 / 2) * (1 - lam0⁻¹) ^ 2 * lam ^ n := by have hlam_pos : 0 < lam := lt_of_lt_of_le (lt_trans zero_lt_one h0) hge have hpow_pos : 0 < lam ^ n := pow_pos hlam_pos n have hpow_ge_lam0 : lam0 ≤ lam ^ n := by calc lam0 ≤ lam := hge _ ≤ lam ^ n := by exact le_self_pow₀ (le_trans (le_of_lt h0) hge) (by omega) have hinv_le : (lam ^ n)⁻¹ ≤ lam0⁻¹ := (inv_le_inv₀ (lt_of_lt_of_le (lt_trans zero_lt_one h0) hpow_ge_lam0) (lt_trans zero_lt_one h0)).mpr hpow_ge_lam0 have hsub_ge : 1 - lam0⁻¹ ≤ 1 - (lam ^ n)⁻¹ := by linarith have hnonneg : 0 ≤ 1 - lam0⁻¹ := by have hle : lam0⁻¹ ≤ 1 := inv_le_one_of_one_le₀ (le_of_lt h0) linarith have hsquare : (1 - lam0⁻¹) ^ 2 ≤ (1 - (lam ^ n)⁻¹) ^ 2 := by exact pow_le_pow_left₀ hnonneg hsub_ge 2 have halg : (lam ^ n + (lam ^ n)⁻¹) / 2 - 1 = (1 / 2) * (1 - (lam ^ n)⁻¹) ^ 2 * lam ^ n := by field_simp [ne_of_gt hpow_pos] ring rw [halg] gcongr
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_lambda_average_sub_one_ge · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevEndpoint.lean:100
theorem continuous_chebyshev_endpoint_bound Lemma 6 in the paper ↗

Endpoint growth: writing x_q = 2/q - 1, λ(q) = x_q + √(x_q² - 1), for every degree-β polynomial R with sup_{[-1,1]} |R| ≤ 1 the endpoint contrast obeys the uniform upper bound |R(x_q) - R(-1)| ≤ C(q_max) λ(q)^β, and the Chebyshev polynomial T_β supplies the matching lower order T_β(x_q) - 1 ≥ c(q_max) λ(q)^β, both uniform over q ∈ (0, q_max] (via x_q = cosh a, T_β(x_q) = cosh(β a), λ(q) = eᵃ). Uses chebyshev_exterior_extremal.

Formal statement
qmax :
hqmax :
0 < qmax ∧ qmax < 1
∃ Cupper clower : ℝ
if
0 < Cupper ∧ 0 < clower ∧ ∀ (beta : ℕ) (q : ℝ), 1 ≤ beta
and
0 < q
and
q ≤ qmax
then
(∀ R : Polynomial ℝ, R.natDegree ≤ beta → (∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ 1) → |R.eval (2 / q - 1) - R.eval (-1)| ≤ Cupper * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta) ∧
(T ℝ (beta : ℤ)).eval (2 / q - 1) - 1
≥ clower * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta
Proof (Lean source)
lemma continuous_chebyshev_endpoint_bound (qmax : ℝ) (hqmax : 0 < qmax ∧ qmax < 1) : ∃ Cupper clower : ℝ, 0 < Cupper ∧ 0 < clower ∧ ∀ (beta : ℕ) (q : ℝ), 1 ≤ beta → 0 < q → q ≤ qmax → (∀ R : Polynomial ℝ, R.natDegree ≤ beta → (∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ 1) → |R.eval (2 / q - 1) - R.eval (-1)| ≤ Cupper * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta) ∧ (T ℝ (beta : ℤ)).eval (2 / q - 1) - 1 ≥ clower * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta := by let lam0 := (2 / qmax - 1) + sqrt ((2 / qmax - 1) ^ 2 - 1) have hlam0_gt : 1 < lam0 := by have hx : 1 < 2 / qmax - 1 := by have hdiv : 1 < 1 / qmax := one_lt_one_div hqmax.1 hqmax.2 nlinarith [show 2 / qmax = 2 * (1 / qmax) by ring] have hs : 0 ≤ sqrt ((2 / qmax - 1) ^ 2 - 1) := Real.sqrt_nonneg _ dsimp [lam0] nlinarith refine ⟨2, (1 / 2) * (1 - lam0⁻¹) ^ 2, by norm_num, ?_, ?_⟩ · have hinv : lam0⁻¹ < 1 := inv_lt_one_of_one_lt₀ hlam0_gt have hsub : 0 < 1 - lam0⁻¹ := by linarith positivity · intro beta q hbeta hq hqle let xq := 2 / q - 1 let lam := xq + sqrt (xq ^ 2 - 1) have hq_lt_one : q < 1 := lt_of_le_of_lt hqle hqmax.2 have hxq_gt : 1 < xq := by have hdiv : 1 < 1 / q := one_lt_one_div hq hq_lt_one dsimp [xq] nlinarith [show 2 / q = 2 * (1 / q) by ring] have hxq_one : 1 ≤ xq := le_of_lt hxq_gt have hlam_gt : 1 < lam := by have hs : 0 ≤ sqrt (xq ^ 2 - 1) := Real.sqrt_nonneg _ dsimp [lam] nlinarith have hlam0_le_lam : lam0 ≤ lam := by simpa [lam0, lam, xq] using endpoint_lambda_mono (q := q) (qmax := qmax) hq hqle hqmax.2 constructor · intro R hdeg hbound have hcheb_abs := chebyshev_exterior_extremal beta hbeta R hdeg hbound xq hxq_gt have hRneg : |R.eval (-1)| ≤ 1 := hbound (-1) (by constructor <;> norm_num) have htri : |R.eval xq - R.eval (-1)| ≤ |R.eval xq| + |R.eval (-1)| := by simpa using (abs_sub_le (R.eval xq) 0 (R.eval (-1))) have hTupper : (T ℝ (beta : ℤ)).eval xq + 1 ≤ 2 * lam ^ beta := by rw [chebyshev_eval_eq_lambda_average beta xq hxq_one] simpa [lam] using chebyshev_lambda_average_add_one_le (lam := lam) (le_of_lt hlam_gt) hbeta calc |R.eval (2 / q - 1) - R.eval (-1)| = |R.eval xq - R.eval (-1)| := by rfl _ ≤ |R.eval xq| + |R.eval (-1)| := htri _ ≤ (T ℝ (beta : ℤ)).eval xq + 1 := add_le_add hcheb_abs hRneg _ ≤ 2 * lam ^ beta := hTupper _ = 2 * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta := by rfl · have hlower := chebyshev_lambda_average_sub_one_ge (lam := lam) (lam0 := lam0) hlam0_gt hlam0_le_lam hbeta rw [chebyshev_eval_eq_lambda_average beta xq hxq_one] simpa [lam, lam0, xq] using hlower
CausalSmith.Experimentation.RolloutChebyshev.continuous_chebyshev_endpoint_bound · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevEndpoint.lean:135
Helpers.ChebyshevExtremal 3 declarations
theorem neg_one_pow_mul_le_of_abs_le_one Lemma neg_one_pow_mul_le_of_abs_le_one in the paper ↗

A real number of absolute value at most one remains at most one after multiplication by a sign (-1)ⁱ. Arithmetic step in the alternation argument, where polynomial values at the Chebyshev extremal nodes are compared against the alternating signs carried by those nodes.

Formal statement
a :
i :
ha :
|a| ≤ 1
(-1 : ℝ) ^ i * a ≤ 1
Proof (Lean source)
lemma neg_one_pow_mul_le_of_abs_le_one {a : ℝ} {i : ℕ} (ha : |a| ≤ 1) : (-1 : ℝ) ^ i * a ≤ 1 := by apply le_of_abs_le rwa [abs_mul, abs_neg_one_pow, one_mul]
CausalSmith.Experimentation.RolloutChebyshev.neg_one_pow_mul_le_of_abs_le_one · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevExtremal.lean:23
theorem chebyshev_exterior_lagrange_coeff_nonneg Lemma chebyshev_exterior_lagrange_coeff_nonneg in the paper ↗

Sign pattern of Lagrange interpolation coefficients at an exterior point: interpolating on the n + 1 Chebyshev extremal nodes of [-1, 1], the i-th Lagrange basis polynomial evaluated at any point x₀ > 1 agrees in sign with (-1)ⁱ, i.e. (-1)ⁱ ℓ_i(x₀) ≥ 0 for every index i ≤ n.

Formal statement
n i :
hi :
i ∈ Iic n
x0 :
hx0 :
1 < x0
0 ≤ (-1 : ℝ) ^ i * (basis (Iic n) (node n) i).eval x0
Proof (Lean source)
lemma chebyshev_exterior_lagrange_coeff_nonneg {n i : ℕ} (hi : i ∈ Iic n) {x0 : ℝ} (hx0 : 1 < x0) : 0 ≤ (-1 : ℝ) ^ i * (basis (Iic n) (node n) i).eval x0 := by classical rw [basis, Polynomial.eval_prod] simp only [Lagrange.basisDivisor, Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_sub, Polynomial.eval_X] rw [Finset.prod_mul_distrib] have hnum_pos : 0 < ∏ j ∈ (Iic n).erase i, (x0 - node n j) := by refine Finset.prod_pos ?_ intro j hj have hnode_le_one : node n j ≤ 1 := (Polynomial.Chebyshev.node_mem_Icc (n := n) (i := j)).2 linarith have hden_signed_pos : 0 < (-1 : ℝ) ^ i * ∏ j ∈ (Iic n).erase i, (node n i - node n j) := by have hi_le : i ≤ n := Finset.mem_Iic.mp hi have hleft : 0 < ∏ j ∈ range i, ((-1 : ℝ) * (node n i - node n j)) := by refine Finset.prod_pos ?_ intro j hj have hji : j < i := Finset.mem_range.mp hj have hlt : node n i < node n j := Polynomial.Chebyshev.node_lt hi_le hji nlinarith rw [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_range] at hleft have hright : 0 < ∏ j ∈ Finset.Ioc i n, (node n i - node n j) := by refine Finset.prod_pos ?_ intro j hj have hji : i < j := (Finset.mem_Ioc.mp hj).1 have hjn : j ≤ n := (Finset.mem_Ioc.mp hj).2 have hlt : node n j < node n i := Polynomial.Chebyshev.node_lt hjn hji linarith have hunion : (Iic n).erase i = range i ∪ Finset.Ioc i n := by ext j simp only [Finset.mem_erase, Finset.mem_Iic, mem_union, Finset.mem_range, Finset.mem_Ioc] omega have hdisjoint : Disjoint (range i) (Finset.Ioc i n) := by rw [Finset.disjoint_iff_ne] intro a ha b hb have hai : a < i := Finset.mem_range.mp ha have hib : i < b := (Finset.mem_Ioc.mp hb).1 omega rw [hunion, Finset.prod_union hdisjoint] rw [← mul_assoc] exact mul_pos hleft hright have hden_inv_signed_pos : 0 < (-1 : ℝ) ^ i * ∏ j ∈ (Iic n).erase i, (node n i - node n j)⁻¹ := by have hi_le : i ≤ n := Finset.mem_Iic.mp hi have hleft : 0 < ∏ j ∈ range i, ((-1 : ℝ) * (node n i - node n j)⁻¹) := by refine Finset.prod_pos ?_ intro j hj have hji : j < i := Finset.mem_range.mp hj have hlt : node n i < node n j := Polynomial.Chebyshev.node_lt hi_le hji have hinv_neg : (node n i - node n j)⁻¹ < 0 := inv_lt_zero'.mpr (by linarith) nlinarith rw [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_range] at hleft have hright : 0 < ∏ j ∈ Finset.Ioc i n, (node n i - node n j)⁻¹ := by refine Finset.prod_pos ?_ intro j hj have hji : i < j := (Finset.mem_Ioc.mp hj).1 have hjn : j ≤ n := (Finset.mem_Ioc.mp hj).2 have hlt : node n j < node n i := Polynomial.Chebyshev.node_lt hjn hji exact inv_pos.mpr (by linarith) have hunion : (Iic n).erase i = range i ∪ Finset.Ioc i n := by ext j simp only [Finset.mem_erase, Finset.mem_Iic, mem_union, Finset.mem_range, Finset.mem_Ioc] omega have hdisjoint : Disjoint (range i) (Finset.Ioc i n) := by rw [Finset.disjoint_iff_ne] intro a ha b hb have hai : a < i := Finset.mem_range.mp ha have hib : i < b := (Finset.mem_Ioc.mp hb).1 omega rw [hunion, Finset.prod_union hdisjoint] rw [← mul_assoc] exact mul_pos hleft hright have hprod_pos : 0 < ((-1 : ℝ) ^ i * ∏ j ∈ (Iic n).erase i, (node n i - node n j)⁻¹) * ∏ j ∈ (Iic n).erase i, (x0 - node n j) := mul_pos hden_inv_signed_pos hnum_pos exact le_of_lt (lt_of_lt_of_eq hprod_pos (by ring))
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_exterior_lagrange_coeff_nonneg · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevExtremal.lean:32
theorem chebyshev_exterior_extremal Lemma 4 in the paper ↗

Classical exterior-point Chebyshev extremal inequality (Rivlin1974): every real polynomial P of degree ≤ β with sup_{[-1,1]} |P| ≤ 1 satisfies |P(x₀)| ≤ T_β(x₀) for every x₀ > 1. The formal proof uses the equivalent Lagrange-interpolation form of the alternation argument: the exterior evaluation functional has the Chebyshev alternating signs on the extremal nodes.

Formal statement
beta :
_hbeta :
1 ≤ beta
P :
hdeg :
P.natDegree ≤ beta
hbound :
∀ x : ℝ
if
x ∈ Icc (-1 : ℝ) 1
then
|P.eval x| ≤ 1
x0 :
hx0 :
1 < x0
|P.eval x0| ≤ (T ℝ (beta : ℤ)).eval x0
Proof (Lean source)
lemma chebyshev_exterior_extremal (beta : ℕ) (_hbeta : 1 ≤ beta) (P : Polynomial ℝ) (hdeg : P.natDegree ≤ beta) (hbound : ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |P.eval x| ≤ 1) (x0 : ℝ) (hx0 : 1 < x0) : |P.eval x0| ≤ (T ℝ (beta : ℤ)).eval x0 := by classical let s : Finset ℕ := Finset.Iic beta let v : ℕ → ℝ := Polynomial.Chebyshev.node beta let T : Polynomial ℝ := T ℝ (beta : ℤ) have hvs : InjOn v s := by simpa [s, v, Nat.range_succ_eq_Iic] using (Polynomial.Chebyshev.strictAntiOn_node beta).injOn have hcard : s.card = beta + 1 := by simp [s] have hTdegree : T.degree < (s.card : WithBot ℕ) := by dsimp [T] rw [hcard, Polynomial.Chebyshev.degree_T, Int.natAbs_natCast] exact WithBot.coe_lt_coe.mpr (Nat.lt_succ_self beta) have upper : ∀ Q : Polynomial ℝ, Q.natDegree ≤ beta → (∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |Q.eval x| ≤ 1) → Q.eval x0 ≤ T.eval x0 := by intro Q hQdeg hQbound have hQdegree : Q.degree < (s.card : WithBot ℕ) := by rw [hcard] exact lt_of_le_of_lt (show Q.degree ≤ (Q.natDegree : WithBot ℕ) from Polynomial.degree_le_natDegree) (WithBot.coe_lt_coe.mpr (Nat.lt_succ_of_le hQdeg)) have hQinterp := Lagrange.eq_interpolate (s := s) (v := v) hvs hQdegree have hTinterp := Lagrange.eq_interpolate (s := s) (v := v) hvs hTdegree have hQeval : Q.eval x0 = ∑ i ∈ s, Q.eval (v i) * (basis s v i).eval x0 := by have h := congrArg (fun R : Polynomial ℝ => R.eval x0) hQinterp simpa [Lagrange.interpolate_apply, Polynomial.eval_finset_sum, Polynomial.eval_mul, mul_comm, mul_left_comm, mul_assoc] using h have hTeval : T.eval x0 = ∑ i ∈ s, T.eval (v i) * (basis s v i).eval x0 := by have h := congrArg (fun R : Polynomial ℝ => R.eval x0) hTinterp simpa [Lagrange.interpolate_apply, Polynomial.eval_finset_sum, Polynomial.eval_mul, mul_comm, mul_left_comm, mul_assoc] using h rw [hQeval, hTeval] refine Finset.sum_le_sum ?_ intro i hi have hi_le : i ≤ beta := by simpa [s] using hi have hnode_mem : v i ∈ Icc (-1 : ℝ) 1 := by simpa [v] using (Polynomial.Chebyshev.node_mem_Icc (n := beta) (i := i)) have hcoeff_nonneg : 0 ≤ (-1 : ℝ) ^ i * (basis s v i).eval x0 := by simpa [s, v] using (chebyshev_exterior_lagrange_coeff_nonneg (n := beta) (i := i) (by simpa [s] using hi) hx0) calc Q.eval (v i) * (basis s v i).eval x0 = ((-1 : ℝ) ^ i * Q.eval (v i)) * ((-1 : ℝ) ^ i * (basis s v i).eval x0) := by have hsignsq : (-1 : ℝ) ^ i * (-1 : ℝ) ^ i = 1 := by rw [← pow_add] have heven : Even (i + i) := ⟨i, by omega⟩ simp [heven.neg_one_pow] calc Q.eval (v i) * (basis s v i).eval x0 = 1 * (Q.eval (v i) * (basis s v i).eval x0) := by ring _ = (((-1 : ℝ) ^ i) * ((-1 : ℝ) ^ i)) * (Q.eval (v i) * (basis s v i).eval x0) := by rw [hsignsq] _ = ((-1 : ℝ) ^ i * Q.eval (v i)) * ((-1 : ℝ) ^ i * (basis s v i).eval x0) := by ring _ ≤ 1 * ((-1 : ℝ) ^ i * (basis s v i).eval x0) := by exact mul_le_mul_of_nonneg_right (neg_one_pow_mul_le_of_abs_le_one (hQbound (v i) hnode_mem)) hcoeff_nonneg _ = T.eval (v i) * (basis s v i).eval x0 := by rw [one_mul] change (-1 : ℝ) ^ i * (basis s v i).eval x0 = (T ℝ (beta : ℕ)).eval (Polynomial.Chebyshev.node beta i) * (basis s v i).eval x0 rw [Polynomial.Chebyshev.eval_T_real_node (show i ∈ Finset.Iic beta from by simpa [s] using hi)] have hupper := upper P hdeg hbound have hneg_upper : (-P).eval x0 ≤ T.eval x0 := by refine upper (-P) ?_ ?_ · simpa using hdeg · intro x hx simpa using hbound x hx have hupper' : P.eval x0 ≤ (T ℝ (beta : ℤ)).eval x0 := by simpa [T] using hupper have hneg_upper' : -P.eval x0 ≤ (T ℝ (beta : ℤ)).eval x0 := by simpa [T] using hneg_upper exact abs_le.mpr ⟨by linarith, hupper'⟩
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_exterior_extremal · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevExtremal.lean:152
Helpers.ChebyshevSchedule 1 declarations
theorem chebyshev_schedule_admissible Lemma 7 in the paper ↗

For every integer k ≥ 1 and q ∈ (0,1], the shifted Chebyshev-Lobatto schedule p^Ch(k,q) belongs to S_{k,q}: endpoints 0 and q, with strict monotonicity from the strict decrease of cosine on [0,π]. This lemma is the load-bearing member that pins the Chebyshev schedule's core space p^Ch(k,q) ∈ [0,1]^(k+1): its conclusion BudgetedSchedule has as first conjunct ∀ j, p^Ch(k,q) j ∈ Set.Icc 0 1, i.e. the [0,1]^(k+1) range, holding exactly under the admissibility hypotheses k ≥ 1 and q ∈ (0,1]. The range predicate hq : 0 < q ∧ q ≤ 1 realizes the core space q ∈ (0,1]. @realizes p^Ch(k,q)(range [0,1]^(k+1): BudgetedSchedule Icc conjunct; k≥1, q∈(0,1]) @realizes q(carrier ℝ; range 0 < q ≤ 1 via hq — the p^Ch admissibility range)

Formal statement
k :
q :
hk :
1 ≤ k
hq :
0 < q ∧ q ≤ 1
Proof (Lean source)
lemma chebyshev_schedule_admissible (k : ℕ) (q : ℝ) (hk : 1 ≤ k) (hq : 0 < q ∧ q ≤ 1) : -- @realizes q(0 < q ∧ q ≤ 1) BudgetedSchedule k q (chebyshevSchedule k q) := by -- @realizes p^Ch(k,q)(∈ [0,1]^(k+1) via BudgetedSchedule.1) have hkpos_nat : 0 < k := by omega have hkpos : (0 : ℝ) < (k : ℝ) := by exact_mod_cast hkpos_nat refine ⟨?range, ?zero, ?mono, ?last⟩ · intro j unfold chebyshevSchedule have hcos_le : cos (pi * (j : ℝ) / (k : ℝ)) ≤ 1 := Real.cos_le_one _ have hcos_ge : -1 ≤ cos (pi * (j : ℝ) / (k : ℝ)) := Real.neg_one_le_cos _ constructor · have hnonneg : 0 ≤ 1 - cos (pi * (j : ℝ) / (k : ℝ)) := by linarith nlinarith [hq.1] · have hle2 : 1 - cos (pi * (j : ℝ) / (k : ℝ)) ≤ 2 := by linarith have hmul : q * (1 - cos (pi * (j : ℝ) / (k : ℝ))) ≤ q * 2 := mul_le_mul_of_nonneg_left hle2 (le_of_lt hq.1) nlinarith [hq.2] · simp [chebyshevSchedule] · intro a b hab have hb_le_nat : (b : ℕ) ≤ k := Nat.le_of_lt_succ b.isLt have hb_le : (b : ℝ) ≤ (k : ℝ) := by exact_mod_cast hb_le_nat have hθa_nonneg : 0 ≤ pi * (a : ℝ) / (k : ℝ) := by positivity have hratio_le : (b : ℝ) / (k : ℝ) ≤ 1 := (div_le_one hkpos).2 hb_le have hθb_le_pi : pi * (b : ℝ) / (k : ℝ) ≤ pi := by calc pi * (b : ℝ) / (k : ℝ) = pi * ((b : ℝ) / (k : ℝ)) := by ring _ ≤ pi * 1 := mul_le_mul_of_nonneg_left hratio_le (le_of_lt Real.pi_pos) _ = pi := by ring have hab_nat : (a : ℕ) < (b : ℕ) := by exact_mod_cast hab have hab_real : (a : ℝ) < (b : ℝ) := by exact_mod_cast hab_nat have hmul_arg : pi * (a : ℝ) < pi * (b : ℝ) := mul_lt_mul_of_pos_left hab_real Real.pi_pos have hθlt : pi * (a : ℝ) / (k : ℝ) < pi * (b : ℝ) / (k : ℝ) := (div_lt_div_iff_of_pos_right hkpos).2 hmul_arg have hcos : cos (pi * (b : ℝ) / (k : ℝ)) < cos (pi * (a : ℝ) / (k : ℝ)) := Real.cos_lt_cos_of_nonneg_of_le_pi hθa_nonneg hθb_le_pi hθlt unfold chebyshevSchedule have hdiff : 1 - cos (pi * (a : ℝ) / (k : ℝ)) < 1 - cos (pi * (b : ℝ) / (k : ℝ)) := by linarith have hmul : q * (1 - cos (pi * (a : ℝ) / (k : ℝ))) < q * (1 - cos (pi * (b : ℝ) / (k : ℝ))) := mul_lt_mul_of_pos_left hdiff hq.1 nlinarith · unfold chebyshevSchedule have hk_ne : (k : ℝ) ≠ 0 := ne_of_gt hkpos simp [hk_ne, Real.cos_pi] ring
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_schedule_admissible · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ChebyshevSchedule.lean:17
Helpers.EhlichZeller 3 declarations
def EhlichZellerMesh

SUBSTRATE-GATE (gate_class: gated). The Ehlich–Zeller Chebyshev-Lobatto mesh/norming inequality (Ehlich, H. and Zeller, K. (1964). Schwankung von Polynomen zwischen Gitterpunkten. Mathematische Zeitschrift 86, 41–44): for a real polynomial R of degree ≤ β with β < k, sup_{[-1,1]} |R| ≤ sec(π β / (2k)) · max_{0≤j≤k} |R(-cos(π j / k))|.

Definition (Lean source)
def EhlichZellerMesh : Prop := ∀ (beta k : ℕ) (R : Polynomial ℝ), R.natDegree ≤ beta → beta < k → ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ (1 / cos (pi * (beta : ℝ) / (2 * (k : ℝ)))) * Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|)
CausalSmith.Experimentation.RolloutChebyshev.EhlichZellerMesh · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EhlichZeller.lean:22
theorem ehlichZellerMesh

The local gate proposition is discharged by the reusable substrate implementation.

Formal statement
Proof (Lean source)
lemma ehlichZellerMesh : EhlichZellerMesh := by intro beta k R hdeg hlt x hx let nodeVal : ℕ → ℝ := fun j => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))| let finNodeVal : Fin (k + 1) → ℝ := fun j => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))| have hmesh_le : Causalean.Mathlib.Analysis.EhlichZellerMesh.czMeshMax R k ≤ Finset.univ.sup' univ_nonempty finNodeVal := by unfold Causalean.Mathlib.Analysis.EhlichZellerMesh.czMeshMax Causalean.Mathlib.Analysis.EhlichZellerMesh.czNode have hnonneg0 : sSup (∅ : Set ℝ) ≤ nodeVal 0 := by simp [nodeVal] have hmem : (⨆ j ∈ range (k + 1), nodeVal j) ∈ image nodeVal (range (k + 1)) := Finset.ciSup_mem_image nodeVal ⟨0, by simp, hnonneg0⟩ rcases Finset.mem_image.mp hmem with ⟨j, hj, hj_eq⟩ change (⨆ j ∈ range (k + 1), nodeVal j) ≤ Finset.univ.sup' univ_nonempty finNodeVal rw [← hj_eq] let jf : Fin (k + 1) := ⟨j, by simpa using hj⟩ exact Finset.le_sup' (s := univ) (f := finNodeVal) (Finset.mem_univ jf) have hcoef_nonneg : 0 ≤ 1 / cos (pi * (beta : ℝ) / (2 * (k : ℝ))) := by have hk_nat : 0 < k := by omega have hk_pos : (0 : ℝ) < (k : ℝ) := by exact_mod_cast hk_nat have hbeta_lt : (beta : ℝ) < (k : ℝ) := by exact_mod_cast hlt have hangle_lt : pi * (beta : ℝ) / (2 * (k : ℝ)) < pi / 2 := by field_simp [ne_of_gt hk_pos] nlinarith [Real.pi_pos, hbeta_lt] exact one_div_nonneg.mpr (le_of_lt (Real.cos_pos_of_mem_Ioo ⟨by have hangle_nonneg : 0 ≤ pi * (beta : ℝ) / (2 * (k : ℝ)) := by positivity linarith [hangle_nonneg, Real.pi_pos] , hangle_lt⟩)) have hbdd : BddAbove ((fun x => |R.eval x|) '' Icc (-1 : ℝ) 1) := by refine ⟨Causalean.Mathlib.Analysis.EhlichZellerMesh.czSup R, ?_⟩ rintro y ⟨x, hx, rfl⟩ let t := arccos (-x) have ht : t ∈ Icc (0 : ℝ) pi := ⟨Real.arccos_nonneg (-x), Real.arccos_le_pi (-x)⟩ have hcos : -cos t = x := by have hx₁ : -1 ≤ -x := by linarith [hx.2] have hx₂ : -x ≤ 1 := by linarith [hx.1] simp [t, Real.cos_arccos hx₁ hx₂] simpa [czTrig, hcos] using Causalean.Mathlib.Analysis.EhlichZellerMesh.abs_czTrig_le_czSup R ht have hpoint : |R.eval x| ≤ sSup ((fun x => |R.eval x|) '' Icc (-1 : ℝ) 1) := le_csSup hbdd ⟨x, hx, rfl⟩ have hbound := ehlichZeller_mesh_bound R beta k hdeg hlt exact hpoint.trans (hbound.trans (mul_le_mul_of_nonneg_left hmesh_le hcoef_nonneg))
CausalSmith.Experimentation.RolloutChebyshev.ehlichZellerMesh · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EhlichZeller.lean:40
theorem oversampled_chebyshev_lobatto_norming Lemma 5 in the paper ↗

Gate consumer: for c > 1, there is a finite constant K(c) (namely sec(π/(2c))) such that for every β ≥ 1, every integer k ≥ c·β, and every degree-≤β polynomial R, sup_{[-1,1]} |R| ≤ K(c) · max_{0≤j≤k} |R(-cos(π j / k))|. Its only hard step is the gated Ehlich–Zeller mesh inequality (threaded as hmesh); the rest is sec monotonicity from β/k ≤ 1/c. Proved conditional on the gate.

Formal statement
c :
hc :
1 < c
∃ K : ℝ,
0 < K ∧
∀ (beta k : ℕ) (R : Polynomial ℝ),
1
≤ beta → (k : ℝ) ≥ c * beta → R.natDegree ≤ beta → ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ K * Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|)
Proof (Lean source)
lemma oversampled_chebyshev_lobatto_norming (hmesh : EhlichZellerMesh) (c : ℝ) (hc : 1 < c) : ∃ K : ℝ, 0 < K ∧ ∀ (beta k : ℕ) (R : Polynomial ℝ), 1 ≤ beta → (k : ℝ) ≥ c * beta → R.natDegree ≤ beta → ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ K * Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|) := by let K : ℝ := 1 / cos (pi / (2 * c)) refine ⟨K, ?_, ?_⟩ · have hcpos : 0 < c := lt_trans zero_lt_one hc have hangle_pos : 0 < pi / (2 * c) := div_pos Real.pi_pos (mul_pos (by norm_num) hcpos) have hangle_lt : pi / (2 * c) < pi / 2 := by exact div_lt_div_of_pos_left Real.pi_pos (by norm_num) (by nlinarith [hc]) exact one_div_pos.mpr (Real.cos_pos_of_mem_Ioo ⟨by linarith, hangle_lt⟩) · intro beta k R hbeta hkR hdeg x hx have hbeta_pos_nat : 0 < beta := by omega have hbeta_pos : 0 < (beta : ℝ) := by exact_mod_cast hbeta_pos_nat have hcpos : 0 < c := lt_trans zero_lt_one hc have hkpos : 0 < (k : ℝ) := by have hcbeta_pos : 0 < c * (beta : ℝ) := mul_pos hcpos hbeta_pos exact lt_of_lt_of_le hcbeta_pos hkR have hbeta_lt_k : beta < k := by have hbeta_lt_cbeta : (beta : ℝ) < c * (beta : ℝ) := by nlinarith [hc, hbeta_pos] have hbeta_lt_k_real : (beta : ℝ) < (k : ℝ) := lt_of_lt_of_le hbeta_lt_cbeta hkR exact_mod_cast hbeta_lt_k_real have hmesh_bound := hmesh beta k R hdeg hbeta_lt_k x hx have hratio : (beta : ℝ) / (k : ℝ) ≤ 1 / c := by rw [div_le_iff₀ hkpos] field_simp [ne_of_gt hcpos] nlinarith [hkR] have hangle_le : pi * (beta : ℝ) / (2 * (k : ℝ)) ≤ pi / (2 * c) := by calc pi * (beta : ℝ) / (2 * (k : ℝ)) = (pi / 2) * ((beta : ℝ) / (k : ℝ)) := by field_simp [ne_of_gt hkpos] _ ≤ (pi / 2) * (1 / c) := by exact mul_le_mul_of_nonneg_left hratio (by positivity) _ = pi / (2 * c) := by field_simp [ne_of_gt hcpos] have hangleA_nonneg : 0 ≤ pi * (beta : ℝ) / (2 * (k : ℝ)) := by positivity have hangleB_le_pi : pi / (2 * c) ≤ pi := by rw [div_le_iff₀ (mul_pos (by norm_num) hcpos)] nlinarith [Real.pi_pos, hc] have hcos_le : cos (pi / (2 * c)) ≤ cos (pi * (beta : ℝ) / (2 * (k : ℝ))) := Real.cos_le_cos_of_nonneg_of_le_pi hangleA_nonneg hangleB_le_pi hangle_le have hangleB_lt : pi / (2 * c) < pi / 2 := by exact div_lt_div_of_pos_left Real.pi_pos (by norm_num) (by nlinarith [hc]) have hangleB_pos : 0 < pi / (2 * c) := div_pos Real.pi_pos (mul_pos (by norm_num) hcpos) have hcosB_pos : 0 < cos (pi / (2 * c)) := Real.cos_pos_of_mem_Ioo ⟨by linarith, hangleB_lt⟩ have hcoef_le : 1 / cos (pi * (beta : ℝ) / (2 * (k : ℝ))) ≤ K := by dsimp [K] exact one_div_le_one_div_of_le hcosB_pos hcos_le have hsup_nonneg : 0 ≤ Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|) := by let j0 : Fin (k + 1) := 0 exact (abs_nonneg _).trans (Finset.le_sup' (s := univ) (f := fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|) (Finset.mem_univ j0)) exact hmesh_bound.trans (mul_le_mul_of_nonneg_right hcoef_le hsup_nonneg)
CausalSmith.Experimentation.RolloutChebyshev.oversampled_chebyshev_lobatto_norming · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EhlichZeller.lean:98
Helpers.EqualSpacing 3 declarations
theorem equalSchedule_injective Lemma equalSchedule_injective in the paper ↗

The equal-spacing benchmark schedule p^eq(β,q) = (0, q/β, 2q/β, ..., q) has distinct nodes: whenever the order satisfies β ≥ 1 and the budget q is positive, distinct round indices give distinct treated fractions. Node distinctness is the premise under which Lagrange interpolation on this grid — and hence the dual description of the amplification — is available.

Formal statement
beta :
q :
hbeta :
1 ≤ beta
hq :
0 < q
Proof (Lean source)
lemma equalSchedule_injective (beta : ℕ) (q : ℝ) (hbeta : 1 ≤ beta) (hq : 0 < q) : Injective (equalSchedule beta q) := by intro a b hab have hbeta_pos_nat : 0 < beta := by omega have hbeta_ne : (beta : ℝ) ≠ 0 := by exact_mod_cast (ne_of_gt hbeta_pos_nat) have hq_ne : q ≠ 0 := ne_of_gt hq have hreal : (a : ℝ) = (b : ℝ) := by dsimp [equalSchedule] at hab field_simp [hbeta_ne, hq_ne] at hab linarith exact Fin.ext (by exact_mod_cast hreal)
CausalSmith.Experimentation.RolloutChebyshev.equalSchedule_injective · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EqualSpacing.lean:18
theorem equalSchedule_lagrange_basis_eval_one_le Lemma equalSchedule_lagrange_basis_eval_one_le in the paper ↗

Size of the Lagrange basis at full treatment on the equal grid: for order β ≥ 1 and budget q ∈ (0,1], the j-th Lagrange basis polynomial for the equal-spacing schedule p^eq(β,q) obeys |ℓ_j(1)| ≤ (β/q)^β / (j! (β - j)!) at the extrapolation point 1.

Formal statement
beta :
q :
hbeta :
1 ≤ beta
hq :
0 < q ∧ q ≤ 1
j :
Fin (beta + 1)
|(basis (Finset.univ : Finset (Fin (beta + 1))) (equalSchedule beta q) j).eval 1|
≤ ((beta : ℝ) / q) ^ beta / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ))
Proof (Lean source)
lemma equalSchedule_lagrange_basis_eval_one_le (beta : ℕ) (q : ℝ) (hbeta : 1 ≤ beta) (hq : 0 < q ∧ q ≤ 1) (j : Fin (beta + 1)) : |(basis (Finset.univ : Finset (Fin (beta + 1))) (equalSchedule beta q) j).eval 1| ≤ ((beta : ℝ) / q) ^ beta / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ)) := by classical let S : Finset (Fin (beta + 1)) := Finset.univ let p : Fin (beta + 1) → ℝ := equalSchedule beta q have hbeta_pos_nat : 0 < beta := by omega have hbeta_pos : 0 < (beta : ℝ) := by exact_mod_cast hbeta_pos_nat have hbeta_ne : (beta : ℝ) ≠ 0 := ne_of_gt hbeta_pos have hq_pos : 0 < q := hq.1 have hq_ne : q ≠ 0 := ne_of_gt hq_pos have hcard : (S.erase j).card = beta := by simp [S] have hden_fin : (∏ m ∈ S.erase j, |(j.val : ℝ) - (m.val : ℝ)|) = (j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ) := by have hjle : j.val ≤ beta := Nat.le_of_lt_succ j.isLt calc (∏ m ∈ S.erase j, |(j.val : ℝ) - (m.val : ℝ)|) = ∏ m ∈ (Iic beta).erase j.val, |(j.val : ℝ) - (m : ℝ)| := by refine Finset.prod_bij (fun m _ => m.val) ?_ ?_ ?_ ?_ · intro m hm rcases Finset.mem_erase.mp hm with ⟨hmne, _⟩ exact Finset.mem_erase.mpr ⟨by exact fun h => hmne (Fin.ext h), by simpa using Nat.le_of_lt_succ m.isLt⟩ · intro a ha b hb hval exact Fin.ext hval · intro m hm rcases Finset.mem_erase.mp hm with ⟨hmne, hmle⟩ refine ⟨⟨m, Nat.lt_succ_of_le (Finset.mem_Iic.mp hmle)⟩, ?_, rfl⟩ exact Finset.mem_erase.mpr ⟨by exact fun h => hmne (congrArg val h), by simp [S]⟩ · intro m hm rfl _ = (j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ) := prod_Iic_erase_abs_sub_eq_factorial beta j.val hjle have hbasis : |(basis S p j).eval 1| = ∏ m ∈ S.erase j, |((p j - p m)⁻¹) * (1 - p m)| := by simp [S, p, basis, Lagrange.basisDivisor, Polynomial.eval_prod, Finset.abs_prod, abs_mul, abs_inv] have hfactor : ∀ m ∈ S.erase j, |((p j - p m)⁻¹) * (1 - p m)| ≤ ((beta : ℝ) / q) * |(j.val : ℝ) - (m.val : ℝ)|⁻¹ := by intro m hm rcases Finset.mem_erase.mp hm with ⟨hmne, _⟩ have hmle : (m.val : ℝ) ≤ (beta : ℝ) := by exact_mod_cast Nat.le_of_lt_succ m.isLt have hpm_le_one : p m ≤ 1 := by have hleq : q * (m.val : ℝ) / (beta : ℝ) ≤ q := by calc q * (m.val : ℝ) / (beta : ℝ) ≤ q * (beta : ℝ) / (beta : ℝ) := by gcongr _ = q := by field_simp [hbeta_ne] exact hleq.trans hq.2 have hpm_nonneg : 0 ≤ p m := by dsimp [p, equalSchedule] positivity have hnum : |1 - p m| ≤ 1 := by rw [abs_le] constructor <;> linarith have hdiff_ne : (j.val : ℝ) - (m.val : ℝ) ≠ 0 := by intro hzero have hval : j.val = m.val := by exact_mod_cast sub_eq_zero.mp hzero exact hmne (Fin.ext hval.symm) have hpdiff : p j - p m = (q / (beta : ℝ)) * ((j.val : ℝ) - (m.val : ℝ)) := by dsimp [p, equalSchedule] ring have hscale_pos : 0 < q / (beta : ℝ) := div_pos hq_pos hbeta_pos calc |((p j - p m)⁻¹) * (1 - p m)| = |1 - p m| * |p j - p m|⁻¹ := by rw [abs_mul, abs_inv, mul_comm] _ ≤ 1 * |p j - p m|⁻¹ := by exact mul_le_mul_of_nonneg_right hnum (inv_nonneg.mpr (abs_nonneg _)) _ = ((beta : ℝ) / q) * |(j.val : ℝ) - (m.val : ℝ)|⁻¹ := by rw [hpdiff, abs_mul, abs_of_pos hscale_pos] field_simp [hbeta_ne, hq_ne, hdiff_ne] calc |(basis (Finset.univ : Finset (Fin (beta + 1))) (equalSchedule beta q) j).eval 1| = |(basis S p j).eval 1| := by rfl _ = ∏ m ∈ S.erase j, |((p j - p m)⁻¹) * (1 - p m)| := hbasis _ ≤ ∏ m ∈ S.erase j, ((beta : ℝ) / q) * |(j.val : ℝ) - (m.val : ℝ)|⁻¹ := by refine Finset.prod_le_prod ?_ hfactor intro m hm positivity _ = ((beta : ℝ) / q) ^ beta * (∏ m ∈ S.erase j, |(j.val : ℝ) - (m.val : ℝ)|)⁻¹ := by rw [Finset.prod_mul_distrib, Finset.prod_const, hcard, Finset.prod_inv_distrib] _ = ((beta : ℝ) / q) ^ beta / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ)) := by rw [hden_fin] ring
CausalSmith.Experimentation.RolloutChebyshev.equalSchedule_lagrange_basis_eval_one_le · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EqualSpacing.lean:35
theorem equal_spacing_benchmark Proposition 1 in the paper ↗

Equal-spacing benchmark: A_β(p^eq(β,q)) ≤ 9 (β/q)^{2β} for every integer β ≥ 1 and every q ∈ (0,1] (the universal constant C_eq = 9). Constructed via Lagrange-basis weights on the equal grid with the ℓ¹ bound ∑|w_j| ≤ 3 (β/q)^β, plus the endpoint case at q = 1. The leading conjunct ∀ j, p^eq(β,q) j ∈ [0,1] realizes the schedule's core space p^eq(β,q) ∈ [0,1]^(β+1) (the range clause the note states for the benchmark grid); the second conjunct is the amplification bound proper. The range predicate hq : 0 < q ∧ q ≤ 1 realizes the core space q ∈ (0,1]. @realizes p^eq(beta,q)(range [0,1]^(β+1): Icc conjunct on conclusion; β≥1, q∈(0,1]) @realizes q(carrier ℝ; range 0 < q ≤ 1 via hq)

Formal statement
beta :
q :
hbeta :
1 ≤ beta
hq :
0 < q ∧ q ≤ 1
(∀ j, equalSchedule beta q j ∈ Icc (0 : ℝ) 1) ∧
amplification beta beta (equalSchedule beta q) ≤ 9 * ((beta : ℝ) / q) ^ (2 * beta)
Proof (Lean source)
lemma equal_spacing_benchmark (beta : ℕ) (q : ℝ) (hbeta : 1 ≤ beta) (hq : 0 < q ∧ q ≤ 1) : -- @realizes q(0 < q ∧ q ≤ 1) (∀ j, equalSchedule beta q j ∈ Icc (0 : ℝ) 1) ∧ -- @realizes p^eq(beta,q)(∈[0,1]^(β+1)) amplification beta beta (equalSchedule beta q) ≤ 9 * ((beta : ℝ) / q) ^ (2 * beta) := by classical have hbeta_pos_nat : 0 < beta := by omega have hbeta_pos : 0 < (beta : ℝ) := by exact_mod_cast hbeta_pos_nat have hbeta_ne : (beta : ℝ) ≠ 0 := ne_of_gt hbeta_pos have hq_pos : 0 < q := hq.1 have hq_ne : q ≠ 0 := ne_of_gt hq_pos have hrange : ∀ j, equalSchedule beta q j ∈ Icc (0 : ℝ) 1 := by intro j constructor · dsimp [equalSchedule] positivity · have hjle : (j.val : ℝ) ≤ (beta : ℝ) := by exact_mod_cast Nat.le_of_lt_succ j.isLt have hleq : q * (j.val : ℝ) / (beta : ℝ) ≤ q := by calc q * (j.val : ℝ) / (beta : ℝ) ≤ q * (beta : ℝ) / (beta : ℝ) := by gcongr _ = q := by field_simp [hbeta_ne] exact hleq.trans hq.2 refine ⟨hrange, ?_⟩ let p : Fin (beta + 1) → ℝ := equalSchedule beta q let w : Fin (beta + 1) → ℝ := fun j => (basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 1 - (basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0 have hp : Injective p := by simpa [p] using equalSchedule_injective beta q hbeta hq_pos have hw : UnbiasedWeights beta beta p w := by simpa [w] using lagrange_endpoint_weights_unbiased beta beta p (le_refl beta) hp have hA_le : amplification beta beta p ≤ (∑ j, |w j|) ^ 2 := by unfold amplification apply csInf_le · use 0 intro x hx rcases hx with ⟨w', hw', rfl⟩ positivity · exact ⟨w, hw, rfl⟩ have hy_ge_one : 1 ≤ (beta : ℝ) / q := by rw [le_div_iff₀ hq_pos] have hbeta_one : (1 : ℝ) ≤ (beta : ℝ) := by exact_mod_cast hbeta nlinarith [hq.2] have hy_nonneg : 0 ≤ (beta : ℝ) / q := le_trans (by norm_num) hy_ge_one have hsum_eval1 : (∑ j : Fin (beta + 1), |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 1|) ≤ 2 * ((beta : ℝ) / q) ^ beta := by calc (∑ j : Fin (beta + 1), |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 1|) ≤ ∑ j : Fin (beta + 1), ((beta : ℝ) / q) ^ beta / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ)) := by refine Finset.sum_le_sum ?_ intro j hj simpa [p] using equalSchedule_lagrange_basis_eval_one_le beta q hbeta hq j _ = ((beta : ℝ) / q) ^ beta * (∑ j : Fin (beta + 1), (1 : ℝ) / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ))) := by rw [Finset.mul_sum] refine Finset.sum_congr rfl ?_ intro j hj ring _ ≤ ((beta : ℝ) / q) ^ beta * 2 := by exact mul_le_mul_of_nonneg_left (factorial_reciprocal_sum_le_two beta hbeta) (pow_nonneg hy_nonneg beta) _ = 2 * ((beta : ℝ) / q) ^ beta := by ring have hsum_eval0 : (∑ j : Fin (beta + 1), |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0|) = 1 := by let z : Fin (beta + 1) := 0 have hpz : p z = 0 := by simp [p, equalSchedule, z] calc (∑ j : Fin (beta + 1), |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0|) = ∑ j : Fin (beta + 1), if j = z then (1 : ℝ) else 0 := by refine Finset.sum_congr rfl ?_ intro j hj by_cases hz : j = z · subst j have heval : (basis (Finset.univ : Finset (Fin (beta + 1))) p z).eval (p z) = 1 := by simpa using Lagrange.eval_basis_self hp.injOn (Finset.mem_univ z) have hzero : (basis (Finset.univ : Finset (Fin (beta + 1))) p z).eval 0 = 1 := by simpa [hpz] using heval simp [hzero] · have heval : (basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval (p z) = 0 := by simpa using Lagrange.eval_basis_of_ne hz (Finset.mem_univ z) have hzero : (basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0 = 0 := by simpa [hpz] using heval simp [hzero, hz] _ = 1 := by norm_num [Finset.sum_ite_eq', z] have hsumw : (∑ j, |w j|) ≤ 3 * ((beta : ℝ) / q) ^ beta := by calc (∑ j, |w j|) ≤ ∑ j : Fin (beta + 1), (|(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 1| + |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0|) := by refine Finset.sum_le_sum ?_ intro j hj dsimp [w] simpa using (abs_sub_le ((basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 1) 0 ((basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0)) _ = (∑ j : Fin (beta + 1), |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 1|) + (∑ j : Fin (beta + 1), |(basis (Finset.univ : Finset (Fin (beta + 1))) p j).eval 0|) := by rw [Finset.sum_add_distrib] _ ≤ 2 * ((beta : ℝ) / q) ^ beta + 1 := by exact add_le_add hsum_eval1 (le_of_eq hsum_eval0) _ ≤ 3 * ((beta : ℝ) / q) ^ beta := by have hpow_ge_one : 1 ≤ ((beta : ℝ) / q) ^ beta := one_le_pow₀ hy_ge_one nlinarith have hsumw_nonneg : 0 ≤ ∑ j, |w j| := by positivity have hbound_nonneg : 0 ≤ 3 * ((beta : ℝ) / q) ^ beta := by positivity calc amplification beta beta (equalSchedule beta q) = amplification beta beta p := by rfl _ ≤ (∑ j, |w j|) ^ 2 := hA_le _ ≤ (3 * ((beta : ℝ) / q) ^ beta) ^ 2 := sq_le_sq' (by linarith) hsumw _ = 9 * ((beta : ℝ) / q) ^ (2 * beta) := by calc (3 * ((beta : ℝ) / q) ^ beta) ^ 2 = 9 * (((beta : ℝ) / q) ^ beta) ^ 2 := by ring _ = 9 * ((beta : ℝ) / q) ^ (beta * 2) := by rw [pow_mul] _ = 9 * ((beta : ℝ) / q) ^ (2 * beta) := by ring_nf
CausalSmith.Experimentation.RolloutChebyshev.equal_spacing_benchmark · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EqualSpacing.lean:139
Helpers.EqualSpacingArithmetic 3 declarations
theorem prod_Iic_erase_abs_sub_eq_factorial Lemma prod_Iic_erase_abs_sub_eq_factorial in the paper ↗

On the integer grid {0, 1, ..., β}, the product of the distances from a fixed index i to all the other indices equals i! (β - i)!.

Formal statement
beta i :
hi :
i ≤ beta
(∏ m ∈ (Iic beta).erase i, |(i : ℝ) - (m : ℝ)|)
= (i.factorial : ℝ) * ((beta - i).factorial : ℝ)
Proof (Lean source)
lemma prod_Iic_erase_abs_sub_eq_factorial (beta i : ℕ) (hi : i ≤ beta) : (∏ m ∈ (Iic beta).erase i, |(i : ℝ) - (m : ℝ)|) = (i.factorial : ℝ) * ((beta - i).factorial : ℝ) := by classical have hunion : (Iic beta).erase i = range i ∪ Finset.Ioc i beta := by ext m simp only [Finset.mem_erase, Finset.mem_Iic, mem_union, Finset.mem_range, Finset.mem_Ioc] omega have hdisjoint : Disjoint (range i) (Finset.Ioc i beta) := by rw [Finset.disjoint_iff_ne] intro a ha b hb have hai : a < i := Finset.mem_range.mp ha have hib : i < b := (Finset.mem_Ioc.mp hb).1 omega have hleft : (∏ m ∈ range i, |(i : ℝ) - (m : ℝ)|) = (i.factorial : ℝ) := by calc (∏ m ∈ range i, |(i : ℝ) - (m : ℝ)|) = ∏ m ∈ range i, (((i - 1 - m) + 1 : ℕ) : ℝ) := by refine Finset.prod_congr rfl ?_ intro m hm have hmi : m < i := Finset.mem_range.mp hm have hmi_real : (m : ℝ) ≤ (i : ℝ) := by exact_mod_cast Nat.le_of_lt hmi have hnonneg : 0 ≤ (i : ℝ) - (m : ℝ) := by linarith rw [abs_of_nonneg hnonneg] have hn : i - m = (i - 1 - m) + 1 := by omega have hsub_eq : (i : ℝ) - (m : ℝ) = ((i - m : ℕ) : ℝ) := by have h := Nat.sub_add_cancel (Nat.le_of_lt hmi) have hreal : ((i - m : ℕ) : ℝ) + (m : ℝ) = (i : ℝ) := by exact_mod_cast h linarith rw [hsub_eq] exact_mod_cast hn _ = ∏ m ∈ range i, (((m + 1 : ℕ) : ℝ)) := by rw [Finset.prod_range_reflect (fun m => (((m + 1 : ℕ) : ℝ))) i] _ = (i.factorial : ℝ) := by exact_mod_cast Finset.prod_range_add_one_eq_factorial i have hright : (∏ m ∈ Finset.Ioc i beta, |(i : ℝ) - (m : ℝ)|) = ((beta - i).factorial : ℝ) := by have hIoc : Finset.Ioc i beta = Ico (i + 1) (beta + 1) := by ext m simp only [Finset.mem_Ioc, Finset.mem_Ico] omega calc (∏ m ∈ Finset.Ioc i beta, |(i : ℝ) - (m : ℝ)|) = ∏ m ∈ Ico (i + 1) (beta + 1), |(i : ℝ) - (m : ℝ)| := by rw [hIoc] _ = ∏ r ∈ range (beta + 1 - (i + 1)), |(i : ℝ) - ((i + 1 + r : ℕ) : ℝ)| := by rw [Finset.prod_Ico_eq_prod_range] _ = ∏ r ∈ range (beta - i), (((r + 1 : ℕ) : ℝ)) := by refine Finset.prod_congr ?_ ?_ · congr 1 omega · intro r hr have hnonpos : (i : ℝ) - ((i + 1 + r : ℕ) : ℝ) ≤ 0 := by have hle : (i : ℝ) ≤ ((i + 1 + r : ℕ) : ℝ) := by exact_mod_cast (by omega : i ≤ i + 1 + r) linarith rw [abs_of_nonpos hnonpos] have hcast : ((i + 1 + r : ℕ) : ℝ) = (i : ℝ) + 1 + (r : ℝ) := by norm_num have hr : ((r + 1 : ℕ) : ℝ) = (r : ℝ) + 1 := by norm_num linarith _ = ((beta - i).factorial : ℝ) := by exact_mod_cast Finset.prod_range_add_one_eq_factorial (beta - i) rw [hunion, Finset.prod_union hdisjoint, hleft, hright]
CausalSmith.Experimentation.RolloutChebyshev.prod_Iic_erase_abs_sub_eq_factorial · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EqualSpacingArithmetic.lean:18
theorem two_pow_le_two_mul_factorial Lemma two_pow_le_two_mul_factorial in the paper ↗

For every natural number n ≥ 1, 2ⁿ ≤ 2 · n!. Arithmetic step that converts the binomial total 2^β arising in the equal-spacing weight bound into a factorial denominator.

Formal statement
n :
hn :
1 ≤ n
2 ^ n ≤ 2 * n.factorial
Proof (Lean source)
lemma two_pow_le_two_mul_factorial (n : ℕ) (hn : 1 ≤ n) : 2 ^ n ≤ 2 * n.factorial := by induction n with | zero => omega | succ n ih => cases n with | zero => norm_num | succ n => have hprev : 2 ^ (n + 1) ≤ 2 * (n + 1).factorial := ih (by omega) calc 2 ^ (n + 2) = 2 * 2 ^ (n + 1) := by ring _ ≤ 2 * (2 * (n + 1).factorial) := Nat.mul_le_mul_left 2 hprev _ ≤ 2 * (n + 2).factorial := by have hmul : 2 * (n + 1).factorial ≤ (n + 2) * (n + 1).factorial := Nat.mul_le_mul_right _ (by omega) have hfact : (n + 2).factorial = (n + 2) * (n + 1).factorial := by rw [show n + 2 = succ (n + 1) by omega, Nat.factorial_succ] rw [hfact] exact Nat.mul_le_mul_left 2 hmul
CausalSmith.Experimentation.RolloutChebyshev.two_pow_le_two_mul_factorial · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EqualSpacingArithmetic.lean:93
theorem factorial_reciprocal_sum_le_two Lemma factorial_reciprocal_sum_le_two in the paper ↗

For every order β ≥ 1, the reciprocal-factorial sum ∑_{j=0}^{β} 1 / (j! (β - j)!) is at most 2; the sum in fact equals 2^β / β!, and the bound follows from 2^β ≤ 2 · β!.

Formal statement
beta :
hbeta :
1 ≤ beta
(∑ j : Fin (beta + 1), (1 : ℝ) / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ)))
≤ 2
Proof (Lean source)
lemma factorial_reciprocal_sum_le_two (beta : ℕ) (hbeta : 1 ≤ beta) : (∑ j : Fin (beta + 1), (1 : ℝ) / ((j.val.factorial : ℝ) * ((beta - j.val).factorial : ℝ))) ≤ 2 := by classical let f : ℕ → ℝ := fun j => (1 : ℝ) / ((j.factorial : ℝ) * ((beta - j).factorial : ℝ)) have hterm : ∀ j ∈ range (beta + 1), f j = (beta.choose j : ℝ) / (beta.factorial : ℝ) := by intro j hj have hjle : j ≤ beta := Nat.le_of_lt_succ (Finset.mem_range.mp hj) have hchoose : (beta.choose j : ℝ) * (j.factorial : ℝ) * ((beta - j).factorial : ℝ) = (beta.factorial : ℝ) := by exact_mod_cast Nat.choose_mul_factorial_mul_factorial hjle have hden_pos : 0 < (j.factorial : ℝ) * ((beta - j).factorial : ℝ) := by positivity have hfac_pos : 0 < (beta.factorial : ℝ) := by positivity dsimp [f] field_simp [ne_of_gt hden_pos, ne_of_gt hfac_pos] nlinarith have hsum : (∑ j ∈ range (beta + 1), f j) = (2 : ℝ) ^ beta / (beta.factorial : ℝ) := by calc (∑ j ∈ range (beta + 1), f j) = ∑ j ∈ range (beta + 1), (beta.choose j : ℝ) / (beta.factorial : ℝ) := by exact Finset.sum_congr rfl hterm _ = (∑ j ∈ range (beta + 1), (beta.choose j : ℝ)) / (beta.factorial : ℝ) := by simp [div_eq_mul_inv, Finset.sum_mul] _ = (2 : ℝ) ^ beta / (beta.factorial : ℝ) := by have hchoose_sum : (∑ j ∈ range (beta + 1), (beta.choose j : ℕ) : ℕ) = 2 ^ beta := Nat.sum_range_choose beta have hchoose_sum_real : (∑ j ∈ range (beta + 1), (beta.choose j : ℝ)) = ((2 ^ beta : ℕ) : ℝ) := by exact_mod_cast hchoose_sum rw [hchoose_sum_real] norm_num rw [Fin.sum_univ_eq_sum_range f (beta + 1)] rw [hsum] have hpow_fact_nat := two_pow_le_two_mul_factorial beta hbeta have hpow_fact_real : ((2 ^ beta : ℕ) : ℝ) ≤ ((2 * beta.factorial : ℕ) : ℝ) := by exact_mod_cast hpow_fact_nat have hfac_pos : 0 < (beta.factorial : ℝ) := by positivity rw [div_le_iff₀ hfac_pos] norm_num at hpow_fact_real ⊢ exact hpow_fact_real
CausalSmith.Experimentation.RolloutChebyshev.factorial_reciprocal_sum_le_two · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/EqualSpacingArithmetic.lean:115
Helpers.ExactRisk 2 declarations
def exactNestedMinimaxQuestion Remark 1 in the paper ↗

OPEN QUESTION (D0 residual oeq:exact-nested-minimax, status to-prove). Stated as a named Prop, NOT a theorem and NOT a proof obligation: it asks whether, in the low-budget regime with k = ⌈c·β⌉, the shifted Chebyshev-Lobatto schedule p^Ch(k,q) also solves the exact finite-population nested-rollout minimax problem R_exact(β,k,q) for the true monotone-Bernoulli covariance Γ_P(p) — i.e. its fixed-schedule exact risk attains exactNestedRisk, the infimum over S_{k,q}. Rate-feasibility (the provable half) is exact_chebyshev_rate_feasible; exact optimality is left open (no theorem depends on this).

Definition (Lean source)
def exactNestedMinimaxQuestion (c : ℝ) (n beta k : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (q qmax sigma0sq : ℝ) : Prop := 1 < c → 0 < q → LowBudgetCap q qmax → 1 ≤ beta → k = ⌈c * (beta : ℝ)⌉₊ → sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k (chebyshevSchedule k q) w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq (chebyshevSchedule k q) ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } = exactNestedRisk n k beta D q sigma0sq
CausalSmith.Experimentation.RolloutChebyshev.exactNestedMinimaxQuestion · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ExactRisk.lean:24
theorem exact_chebyshev_rate_feasible Proposition 3 in the paper ↗

Rate-feasibility of the Chebyshev-Lobatto schedule for the exact risk: for c > 1, β ≥ 1, k = ⌈c·β⌉, and q ∈ (0, q_max], the fixed-Chebyshev exact risk obeys inf_{w∈W_β(p^Ch)} sup_{P∈P_β} w'Γ_P(p^Ch)w ≤ (σ₀²/n) C₊(c,q_max) (ρ(q)/q)^{2β}, hence R_exact(β,k,q) ≤ (σ₀²/n) C₊(c,q_max) (ρ(q)/q)^{2β}. Pure composition of exact_risk_envelope_upper (applied to the admissible p^Ch via chebyshev_schedule_admissible) with the Chebyshev upper half of chebyshev_minimax. The range predicate hc : 1 < c realizes the core space c ∈ (1,∞); hq : 0 < q with hcap : LowBudgetCap q qmax realizes q ∈ (0,1]. @realizes c(carrier ℝ; range 1 < c via hc) @realizes q(carrier ℝ; range 0 < q ≤ q_max < 1 via hq + hcap)

Formal statement
c qmax :
hc :
1 < c
hqmax :
0 < qmax ∧ qmax < 1
∃ Cplus : ℝ
if
0 < Cplus ∧
∀ (n beta k : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (q sigma0sq : ℝ), 1 ≤ beta
and
0 < q
and
and
0 ≤ sigma0sq
and
k = ⌈c * (beta : ℝ)⌉₊
then
sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k (chebyshevSchedule k q) w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq (chebyshevSchedule k q) ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } }
≤ sigma0sq / (n : ℝ) * Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)
Proof (Lean source)
lemma exact_chebyshev_rate_feasible (c qmax : ℝ) (hc : 1 < c) (hqmax : 0 < qmax ∧ qmax < 1) : ∃ Cplus : ℝ, 0 < Cplus ∧ ∀ (n beta k : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (q sigma0sq : ℝ), 1 ≤ beta → 0 < q → LowBudgetCap q qmax → 0 ≤ sigma0sq → k = ⌈c * (beta : ℝ)⌉₊ → sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k (chebyshevSchedule k q) w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq (chebyshevSchedule k q) ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } ≤ sigma0sq / (n : ℝ) * Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) := by rcases chebyshev_minimax qmax hqmax with ⟨_, _, hcheb⟩ rcases hcheb c hc with ⟨Cplus, hCplus, hbounds⟩ refine ⟨Cplus, hCplus, ?_⟩ intro n beta k Ω _ D q sigma0sq hbeta hq hcap hsig hk have hk_real : c * (beta : ℝ) ≤ (k : ℝ) := by simpa [hk] using Nat.le_ceil (c * (beta : ℝ)) have hbeta_pos_real : 0 < (beta : ℝ) := by exact_mod_cast hbeta have hbeta_le_cbeta : (beta : ℝ) ≤ c * (beta : ℝ) := by nlinarith have hk_beta : beta ≤ k := by exact_mod_cast (le_trans hbeta_le_cbeta hk_real) have hq_le_one : q ≤ 1 := by linarith [hcap.2.1, hcap.2.2] have hq01 : 0 < q ∧ q ≤ 1 := ⟨hq, hq_le_one⟩ have hk_one : 1 ≤ k := le_trans hbeta hk_beta have hpCh : BudgetedSchedule k q (chebyshevSchedule k q) := chebyshev_schedule_admissible k q hk_one hq01 have hrisk := (exact_risk_envelope_upper n k beta D q sigma0sq hbeta hk_beta hq01 hsig (chebyshevSchedule k q) hpCh).1 have hupper := (hbounds beta k q hbeta hk_real hcap hq).2.1 have hscale_nonneg : 0 ≤ sigma0sq / (n : ℝ) := div_nonneg hsig (Nat.cast_nonneg n) calc sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k (chebyshevSchedule k q) w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq (chebyshevSchedule k q) ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } ≤ sigma0sq / (n : ℝ) * amplification beta k (chebyshevSchedule k q) := hrisk _ ≤ sigma0sq / (n : ℝ) * (Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)) := mul_le_mul_of_nonneg_left hupper hscale_nonneg _ = sigma0sq / (n : ℝ) * Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) := by ring
CausalSmith.Experimentation.RolloutChebyshev.exact_chebyshev_rate_feasible · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/ExactRisk.lean:51
Helpers.MinimaxAssembly 8 declarations
theorem chebyshev_lambda_eq_rho_div_q Lemma chebyshev_lambda_eq_rho_div_q in the paper ↗

The endpoint growth factor written directly in terms of the budget: for 0 < q < 1, (2/q - 1) + √((2/q - 1)² - 1) = (1 + √(1 - q))² / q.

Formal statement
q :
hq :
0 < q
hq_lt_one :
q < 1
(2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1) = (1 + sqrt (1 - q)) ^ 2 / q
Proof (Lean source)
lemma chebyshev_lambda_eq_rho_div_q {q : ℝ} (hq : 0 < q) (hq_lt_one : q < 1) : (2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1) = (1 + sqrt (1 - q)) ^ 2 / q := by have hsqrt_nonneg : 0 ≤ 2 * sqrt (1 - q) / q := by exact div_nonneg (mul_nonneg (by norm_num) (Real.sqrt_nonneg _)) (le_of_lt hq) have hrad_nonneg : 0 ≤ (2 / q - 1) ^ 2 - 1 := by field_simp [ne_of_gt hq] nlinarith [hq, hq_lt_one] have hsqrt : sqrt ((2 / q - 1) ^ 2 - 1) = 2 * sqrt (1 - q) / q := by rw [Real.sqrt_eq_iff_eq_sq hrad_nonneg hsqrt_nonneg] field_simp [ne_of_gt hq] ring_nf rw [Real.sq_sqrt (by linarith)] ring rw [hsqrt] field_simp [ne_of_gt hq] ring_nf rw [Real.sq_sqrt (by linarith)] ring
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_lambda_eq_rho_div_q · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:19
theorem amplification_nonneg

The total-variation amplification of a rollout schedule is never negative, being an infimum of squared total-variation norms of unbiased weight vectors. The bound also holds vacuously when no unbiased weights exist for the schedule, since an infimum over an empty set of reals is 0.

Formal statement
beta k :
p :
Fin (k + 1) → ℝ
0 ≤ amplification beta k p
Proof (Lean source)
lemma amplification_nonneg (beta k : ℕ) (p : Fin (k + 1) → ℝ) : 0 ≤ amplification beta k p := by unfold amplification apply Real.sInf_nonneg rintro v ⟨w, _hw, rfl⟩ exact sq_nonneg _
CausalSmith.Experimentation.RolloutChebyshev.amplification_nonneg · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:45
theorem minimaxAmplification_le_of_budgeted

Exhibiting one admissible design bounds the minimax value: if p is a budgeted rollout schedule with budget q on k + 1 rounds, then the minimax amplification M_{β,k,q} is at most that schedule's own amplification A_β(p). This is the direction used to convert an explicit design, such as the shifted Chebyshev–Lobatto grid, into an upper bound on the minimax value.

Formal statement
beta k :
q :
p :
Fin (k + 1) → ℝ
hp :
minimaxAmplification beta k q ≤ amplification beta k p
Proof (Lean source)
lemma minimaxAmplification_le_of_budgeted (beta k : ℕ) (q : ℝ) (p : Fin (k + 1) → ℝ) (hp : BudgetedSchedule k q p) : minimaxAmplification beta k q ≤ amplification beta k p := by unfold minimaxAmplification apply csInf_le · refine ⟨0, ?_⟩ rintro v ⟨p', _hp', rfl⟩ exact amplification_nonneg beta k p' · exact ⟨p, hp, rfl⟩
CausalSmith.Experimentation.RolloutChebyshev.minimaxAmplification_le_of_budgeted · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:56
theorem minimaxAmplification_lower_of_forall

A lower bound holding for every admissible design is a lower bound on the minimax value: if at least one budgeted schedule with budget q on k + 1 rounds exists, and every such schedule p satisfies B ≤ A_β(p), then B ≤ M_{β,k,q}.

Formal statement
beta k :
q B :
hne :
∃ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p
hlower :
∀ p : Fin (k + 1) → ℝ
then
B ≤ amplification beta k p
B ≤ minimaxAmplification beta k q
Proof (Lean source)
lemma minimaxAmplification_lower_of_forall (beta k : ℕ) (q B : ℝ) (hne : ∃ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p) (hlower : ∀ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p → B ≤ amplification beta k p) : B ≤ minimaxAmplification beta k q := by unfold minimaxAmplification refine le_csInf ?hneSet ?_ · rcases hne with ⟨p, hp⟩ exact ⟨amplification beta k p, p, hp, rfl⟩ · rintro v ⟨p, hp, rfl⟩ exact hlower p hp
CausalSmith.Experimentation.RolloutChebyshev.minimaxAmplification_lower_of_forall · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:71
theorem budgetedSchedule_le_endpoint

The budget is respected at every round: in a budgeted rollout schedule the treated fraction increases across rounds and equals q at the final round, so every round j has p_j ≤ q. This is what confines all schedule nodes to the budget window [0, q].

Formal statement
k :
q :
p :
Fin (k + 1) → ℝ
hp :
j :
Fin (k + 1)
p j ≤ q
Proof (Lean source)
lemma budgetedSchedule_le_endpoint {k : ℕ} {q : ℝ} {p : Fin (k + 1) → ℝ} (hp : BudgetedSchedule k q p) (j : Fin (k + 1)) : p j ≤ q := by have hlast : p (last k) = q := hp.2.2.2 have hjle : j ≤ last k := by exact Fin.le_last j have hmono : Monotone p := hp.2.2.1.monotone simpa [hlast] using hmono hjle
CausalSmith.Experimentation.RolloutChebyshev.budgetedSchedule_le_endpoint · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:90
theorem affine_mem_Icc_neg_one_one Lemma affine_mem_Icc_neg_one_one in the paper ↗

The change of variables carrying the budget window onto the Chebyshev interval is well-defined: with a positive budget q, any treated fraction u with 0 ≤ u ≤ q is mapped by u ↦ 2u/q - 1 into [-1, 1]. Under this reparametrisation the rollout schedule's nodes become points of the standard interval on which Chebyshev polynomials are bounded by one.

Formal statement
q u :
hq :
0 < q
hu0 :
0 ≤ u
huq :
u ≤ q
2 * u / q - 1 ∈ Icc (-1 : ℝ) 1
Proof (Lean source)
lemma affine_mem_Icc_neg_one_one {q u : ℝ} (hq : 0 < q) (hu0 : 0 ≤ u) (huq : u ≤ q) : 2 * u / q - 1 ∈ Icc (-1 : ℝ) 1 := by constructor · rw [le_sub_iff_add_le, neg_add_cancel] exact div_nonneg (mul_nonneg (by norm_num) hu0) (le_of_lt hq) · rw [sub_le_iff_le_add, show (1 : ℝ) + 1 = 2 by norm_num] rw [div_le_iff₀ hq] nlinarith
CausalSmith.Experimentation.RolloutChebyshev.affine_mem_Icc_neg_one_one · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:103
theorem chebyshev_affine_natDegree_le Lemma chebyshev_affine_natDegree_le in the paper ↗

Composing the degree-β Chebyshev polynomial with the affine rescaling u ↦ (2/q) u - 1 again yields a polynomial of degree at most β. Degree bookkeeping for the test polynomial used in the minimax lower bound, which must remain admissible for the degree-β dual problem after being transported from the standard interval to the budget window.

Formal statement
beta :
q :
((T ℝ (beta : ℤ)).comp (C (2 / q) * X - C 1)).natDegree
≤ beta
Proof (Lean source)
lemma chebyshev_affine_natDegree_le (beta : ℕ) (q : ℝ) : ((T ℝ (beta : ℤ)).comp (C (2 / q) * Polynomial.X - C 1)).natDegree ≤ beta := by calc ((T ℝ (beta : ℤ)).comp (C (2 / q) * Polynomial.X - C 1)).natDegree ≤ (T ℝ (beta : ℤ)).natDegree * (C (2 / q) * Polynomial.X - C 1).natDegree := Polynomial.natDegree_comp_le _ ≤ beta * 1 := by gcongr · simp [Polynomial.Chebyshev.natDegree_T, Int.natAbs_natCast] · exact Polynomial.natDegree_sub_le_of_le ((Polynomial.natDegree_C_mul_le (2 / q) (Polynomial.X : Polynomial ℝ)).trans Polynomial.natDegree_X_le) (by rw [Polynomial.natDegree_C (R := ℝ) (a := (1 : ℝ))]) _ = beta := by simp
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_affine_natDegree_le · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:117
theorem chebyshev_amplification_lower

No rollout design can beat the Chebyshev exponential base. Granted an endpoint growth bound for the Chebyshev polynomial with a positive constant c — that T_β(2/q - 1) - 1 ≥ c λ(q)^β uniformly over orders β ≥ 1 and budgets q ∈ (0, q_max] — EVERY budgeted rollout schedule p with budget q ≤ q_max < 1 on k + 1 rounds, where the number of rounds satisfies k ≥ β, has total-variation amplification at least c² · ((1 + √(1 - q))² / q)^{2β}.

Formal statement
qmax clower :
hclower_pos :
0 < clower
hendpoint_lower :
∀ (beta : ℕ) (q : ℝ)
if
1 ≤ beta
and
0 < q
and
q ≤ qmax
then
(T ℝ (beta : ℤ)).eval (2 / q - 1) - 1
≥ clower * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta
beta k :
q :
hbeta :
1 ≤ beta
hkβ :
beta ≤ k
hq :
0 < q
hqle :
q ≤ qmax
hqmax_lt :
qmax < 1
p :
Fin (k + 1) → ℝ
hp :
amplification beta k p ≥ clower ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)
Proof (Lean source)
lemma chebyshev_amplification_lower (qmax clower : ℝ) (hclower_pos : 0 < clower) (hendpoint_lower : ∀ (beta : ℕ) (q : ℝ), 1 ≤ beta → 0 < q → q ≤ qmax → (T ℝ (beta : ℤ)).eval (2 / q - 1) - 1 ≥ clower * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta) {beta k : ℕ} {q : ℝ} (hbeta : 1 ≤ beta) (hkβ : beta ≤ k) (hq : 0 < q) (hqle : q ≤ qmax) (hqmax_lt : qmax < 1) (p : Fin (k + 1) → ℝ) (hp : BudgetedSchedule k q p) : amplification beta k p ≥ clower ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) := by let lam : ℝ := (2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1) let dualSet : Set ℝ := { t : ℝ | ∃ r : Polynomial ℝ, r.natDegree ≤ beta ∧ (∀ j, |r.eval (p j)| ≤ 1) ∧ t = |r.eval 1 - r.eval 0| } let r : Polynomial ℝ := (T ℝ (beta : ℤ)).comp (C (2 / q) * X - C 1) have hq_lt_one : q < 1 := lt_of_le_of_lt hqle hqmax_lt have hxq_gt : 1 < 2 / q - 1 := by have hdiv : 1 < 1 / q := one_lt_one_div hq hq_lt_one nlinarith [show 2 / q = 2 * (1 / q) by ring] have hxq_one : 1 ≤ 2 / q - 1 := le_of_lt hxq_gt have hlam_gt : 1 < lam := by have hs : 0 ≤ sqrt ((2 / q - 1) ^ 2 - 1) := Real.sqrt_nonneg _ dsimp [lam] nlinarith have hlam_eq_base : lam = (1 + sqrt (1 - q)) ^ 2 / q := by dsimp [lam] exact chebyshev_lambda_eq_rho_div_q hq hq_lt_one have hne : ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w := unbiased_weight_set_nonempty beta k q p hbeta hkβ hp have hdual_eq : amplification beta k p = (sSup dualSet) ^ 2 := by simpa [dualSet] using (amplification_dual_norm beta k p hp.2.2.1.injective hne).2 have hdual_bdd : BddAbove dualSet := by dsimp [dualSet] simpa [_root_.Causalean.Mathlib.Analysis.FiniteDimL1LinfDuality.dualValSet] using (_root_.Causalean.Mathlib.Analysis.FiniteDimL1LinfDuality.dualValSet_bddAbove (p := p) (β := beta) (_root_.Causalean.Mathlib.Analysis.FiniteDimL1LinfDuality.primalNormSet_nonempty hp.2.2.1.injective hkβ)) have hrdeg : r.natDegree ≤ beta := by simpa [r] using chebyshev_affine_natDegree_le beta q have hrbound : ∀ j, |r.eval (p j)| ≤ 1 := by intro j have hu0 : 0 ≤ p j := (hp.1 j).1 have huq : p j ≤ q := budgetedSchedule_le_endpoint hp j have hxIcc : 2 * p j / q - 1 ∈ Icc (-1 : ℝ) 1 := affine_mem_Icc_neg_one_one hq hu0 huq have hxabs : |2 * p j / q - 1| ≤ 1 := by simpa [abs_le] using hxIcc have hxabs' : |2 / q * p j - 1| ≤ 1 := by have harg' : 2 / q * p j - 1 = 2 * p j / q - 1 := by field_simp [ne_of_gt hq] simpa [harg'] using hxabs have hcheb := Polynomial.Chebyshev.abs_eval_T_real_le_one (beta : ℤ) hxabs' have harg : (eval (p j) (C (2 / q) * X - C 1)) = 2 / q * p j - 1 := by simp simpa [r, Polynomial.eval_comp, harg] using hcheb have hmem : |r.eval 1 - r.eval 0| ∈ dualSet := by exact ⟨r, hrdeg, hrbound, rfl⟩ have hsup_ge_abs : |r.eval 1 - r.eval 0| ≤ sSup dualSet := le_csSup hdual_bdd hmem have hTlower : clower * lam ^ beta ≤ (T ℝ (beta : ℤ)).eval (2 / q - 1) - 1 := by simpa [lam] using hendpoint_lower beta q hbeta hq hqle have hTnonneg : 0 ≤ (T ℝ (beta : ℤ)).eval (2 / q - 1) := le_trans zero_le_one (Polynomial.Chebyshev.one_le_eval_T_real (beta : ℤ) hxq_one) have hTneg_abs : |(T ℝ (beta : ℤ)).eval (-1)| ≤ 1 := Polynomial.Chebyshev.abs_eval_T_real_le_one (beta : ℤ) (by norm_num) have hTminus_le_abs : (T ℝ (beta : ℤ)).eval (2 / q - 1) - 1 ≤ |(T ℝ (beta : ℤ)).eval (2 / q - 1) - (T ℝ (beta : ℤ)).eval (-1)| := by have hleft : |(T ℝ (beta : ℤ)).eval (2 / q - 1)| - |(T ℝ (beta : ℤ)).eval (-1)| ≤ |(T ℝ (beta : ℤ)).eval (2 / q - 1) - (T ℝ (beta : ℤ)).eval (-1)| := abs_sub_abs_le_abs_sub _ _ rw [abs_of_nonneg hTnonneg] at hleft nlinarith have hr_eval_one : r.eval 1 = (T ℝ (beta : ℤ)).eval (2 / q - 1) := by simp [r, Polynomial.eval_comp] have hr_eval_zero : r.eval 0 = (T ℝ (beta : ℤ)).eval (-1) := by simp [r, Polynomial.eval_comp] have hlower_abs : clower * lam ^ beta ≤ |r.eval 1 - r.eval 0| := by calc clower * lam ^ beta ≤ (T ℝ (beta : ℤ)).eval (2 / q - 1) - 1 := hTlower _ ≤ |(T ℝ (beta : ℤ)).eval (2 / q - 1) - (T ℝ (beta : ℤ)).eval (-1)| := hTminus_le_abs _ = |r.eval 1 - r.eval 0| := by rw [hr_eval_one, hr_eval_zero] have hdual_lower : clower * lam ^ beta ≤ sSup dualSet := hlower_abs.trans hsup_ge_abs have hleft_nonneg : 0 ≤ clower * lam ^ beta := mul_nonneg (le_of_lt hclower_pos) (pow_nonneg (le_of_lt (lt_trans zero_lt_one hlam_gt)) beta) have hpow : lam ^ (2 * beta) = (lam ^ beta) ^ 2 := by rw [Nat.mul_comm 2 beta, pow_mul] have htarget : clower ^ 2 * lam ^ (2 * beta) = (clower * lam ^ beta) ^ 2 := by rw [hpow] ring rw [hdual_eq, ← hlam_eq_base] rw [htarget] exact sq_le_sq' (by linarith [hleft_nonneg, hdual_lower]) hdual_lower
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_amplification_lower · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxAssembly.lean:140
Helpers.MinimaxUpper 2 declarations
theorem lobatto_affine_comp_natDegree_le Lemma lobatto_affine_comp_natDegree_le in the paper ↗

Composing a polynomial of degree at most β with the affine map x ↦ (q/2)(x + 1), which carries the standard interval [-1, 1] onto the budget window [0, q], leaves the degree at most β. Degree bookkeeping for moving a dual test polynomial between the two parametrisations in the amplification upper bound.

Formal statement
beta :
q :
r :
hrdeg :
r.natDegree ≤ beta
(r.comp (C (q / 2) * (X + C 1))).natDegree ≤ beta
Proof (Lean source)
lemma lobatto_affine_comp_natDegree_le {beta : ℕ} {q : ℝ} {r : Polynomial ℝ} (hrdeg : r.natDegree ≤ beta) : (r.comp (C (q / 2) * (X + C 1))).natDegree ≤ beta := by have haff : (C (q / 2) * (X + C 1 : Polynomial ℝ)).natDegree ≤ 1 := by exact (Polynomial.natDegree_C_mul_le (q / 2) (X + C 1 : Polynomial ℝ)).trans (by rw [Polynomial.natDegree_X_add_C]) calc (r.comp (C (q / 2) * (X + C 1))).natDegree ≤ r.natDegree * (C (q / 2) * (X + C 1 : Polynomial ℝ)).natDegree := Polynomial.natDegree_comp_le _ ≤ beta * 1 := by gcongr _ = beta := by simp
CausalSmith.Experimentation.RolloutChebyshev.lobatto_affine_comp_natDegree_le · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxUpper.lean:16
theorem chebyshev_amplification_upper

The shifted Chebyshev–Lobatto rollout design attains the exponential base, matching the lower bound. Granted two inputs — an endpoint upper bound with constant C, namely |R(2/q - 1) - R(-1)| ≤ C λ(q)^β for every polynomial R of degree at most β bounded by one on [-1, 1]; and a norming-set inequality with constant K, valid once the number of rounds satisfies k ≥ c β, controlling the largest value of such an R on all of [-1, 1] by K times its largest value on the k + 1 Chebyshev–Lobatto nodes — the Chebyshev–Lobatto schedule p^Ch(k,q) has total-variation amplification at most (K C)² · ((1 + √(1 - q))² / q)^{2β} for every order β ≥ 1 with β ≤ k and every budget q ≤ q_max < 1.

Formal statement
c qmax Cupper K :
hCupper_pos :
0 < Cupper
hKpos :
0 < K
hendpoint_upper :
∀ (beta : ℕ) (q : ℝ),
1
≤ beta → 0 < q → q ≤ qmax → ∀ R : Polynomial ℝ, R.natDegree ≤ beta → (∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ 1) → |R.eval (2 / q - 1)
- R.eval (-1)| ≤ Cupper * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta
hnorming :
∀ (beta k : ℕ) (R : Polynomial ℝ),
1
≤ beta → (k : ℝ) ≥ c * beta → R.natDegree ≤ beta → ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ K * Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|)
beta k :
q :
hbeta :
1 ≤ beta
hkβ :
beta ≤ k
hk :
(k : ℝ) ≥ c * beta
hq :
0 < q
hqle :
q ≤ qmax
hqmax_lt :
qmax < 1
≤ (K * Cupper) ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)
Proof (Lean source)
lemma chebyshev_amplification_upper (c qmax Cupper K : ℝ) (hCupper_pos : 0 < Cupper) (hKpos : 0 < K) (hendpoint_upper : ∀ (beta : ℕ) (q : ℝ), 1 ≤ beta → 0 < q → q ≤ qmax → ∀ R : Polynomial ℝ, R.natDegree ≤ beta → (∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ 1) → |R.eval (2 / q - 1) - R.eval (-1)| ≤ Cupper * ((2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1)) ^ beta) (hnorming : ∀ (beta k : ℕ) (R : Polynomial ℝ), 1 ≤ beta → (k : ℝ) ≥ c * beta → R.natDegree ≤ beta → ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ K * Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|)) {beta k : ℕ} {q : ℝ} (hbeta : 1 ≤ beta) (hkβ : beta ≤ k) (hk : (k : ℝ) ≥ c * beta) (hq : 0 < q) (hqle : q ≤ qmax) (hqmax_lt : qmax < 1) : amplification beta k (chebyshevSchedule k q) ≤ (K * Cupper) ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) := by let p : Fin (k + 1) → ℝ := chebyshevSchedule k q let lam : ℝ := (2 / q - 1) + sqrt ((2 / q - 1) ^ 2 - 1) let dualSet : Set ℝ := { t : ℝ | ∃ r : Polynomial ℝ, r.natDegree ≤ beta ∧ (∀ j, |r.eval (p j)| ≤ 1) ∧ t = |r.eval 1 - r.eval 0| } have hq_lt_one : q < 1 := lt_of_le_of_lt hqle hqmax_lt have hq_le_one : q ≤ 1 := le_trans hqle (le_of_lt hqmax_lt) have hk_one : 1 ≤ k := hbeta.trans hkβ have hp : BudgetedSchedule k q p := by simpa [p] using chebyshev_schedule_admissible k q hk_one ⟨hq, hq_le_one⟩ have hne : ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w := unbiased_weight_set_nonempty beta k q p hbeta hkβ hp have hdual_eq : amplification beta k p = (sSup dualSet) ^ 2 := by simpa [dualSet] using (amplification_dual_norm beta k p hp.2.2.1.injective hne).2 have hdual_bdd : BddAbove dualSet := by dsimp [dualSet] simpa [_root_.Causalean.Mathlib.Analysis.FiniteDimL1LinfDuality.dualValSet] using (_root_.Causalean.Mathlib.Analysis.FiniteDimL1LinfDuality.dualValSet_bddAbove (p := p) (β := beta) (_root_.Causalean.Mathlib.Analysis.FiniteDimL1LinfDuality.primalNormSet_nonempty hp.2.2.1.injective hkβ)) have hzero_mem : (0 : ℝ) ∈ dualSet := by refine ⟨0, by simp, ?_, by simp⟩ intro j simp have hdual_nonneg : 0 ≤ sSup dualSet := le_csSup hdual_bdd hzero_mem have hlam_gt : 1 < lam := by have hxq_gt : 1 < 2 / q - 1 := by have hdiv : 1 < 1 / q := one_lt_one_div hq hq_lt_one nlinarith [show 2 / q = 2 * (1 / q) by ring] have hs : 0 ≤ sqrt ((2 / q - 1) ^ 2 - 1) := Real.sqrt_nonneg _ dsimp [lam] nlinarith have hlam_eq_base : lam = (1 + sqrt (1 - q)) ^ 2 / q := by dsimp [lam] exact chebyshev_lambda_eq_rho_div_q hq hq_lt_one have hdual_upper : sSup dualSet ≤ K * Cupper * lam ^ beta := by refine csSup_le ?hneSet ?_ · exact ⟨0, hzero_mem⟩ · intro t ht rcases ht with ⟨r, hrdeg, hrnode, rfl⟩ let aff : Polynomial ℝ := C (q / 2) * (X + C 1) let R : Polynomial ℝ := r.comp aff let S : Polynomial ℝ := C K⁻¹ * R have hRdeg : R.natDegree ≤ beta := by simpa [R, aff] using lobatto_affine_comp_natDegree_le (q := q) hrdeg have hSdeg : S.natDegree ≤ beta := by exact (Polynomial.natDegree_C_mul_le K⁻¹ R).trans hRdeg have hRnode : ∀ j : Fin (k + 1), R.eval (-cos (pi * (j : ℝ) / (k : ℝ))) = r.eval (p j) := by intro j simp [R, aff, p, Polynomial.eval_comp, chebyshevSchedule] ring_nf have hnode_sup_le : Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|) ≤ 1 := by refine Finset.sup'_le univ_nonempty _ ?_ intro j _hj simpa [hRnode j] using hrnode j have hR_interval : ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |R.eval x| ≤ K := by intro x hx calc |R.eval x| ≤ K * Finset.univ.sup' univ_nonempty (fun j : Fin (k + 1) => |R.eval (-cos (pi * (j : ℝ) / (k : ℝ)))|) := hnorming beta k R hbeta hk hRdeg x hx _ ≤ K * 1 := mul_le_mul_of_nonneg_left hnode_sup_le (le_of_lt hKpos) _ = K := by ring_nf have hS_bound : ∀ x : ℝ, x ∈ Icc (-1 : ℝ) 1 → |S.eval x| ≤ 1 := by intro x hx have hR := hR_interval x hx calc |S.eval x| = K⁻¹ * |R.eval x| := by simp [S, abs_mul, abs_of_pos (inv_pos.mpr hKpos)] _ ≤ K⁻¹ * K := mul_le_mul_of_nonneg_left hR (inv_nonneg.mpr (le_of_lt hKpos)) _ = 1 := by field_simp [ne_of_gt hKpos] have haff_xq : aff.eval (2 / q - 1) = 1 := by simp [aff] field_simp [ne_of_gt hq] have haff_neg_one : aff.eval (-1) = 0 := by simp [aff] have hR_xq : R.eval (2 / q - 1) = r.eval 1 := by simp [R, Polynomial.eval_comp, haff_xq] have hR_neg_one : R.eval (-1) = r.eval 0 := by simp [R, Polynomial.eval_comp, haff_neg_one] have hS_endpoint : |S.eval (2 / q - 1) - S.eval (-1)| ≤ Cupper * lam ^ beta := by simpa [lam] using hendpoint_upper beta q hbeta hq hqle S hSdeg hS_bound have hscaled : K⁻¹ * |r.eval 1 - r.eval 0| ≤ Cupper * lam ^ beta := by have hS_eval : |S.eval (2 / q - 1) - S.eval (-1)| = K⁻¹ * |r.eval 1 - r.eval 0| := by calc |S.eval (2 / q - 1) - S.eval (-1)| = |K⁻¹ * (r.eval 1 - r.eval 0)| := by simp [S, Polynomial.eval_mul, hR_xq, hR_neg_one, mul_sub] _ = K⁻¹ * |r.eval 1 - r.eval 0| := by rw [abs_mul, abs_of_pos (inv_pos.mpr hKpos)] simpa [hS_eval] using hS_endpoint calc |r.eval 1 - r.eval 0| = K * (K⁻¹ * |r.eval 1 - r.eval 0|) := by field_simp [ne_of_gt hKpos] _ ≤ K * (Cupper * lam ^ beta) := mul_le_mul_of_nonneg_left hscaled (le_of_lt hKpos) _ = K * Cupper * lam ^ beta := by ring_nf have hright_nonneg : 0 ≤ K * Cupper * lam ^ beta := mul_nonneg (mul_nonneg (le_of_lt hKpos) (le_of_lt hCupper_pos)) (pow_nonneg (le_of_lt (lt_trans zero_lt_one hlam_gt)) beta) have hpow : lam ^ (2 * beta) = (lam ^ beta) ^ 2 := by rw [Nat.mul_comm 2 beta, pow_mul] have htarget : (K * Cupper) ^ 2 * lam ^ (2 * beta) = (K * Cupper * lam ^ beta) ^ 2 := by rw [hpow] ring_nf change amplification beta k p ≤ (K * Cupper) ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) rw [hdual_eq, ← hlam_eq_base, htarget] exact (sq_le_sq₀ hdual_nonneg hright_nonneg).2 hdual_upper
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_amplification_upper · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/MinimaxUpper.lean:37
Helpers.NoExtrapolation 1 declarations
theorem no_extrapolation_boundary Proposition 2 in the paper ↗

No-extrapolation boundary at the full-budget point q = 1: the endpoint rule w₀ = -1, w_β = 1, wⱼ = 0 for 1 ≤ j ≤ β-1 lies in W_β(p^eq(β,1)), hence A_β(p^eq(β,1)) ≤ 4. Marks the limit where node optimization becomes trivial (a β-uniform lower bound cannot extend to q = 1).

Formal statement
beta :
hbeta :
1 ≤ beta
UnbiasedWeights beta beta (equalSchedule beta 1) (fun j => if j = (0 : Fin (beta + 1)) then -1 else if j = last beta then 1 else 0) ∧
amplification beta beta (equalSchedule beta 1) ≤ 4
Proof (Lean source)
lemma no_extrapolation_boundary (beta : ℕ) (hbeta : 1 ≤ beta) : UnbiasedWeights beta beta (equalSchedule beta 1) (fun j => if j = (0 : Fin (beta + 1)) then -1 else if j = last beta then 1 else 0) ∧ amplification beta beta (equalSchedule beta 1) ≤ 4 := by let w : Fin (beta + 1) → ℝ := fun j => if j = (0 : Fin (beta + 1)) then -1 else if j = last beta then 1 else 0 have hne : (last beta) ≠ (0 : Fin (beta + 1)) := by intro h have hv : (last beta).val = (0 : Fin (beta + 1)).val := congrArg Fin.val h simp at hv omega have hbeta_ne : beta ≠ 0 := by omega have hw : UnbiasedWeights beta beta (equalSchedule beta 1) w := by constructor · have hsum_split : (∑ j, w j) = (∑ j, if j = (0 : Fin (beta + 1)) then (-1 : ℝ) else 0) + (∑ j, if j = last beta then (1 : ℝ) else 0) := by rw [← Finset.sum_add_distrib] apply Finset.sum_congr rfl intro j hj by_cases h0 : j = (0 : Fin (beta + 1)) · simp [w, h0, hne.symm] · by_cases hl : j = last beta · simp [w, hl, hbeta_ne] · simp [w, h0, hl] norm_num [hsum_split, Finset.sum_ite_eq'] · intro ell hell hle have hsum_split : (∑ j, w j * (equalSchedule beta 1 j) ^ ell) = (∑ j, if j = (0 : Fin (beta + 1)) then -((equalSchedule beta 1 j) ^ ell) else 0) + (∑ j, if j = last beta then (equalSchedule beta 1 j) ^ ell else 0) := by rw [← Finset.sum_add_distrib] apply Finset.sum_congr rfl intro j hj by_cases h0 : j = (0 : Fin (beta + 1)) · simp [w, h0, hne.symm] · by_cases hl : j = last beta · simp [w, hl, hbeta_ne] · simp [w, h0, hl] rw [hsum_split] simp [Finset.sum_ite_eq', equalSchedule, hbeta_ne, zero_pow (ne_of_gt hell)] constructor · exact hw · unfold amplification apply csInf_le · use 0 intro x hx rcases hx with ⟨w', hw', rfl⟩ positivity · refine ⟨w, hw, ?_⟩ have hsum_abs : (∑ j, |w j|) = 2 := by have hsum_split : (∑ j, |w j|) = (∑ j, if j = (0 : Fin (beta + 1)) then (1 : ℝ) else 0) + (∑ j, if j = last beta then (1 : ℝ) else 0) := by rw [← Finset.sum_add_distrib] apply Finset.sum_congr rfl intro j hj by_cases h0 : j = (0 : Fin (beta + 1)) · simp [w, h0, hne.symm] · by_cases hl : j = last beta · simp [w, hl, hbeta_ne] · simp [w, h0, hl] norm_num [hsum_split, Finset.sum_ite_eq'] norm_num [hsum_abs]
CausalSmith.Experimentation.RolloutChebyshev.no_extrapolation_boundary · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/NoExtrapolation.lean:16
Helpers.ScheduleGrid 1 declarations
def equalSchedule

Equal-spacing benchmark schedule p^eq(β,q) = (0, q/β, 2q/β, ..., q) on β+1 nodes. Carrier Fin (β+1) → ℝ (the closed-form grid). Its core space p^eq(β,q) ∈ [0,1]^(β+1) is NOT free from the formula alone: each coordinate q·j/β lies in [0,q] ⊆ [0,1] precisely when β ≥ 1 and q ∈ (0,1]. This range clause is realized by the leading conjunct ∀ j, p^eq(β,q) j ∈ Set.Icc 0 1 of equal_spacing_benchmark's conclusion, holding under its hypotheses 1 ≤ β and hq : 0 < q ∧ q ≤ 1. The budget parameter q (carrier q : ℝ) has space (0,1], pinned by the same range predicate hq. @realizes p^eq(beta,q)(carrier grid q·j/β; range [0,1]^(β+1) via equal_spacing_benchmark Icc conjunct, under β≥1, q∈(0,1]) @realizes q(carrier ℝ; range 0 < q ≤ 1 pinned by equal_spacing_benchmark.hq)

Definition (Lean source)
noncomputable def equalSchedule (beta : ℕ) (q : ℝ) : Fin (beta + 1) → ℝ := fun j => q * (j : ℝ) / (beta : ℝ)
Helpers.Variance 3 declarations
theorem variance_envelope_sharpness Lemma 9 in the paper ↗

Total-variation variance envelope and its sharpness: if the round statistics X₀,...,X_k satisfy the per-round envelope Var_pi(X_j) ≤ σ₀²/n (the threaded assumption RoundMeanVarianceEnvelope), then Var_pi(∑ⱼ wⱼ Xⱼ) ≤ (σ₀²/n)(∑ⱼ|wⱼ|)² for every real w, via the L²(π) triangle inequality.

Formal statement
n k :
Ω :
Type*
D :
X :
Fin (k + 1) → Ω → ℝ
sigma0sq :
w :
Fin (k + 1) → ℝ
hsig :
0 ≤ sigma0sq
hvar :
RoundMeanVarianceEnvelope n k D X sigma0sq
D.Var (fun z => ∑ j, w j * X j z) ≤ sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 ∧
∃ Γ : Matrix (Fin (k + 1)) (Fin (k + 1)) ℝ,
Γ.PosSemidef ∧
(∀ j, Γ j j ≤ sigma0sq / (n : ℝ)) ∧
(∑ i, ∑ j, w i * Γ i j * w j) = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2
Proof (Lean source)
lemma variance_envelope_sharpness (n k : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (X : Fin (k + 1) → Ω → ℝ) (sigma0sq : ℝ) (w : Fin (k + 1) → ℝ) (hsig : 0 ≤ sigma0sq) (hvar : RoundMeanVarianceEnvelope n k D X sigma0sq) : D.Var (fun z => ∑ j, w j * X j z) ≤ sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 ∧ ∃ Γ : Matrix (Fin (k + 1)) (Fin (k + 1)) ℝ, Γ.PosSemidef ∧ (∀ j, Γ j j ≤ sigma0sq / (n : ℝ)) ∧ (∑ i, ∑ j, w i * Γ i j * w j) = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 := by classical let s : ℝ := sigma0sq / (n : ℝ) have hs : 0 ≤ s := div_nonneg hsig (Nat.cast_nonneg n) have hvar_nonneg : ∀ Y : Ω → ℝ, 0 ≤ D.Var Y := by intro Y unfold FiniteDesign.Var exact D.E_nonneg (fun z => sq_nonneg _) have hcov_le_sqrt : ∀ Y Z : Ω → ℝ, D.Cov Y Z ≤ Real.sqrt (D.Var Y) * Real.sqrt (D.Var Z) := by intro Y Z have hcs := Real.sum_mul_le_sqrt_mul_sqrt (Finset.univ : Finset Ω) (fun z => Real.sqrt (D.p z) * (Y z - D.E Y)) (fun z => Real.sqrt (D.p z) * (Z z - D.E Z)) unfold FiniteDesign.Cov FiniteDesign.Var convert hcs using 1 · unfold FiniteDesign.E apply Finset.sum_congr rfl intro z _ have hp : Real.sqrt (D.p z) * Real.sqrt (D.p z) = D.p z := by rw [← sq, Real.sq_sqrt (D.p_nonneg z)] rw [← hp] ring_nf rw [Real.sq_sqrt (sq_nonneg (Real.sqrt (D.p z)))] ring · have hY : Real.sqrt (D.E fun z => (Y z - D.E Y) ^ 2) = Real.sqrt (∑ i, (Real.sqrt (D.p i) * (Y i - D.E Y)) ^ 2) := by apply congrArg Real.sqrt unfold FiniteDesign.E apply Finset.sum_congr rfl intro z _ have hp : Real.sqrt (D.p z) * Real.sqrt (D.p z) = D.p z := by rw [← sq, Real.sq_sqrt (D.p_nonneg z)] rw [← hp] ring_nf rw [Real.sq_sqrt (sq_nonneg (Real.sqrt (D.p z)))] ring have hZ : Real.sqrt (D.E fun z => (Z z - D.E Z) ^ 2) = Real.sqrt (∑ i, (Real.sqrt (D.p i) * (Z i - D.E Z)) ^ 2) := by apply congrArg Real.sqrt unfold FiniteDesign.E apply Finset.sum_congr rfl intro z _ have hp : Real.sqrt (D.p z) * Real.sqrt (D.p z) = D.p z := by rw [← sq, Real.sq_sqrt (D.p_nonneg z)] rw [← hp] ring_nf rw [Real.sq_sqrt (sq_nonneg (Real.sqrt (D.p z)))] ring rw [hY, hZ] have hcov_abs_le_sqrt : ∀ Y Z : Ω → ℝ, |D.Cov Y Z| ≤ Real.sqrt (D.Var Y) * Real.sqrt (D.Var Z) := by intro Y Z refine abs_le.2 ⟨?_, hcov_le_sqrt Y Z⟩ have h := hcov_le_sqrt (fun z => -Y z) Z have hcov : D.Cov (fun z => -Y z) Z = -D.Cov Y Z := by simpa using D.Cov_const_mul_left (-1) Y Z have hvar_neg : D.Var (fun z => -Y z) = D.Var Y := by simpa using D.Var_const_mul (-1) Y have hneg : -D.Cov Y Z ≤ Real.sqrt (D.Var Y) * Real.sqrt (D.Var Z) := by simpa [hcov, hvar_neg] using h linarith have hcov : ∀ i j : Fin (k + 1), |D.Cov (X i) (X j)| ≤ s := by intro i j have hi := Real.sqrt_le_sqrt (hvar i) have hj := Real.sqrt_le_sqrt (hvar j) have hprod : Real.sqrt (D.Var (X i)) * Real.sqrt (D.Var (X j)) ≤ Real.sqrt s * Real.sqrt s := by exact mul_le_mul hi hj (Real.sqrt_nonneg _) (le_trans (Real.sqrt_nonneg _) hi) have hs_sqrt : Real.sqrt s * Real.sqrt s = s := by rw [← sq, Real.sq_sqrt hs] exact (hcov_abs_le_sqrt (X i) (X j)).trans (hprod.trans_eq hs_sqrt) have hupper : D.Var (fun z => ∑ j, w j * X j z) ≤ s * (∑ j, |w j|) ^ 2 := by calc D.Var (fun z => ∑ j, w j * X j z) = ∑ i, ∑ j, w i * w j * D.Cov (X i) (X j) := by simpa using D.Var_linear_comb (Finset.univ : Finset (Fin (k + 1))) w X _ ≤ ∑ i, ∑ j, |w i| * |w j| * s := by apply Finset.sum_le_sum intro i _ apply Finset.sum_le_sum intro j _ have hle_abs : w i * w j * D.Cov (X i) (X j) ≤ |w i * w j * D.Cov (X i) (X j)| := le_abs_self _ have habs_eq : |w i * w j * D.Cov (X i) (X j)| = |w i| * |w j| * |D.Cov (X i) (X j)| := by rw [abs_mul, abs_mul] calc w i * w j * D.Cov (X i) (X j) ≤ |w i * w j * D.Cov (X i) (X j)| := hle_abs _ = |w i| * |w j| * |D.Cov (X i) (X j)| := habs_eq _ ≤ |w i| * |w j| * s := by exact mul_le_mul_of_nonneg_left (hcov i j) (mul_nonneg (abs_nonneg _) (abs_nonneg _)) _ = s * (∑ j, |w j|) ^ 2 := by rw [pow_two] simp [Finset.mul_sum, mul_assoc, mul_comm] have hsharp : ∃ Γ : Matrix (Fin (k + 1)) (Fin (k + 1)) ℝ, Γ.PosSemidef ∧ (∀ j, Γ j j ≤ s) ∧ (∑ i, ∑ j, w i * Γ i j * w j) = s * (∑ j, |w j|) ^ 2 := by let eps : Fin (k + 1) → ℝ := fun j => if 0 ≤ w j then 1 else -1 refine ⟨s • vecMulVec eps eps, ?_, ?_, ?_⟩ · have hbase : (vecMulVec eps eps).PosSemidef := by simpa using Matrix.posSemidef_vecMulVec_self_star (R := ℝ) eps exact hbase.smul hs · intro j have heps_sq : eps j * eps j = 1 := by by_cases h : 0 ≤ w j <;> simp [eps, h] simp [s, vecMulVec, heps_sq] · have hw_eps : ∀ i, w i * eps i = |w i| := by intro i by_cases h : 0 ≤ w i · simp [eps, h, abs_of_nonneg h] · have hlt : w i < 0 := lt_of_not_ge h simp [eps, h, abs_of_neg hlt] calc (∑ i, ∑ j, w i * (s • vecMulVec eps eps) i j * w j) = s * ((∑ i, w i * eps i) * (∑ j, w j * eps j)) := by simp [vecMulVec, Finset.mul_sum, mul_left_comm, mul_comm] _ = s * (∑ j, |w j|) ^ 2 := by simp [hw_eps, pow_two] exact ⟨by simpa [s] using hupper, by simpa [s] using hsharp⟩
CausalSmith.Experimentation.RolloutChebyshev.variance_envelope_sharpness · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/Variance.lean:24
theorem sInf_le_mul_sInf_of_forall_exists_le Lemma sInf_le_mul_sInf_of_forall_exists_le in the paper ↗

Order bookkeeping for taking an infimum after a uniform multiplicative comparison.

Formal statement
F G :
Set
c :
hc :
0 ≤ c
hFne :
F.Nonempty
hFbdd :
hGne :
G.Nonempty
hlink :
∀ g ∈ G, ∃ f ∈ F, f ≤ c * g
sInf F ≤ c * sInf G
Proof (Lean source)
lemma sInf_le_mul_sInf_of_forall_exists_le (F G : Set ℝ) (c : ℝ) (hc : 0 ≤ c) (hFne : F.Nonempty) (hFbdd : BddBelow F) (hGne : G.Nonempty) (hlink : ∀ g ∈ G, ∃ f ∈ F, f ≤ c * g) : sInf F ≤ c * sInf G := by rw [← smul_eq_mul, ← Real.sInf_smul_of_nonneg hc G] refine (csInf_le_iff hFbdd hFne).2 ?_ intro b hb refine le_csInf (Set.smul_set_nonempty.mpr hGne) ?_ intro x hx rcases Set.mem_smul_set.mp hx with ⟨g, hg, rfl⟩ rcases hlink g hg with ⟨f, hf, hle⟩ exact (hb hf).trans (by simpa [smul_eq_mul] using hle)
CausalSmith.Experimentation.RolloutChebyshev.sInf_le_mul_sInf_of_forall_exists_le · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/Variance.lean:169
theorem exact_risk_envelope_upper Lemma 2 in the paper ↗

Envelope-to-exact-risk bridge: for β ≥ 1, k ≥ β, q ∈ (0,1], and every budgeted schedule p ∈ S_{k,q}, the fixed-schedule exact risk is dominated by the amplification envelope, inf_{w∈W_β(p)} sup_{P∈P_β} w'Γ_P(p)w ≤ (σ₀²/n) A_β(p) (the same triangle argument as variance_envelope_sharpness applied to the exact covariance Γ_P(p)); consequently R_exact(β,k,q) ≤ (σ₀²/n) M_{β,k,q}.

Formal statement
n k beta :
Ω :
Type*
D :
q sigma0sq :
hbeta :
1 ≤ beta
hk :
beta ≤ k
_hq :
0 < q ∧ q ≤ 1
hsig :
0 ≤ sigma0sq
p :
Fin (k + 1) → ℝ
hp :
(sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } ≤ sigma0sq / (n : ℝ) * amplification beta k p) ∧
exactNestedRisk n k beta D q sigma0sq ≤ sigma0sq / (n : ℝ) * minimaxAmplification beta k q
Proof (Lean source)
lemma exact_risk_envelope_upper (n k beta : ℕ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (q sigma0sq : ℝ) (hbeta : 1 ≤ beta) (hk : beta ≤ k) (_hq : 0 < q ∧ q ≤ 1) (hsig : 0 ≤ sigma0sq) (p : Fin (k + 1) → ℝ) (hp : BudgetedSchedule k q p) : (sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } ≤ sigma0sq / (n : ℝ) * amplification beta k p) ∧ exactNestedRisk n k beta D q sigma0sq ≤ sigma0sq / (n : ℝ) * minimaxAmplification beta k q := by classical let fixedRisk : (Fin (k + 1) → ℝ) → ℝ := fun p' => sInf { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p' w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p' ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } let scale : ℝ := sigma0sq / (n : ℝ) have hscale : 0 ≤ scale := div_nonneg hsig (Nat.cast_nonneg n) have hvar_nonneg : ∀ Y : Ω → ℝ, 0 ≤ D.Var Y := by intro Y; unfold FiniteDesign.Var; exact D.E_nonneg (fun z => sq_nonneg _) have fixedRisk_nonneg : ∀ p' : Fin (k + 1) → ℝ, 0 ≤ fixedRisk p' := by intro p' dsimp [fixedRisk] apply Real.sInf_nonneg intro rw hrw rcases hrw with ⟨w, hw, rfl⟩ apply Real.sSup_nonneg intro rP hrP rcases hrP with ⟨Y, Z, barY, m, a, hlaw, rfl⟩ exact hvar_nonneg _ have fixed_le_for : ∀ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' → fixedRisk p' ≤ scale * amplification beta k p' := by intro p' hp' let F : Set ℝ := { rw : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p' w ∧ rw = sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p' ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } } let G : Set ℝ := { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p' w ∧ v = (∑ j, |w j|) ^ 2 } rcases unbiased_weight_set_nonempty beta k q p' hbeta hk hp' with ⟨w0, hw0⟩ have hFne : F.Nonempty := by refine ⟨sSup { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p' ∧ rP = D.Var (fun z => ∑ j, w0 j * barY j z) }, ?_⟩ exact ⟨w0, hw0, rfl⟩ have hGne : G.Nonempty := by exact ⟨(∑ j, |w0 j|) ^ 2, w0, hw0, rfl⟩ have hFbdd : BddBelow F := by refine ⟨0, ?_⟩ intro rw hrw rcases hrw with ⟨w, hw, rfl⟩ apply Real.sSup_nonneg intro rP hrP rcases hrP with ⟨Y, Z, barY, m, a, hlaw, rfl⟩ exact hvar_nonneg _ have hlink : ∀ g ∈ G, ∃ f ∈ F, f ≤ scale * g := by intro g hg rcases hg with ⟨w, hw, rfl⟩ let lawValues : Set ℝ := { rP : ℝ | ∃ (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ), RolloutLawClass n k beta D Y Z barY m a sigma0sq p' ∧ rP = D.Var (fun z => ∑ j, w j * barY j z) } refine ⟨sSup lawValues, ?_, ?_⟩ · exact ⟨w, hw, rfl⟩ · apply Real.sSup_le · intro rP hrP rcases hrP with ⟨Y, Z, barY, m, a, hlaw, rfl⟩ exact (variance_envelope_sharpness n k D barY sigma0sq w hsig hlaw.variance_envelope).1 · exact mul_nonneg hscale (sq_nonneg _) change sInf F ≤ scale * sInf G exact sInf_le_mul_sInf_of_forall_exists_le F G scale hscale hFne hFbdd hGne hlink have hfixed_le : fixedRisk p ≤ sigma0sq / (n : ℝ) * amplification beta k p := by simpa [scale] using fixed_le_for p hp have hexact_le : exactNestedRisk n k beta D q sigma0sq ≤ sigma0sq / (n : ℝ) * minimaxAmplification beta k q := by let F : Set ℝ := { rp : ℝ | ∃ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' ∧ rp = fixedRisk p' } let G : Set ℝ := { v : ℝ | ∃ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' ∧ v = amplification beta k p' } have hFne : F.Nonempty := ⟨fixedRisk p, p, hp, rfl⟩ have hGne : G.Nonempty := ⟨amplification beta k p, p, hp, rfl⟩ have hFbdd : BddBelow F := by refine ⟨0, ?_⟩ intro rp hrp rcases hrp with ⟨p', hp', rfl⟩ exact fixedRisk_nonneg p' have hlink : ∀ g ∈ G, ∃ f ∈ F, f ≤ scale * g := by intro g hg rcases hg with ⟨p', hp', rfl⟩ exact ⟨fixedRisk p', ⟨p', hp', rfl⟩, fixed_le_for p' hp'⟩ change sInf F ≤ scale * sInf G exact sInf_le_mul_sInf_of_forall_exists_le F G scale hscale hFne hFbdd hGne hlink exact ⟨hfixed_le, hexact_le⟩
CausalSmith.Experimentation.RolloutChebyshev.exact_risk_envelope_upper · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/Helpers/Variance.lean:184
T_chebyshev_minimax 2 declarations
theorem chebyshev_minimax Theorem 2 in the paper ↗

Headline theorem (Chebyshev-Lobatto matched minimax). Fix q_max ∈ (0,1) and let ρ(q) = (1 + √(1-q))². There is a positive constant C₋(q_max) — chosen UNIFORMLY IN c, depending only on q_max — and, for every oversampling ratio c > 1, a positive constant C₊(c,q_max), such that (both uniform in β, k, q) for every β ≥ 1, every integer k ≥ c·β, and every q ∈ (0, q_max]:

Formal statement
qmax :
hqmax :
0 < qmax ∧ qmax < 1
∃ Cminus : ℝ,
0 < Cminus ∧
∀ (c : ℝ),
1 < c → ∃ Cplus : ℝ, 0 < Cplus ∧ ∀ (beta k : ℕ) (q : ℝ), 1
≤ beta → (k : ℝ) ≥ c * beta → LowBudgetCap q qmax → 0 < q → (∀ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p → amplification beta k p ≥ Cminus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)) ∧
≤ Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) ∧
minimaxAmplification beta k q ≥ Cminus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) ∧
minimaxAmplification beta k q ≤ Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)
Proof (Lean source)
theorem chebyshev_minimax (qmax : ℝ) (hqmax : 0 < qmax ∧ qmax < 1) : ∃ Cminus : ℝ, 0 < Cminus ∧ ∀ (c : ℝ), 1 < c → ∃ Cplus : ℝ, 0 < Cplus ∧ ∀ (beta k : ℕ) (q : ℝ), 1 ≤ beta → (k : ℝ) ≥ c * beta → LowBudgetCap q qmax → 0 < q → (∀ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p → amplification beta k p ≥ Cminus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta)) ∧ amplification beta k (chebyshevSchedule k q) ≤ Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) ∧ minimaxAmplification beta k q ≥ Cminus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) ∧ minimaxAmplification beta k q ≤ Cplus * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) := by rcases continuous_chebyshev_endpoint_bound qmax hqmax with ⟨Cupper, clower, hCupper_pos, hclower_pos, hendpoint⟩ refine ⟨clower ^ 2, by positivity, ?_⟩ intro c hc rcases oversampled_chebyshev_lobatto_norming ehlichZellerMesh c hc with ⟨K, hKpos, hnorming⟩ refine ⟨(K * Cupper) ^ 2, by positivity, ?_⟩ intro beta k q hbeta hk hcap hq have hqle : q ≤ qmax := hcap.2.1 have hqmax_lt : qmax < 1 := hqmax.2 have hq_le_one : q ≤ 1 := le_trans hqle (le_of_lt hqmax_lt) have hbeta_pos_nat : 0 < beta := by omega have hbeta_pos : (0 : ℝ) < (beta : ℝ) := by exact_mod_cast hbeta_pos_nat have hkβ : beta ≤ k := by have hkβ_real : (beta : ℝ) ≤ (k : ℝ) := by nlinarith [hk, hc, hbeta_pos] exact_mod_cast hkβ_real have hk_one : 1 ≤ k := hbeta.trans hkβ have hpCh : BudgetedSchedule k q (chebyshevSchedule k q) := chebyshev_schedule_admissible k q hk_one ⟨hq, hq_le_one⟩ let Bminus : ℝ := clower ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) let Bplus : ℝ := (K * Cupper) ^ 2 * ((1 + sqrt (1 - q)) ^ 2 / q) ^ (2 * beta) have hlower : ∀ p : Fin (k + 1) → ℝ, BudgetedSchedule k q p → Bminus ≤ amplification beta k p := by intro p hp dsimp [Bminus] exact chebyshev_amplification_lower qmax clower hclower_pos (fun beta q hbeta hq hqle => (hendpoint beta q hbeta hq hqle).2) hbeta hkβ hq hqle hqmax_lt p hp have hupper : amplification beta k (chebyshevSchedule k q) ≤ Bplus := by dsimp [Bplus] exact chebyshev_amplification_upper c qmax Cupper K hCupper_pos hKpos (fun beta q hbeta hq hqle R hdeg hbound => (hendpoint beta q hbeta hq hqle).1 R hdeg hbound) hnorming hbeta hkβ hk hq hqle hqmax_lt refine ⟨?_, ?_, ?_, ?_⟩ · intro p hp exact hlower p hp · exact hupper · exact minimaxAmplification_lower_of_forall beta k q Bminus ⟨chebyshevSchedule k q, hpCh⟩ hlower · exact (minimaxAmplification_le_of_budgeted beta k q (chebyshevSchedule k q) hpCh).trans hupper
CausalSmith.Experimentation.RolloutChebyshev.chebyshev_minimax · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/T_chebyshev_minimax.lean:25

Range realization for ρ_Ch(c,q_max) ∈ [1,∞): the minimal-base infimum is ≥ 1, pinning the symbol's declared space [1,∞) VALUE-wise (not merely element-wise). The defining set {ρ | 1 ≤ ρ ∧ ∃ M, …} has 1 as a lower bound (every member satisfies the 1 ≤ ρ conjunct) and is nonempty: the Chebyshev upper half gives A_β(p^Ch) ≤ C₊·(((1+√(1-q))²)/q)^{2β}, so after multiplying by q^β the base is bounded by 4^β. Thus ρ = 4 is a finite witness, and le_csInf gives 1 ≤ sInf. @realizes rho_Ch(c,q_max)(range [1,∞): 1 ≤ rhoCh established value-wise via nonempty witness)

Formal statement
c qmax :
hc :
1 < c
hqmax :
0 < qmax ∧ qmax < 1
1 ≤ rhoCh c qmax
Proof (Lean source)
lemma one_le_rhoCh (c qmax : ℝ) (hc : 1 < c) (hqmax : 0 < qmax ∧ qmax < 1) : 1 ≤ rhoCh c qmax := by rcases chebyshev_minimax qmax hqmax with ⟨_Cminus, _hCminus_pos, hbounds⟩ rcases hbounds c hc with ⟨Cplus, hCplus_pos, hcheb⟩ let S : Set ℝ := { rho : ℝ | 1 ≤ rho ∧ ∃ M : ℝ, ∀ beta : ℕ, 1 ≤ beta → ∀ q : ℝ, 0 < q → q ≤ qmax → q ^ beta * sqrt (amplification beta ⌈c * (beta : ℝ)⌉₊ (chebyshevSchedule ⌈c * (beta : ℝ)⌉₊ q)) ≤ M * rho ^ beta } have hS_nonempty : S.Nonempty := by refine ⟨4, ?_⟩ constructor · norm_num · refine ⟨Real.sqrt Cplus, ?_⟩ intro beta hbeta q hq hqle let k : ℕ := ⌈c * (beta : ℝ)⌉₊ let base : ℝ := (1 + sqrt (1 - q)) ^ 2 / q have hk : (k : ℝ) ≥ c * beta := by dsimp [k] simpa using Nat.le_ceil (c * (beta : ℝ)) have hcap : LowBudgetCap q qmax := ⟨hqmax.1, hqle, hqmax.2⟩ have hupper : amplification beta k (chebyshevSchedule k q) ≤ Cplus * base ^ (2 * beta) := by simpa [k, base] using (hcheb beta k q hbeta hk hcap hq).2.1 have hbase_nonneg : 0 ≤ base := by exact div_nonneg (sq_nonneg _) (le_of_lt hq) have hsqrt_upper : sqrt (amplification beta k (chebyshevSchedule k q)) ≤ sqrt Cplus * base ^ beta := by calc sqrt (amplification beta k (chebyshevSchedule k q)) ≤ sqrt (Cplus * base ^ (2 * beta)) := Real.sqrt_le_sqrt hupper _ = sqrt Cplus * sqrt (base ^ (2 * beta)) := by rw [Real.sqrt_mul (le_of_lt hCplus_pos)] _ = sqrt Cplus * base ^ beta := by have hpow : base ^ (2 * beta) = (base ^ beta) ^ 2 := by rw [Nat.mul_comm 2 beta, pow_mul] rw [hpow, Real.sqrt_sq_eq_abs, abs_of_nonneg (pow_nonneg hbase_nonneg beta)] have hbase_cancel : q ^ beta * (sqrt Cplus * base ^ beta) = sqrt Cplus * ((1 + sqrt (1 - q)) ^ 2) ^ beta := by have hq_ne : q ≠ 0 := ne_of_gt hq calc q ^ beta * (sqrt Cplus * base ^ beta) = sqrt Cplus * (q ^ beta * base ^ beta) := by ring _ = sqrt Cplus * (q * base) ^ beta := by rw [mul_pow] _ = sqrt Cplus * ((1 + sqrt (1 - q)) ^ 2) ^ beta := by congr 1 congr 1 dsimp [base] field_simp [hq_ne] have hsqrt_le_one : sqrt (1 - q) ≤ 1 := by simpa using Real.sqrt_le_sqrt (by linarith : 1 - q ≤ 1) have hrad_nonneg : 0 ≤ sqrt (1 - q) := Real.sqrt_nonneg _ have hbase4 : (1 + sqrt (1 - q)) ^ 2 ≤ (4 : ℝ) := by nlinarith have hpow4 : ((1 + sqrt (1 - q)) ^ 2) ^ beta ≤ (4 : ℝ) ^ beta := by exact pow_le_pow_left₀ (sq_nonneg _) hbase4 beta calc q ^ beta * sqrt (amplification beta ⌈c * (beta : ℝ)⌉₊ (chebyshevSchedule ⌈c * (beta : ℝ)⌉₊ q)) = q ^ beta * sqrt (amplification beta k (chebyshevSchedule k q)) := by simp [k] _ ≤ q ^ beta * (sqrt Cplus * base ^ beta) := mul_le_mul_of_nonneg_left hsqrt_upper (pow_nonneg (le_of_lt hq) beta) _ = sqrt Cplus * ((1 + sqrt (1 - q)) ^ 2) ^ beta := hbase_cancel _ ≤ sqrt Cplus * (4 : ℝ) ^ beta := mul_le_mul_of_nonneg_left hpow4 (Real.sqrt_nonneg Cplus) unfold rhoCh change 1 ≤ sInf S exact le_csInf hS_nonempty (by intro rho hrho exact hrho.1)
T_tv_envelope_design 1 declarations
theorem tv_envelope_design Theorem 1 in the paper ↗

Main deliverable 1 (TV-envelope rollout design theorem). Assume β ≥ 1 and k ≥ β. For every budgeted schedule p ∈ S_{k,q} and every law P ∈ P_β (bundled as RolloutLawClass), the unbiased weight set is nonempty, and for every w ∈ W_β(p) the linear rollout estimator hat_τ_{w,p} = ∑ⱼ wⱼ bar_Y_j is design-unbiased for τ_P = m_P(1) - m_P(0) and satisfies the sharp total-variation variance bound Var_pi(hat_τ_{w,p}) ≤ (σ₀²/n)(∑ⱼ|wⱼ|)².

Formal statement
n k beta :
q sigma0sq :
Ω :
Type*
D :
Y :
Fin n → (Fin n → Bool) → ℝ
Z :
Fin (k + 1) → Ω → (Fin n → Bool)
barY :
Fin (k + 1) → Ω → ℝ
m :
ℝ → ℝ
a :
ℕ → ℝ
hbeta :
1 ≤ beta
hk :
beta ≤ k
hsig :
0 ≤ sigma0sq
p :
Fin (k + 1) → ℝ
hp :
hP :
RolloutLawClass n k beta D Y Z barY m a sigma0sq p
(∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w) ∧
(∀ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w → D.E (fun z => ∑ j, w j * barY j z) = m 1 - m 0 ∧ D.Var (fun z => ∑ j, w j * barY j z) ≤ sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 ∧ ∃ Γ : Matrix (Fin (k + 1)) (Fin (k + 1)) ℝ, Γ.PosSemidef ∧ (∀ j, Γ j j ≤ sigma0sq / (n : ℝ)) ∧ (∑ i, ∑ j, w i * Γ i j * w j) = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2) ∧
(sInf { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ v = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 } = sigma0sq / (n : ℝ) * amplification beta k p) ∧
(sInf { v : ℝ | ∃ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' ∧ v = sigma0sq / (n : ℝ) * amplification beta k p' } = sigma0sq / (n : ℝ) * minimaxAmplification beta k q) ∧
(∀ pstar : Fin (k + 1) → ℝ, BudgetedSchedule k q pstar → amplification beta k pstar = minimaxAmplification beta k q → ∀ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' → sigma0sq / (n : ℝ) * amplification beta k pstar ≤ sigma0sq / (n : ℝ) * amplification beta k p')
Proof (Lean source)
theorem tv_envelope_design (n k beta : ℕ) (q sigma0sq : ℝ) {Ω : Type*} [Fintype Ω] (D : FiniteDesign Ω) (Y : Fin n → (Fin n → Bool) → ℝ) (Z : Fin (k + 1) → Ω → (Fin n → Bool)) (barY : Fin (k + 1) → Ω → ℝ) (m : ℝ → ℝ) (a : ℕ → ℝ) (hbeta : 1 ≤ beta) (hk : beta ≤ k) (hsig : 0 ≤ sigma0sq) (p : Fin (k + 1) → ℝ) (hp : BudgetedSchedule k q p) (hP : RolloutLawClass n k beta D Y Z barY m a sigma0sq p) : (∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w) ∧ (∀ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w → D.E (fun z => ∑ j, w j * barY j z) = m 1 - m 0 ∧ D.Var (fun z => ∑ j, w j * barY j z) ≤ sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 ∧ ∃ Γ : Matrix (Fin (k + 1)) (Fin (k + 1)) ℝ, Γ.PosSemidef ∧ (∀ j, Γ j j ≤ sigma0sq / (n : ℝ)) ∧ (∑ i, ∑ j, w i * Γ i j * w j) = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2) ∧ (sInf { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ v = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 } = sigma0sq / (n : ℝ) * amplification beta k p) ∧ (sInf { v : ℝ | ∃ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' ∧ v = sigma0sq / (n : ℝ) * amplification beta k p' } = sigma0sq / (n : ℝ) * minimaxAmplification beta k q) ∧ (∀ pstar : Fin (k + 1) → ℝ, BudgetedSchedule k q pstar → amplification beta k pstar = minimaxAmplification beta k q → ∀ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' → sigma0sq / (n : ℝ) * amplification beta k pstar ≤ sigma0sq / (n : ℝ) * amplification beta k p') := by have hc : (0 : ℝ) ≤ sigma0sq / (n : ℝ) := div_nonneg hsig (Nat.cast_nonneg n) refine ⟨unbiased_weight_set_nonempty beta k q p hbeta hk hp, ?_, ?_, ?_, ?_⟩ · intro w hw constructor · rw [FiniteDesign.E_sum] have hmean : (∑ j : Fin (k + 1), D.E (fun z => w j * barY j z)) = ∑ j : Fin (k + 1), w j * m (p j) := by apply Finset.sum_congr rfl intro j hj rw [FiniteDesign.E_const_mul, hP.mean_curve] rw [hmean] have hpoly_at_nodes : ∀ j : Fin (k + 1), m (p j) = ∑ ell ∈ range (beta + 1), a ell * (p j) ^ ell := by intro j exact hP.beta_polynomial (p j) (hp.1 j) have hsum_poly : (∑ j : Fin (k + 1), w j * m (p j)) = ∑ ell ∈ range (beta + 1), a ell * ∑ j : Fin (k + 1), w j * (p j) ^ ell := by simp_rw [hpoly_at_nodes] simp_rw [Finset.mul_sum] rw [Finset.sum_comm] simp [mul_left_comm] rw [hsum_poly] have hendpoint := rollout_polynomial_identity n k beta Y Z barY m a hP.static_rollout hP.beta_polynomial rw [hendpoint] have hsplit : (∑ ell ∈ range (beta + 1), a ell * ∑ j : Fin (k + 1), w j * (p j) ^ ell) = a 0 * (∑ j : Fin (k + 1), w j * (p j) ^ (0 : ℕ)) + ∑ ell ∈ Icc 1 beta, a ell * ∑ j : Fin (k + 1), w j * (p j) ^ ell := by clear hsum_poly hendpoint hpoly_at_nodes hmean hbeta hk hP hw induction beta with | zero => simp | succ beta ih => rw [Finset.sum_range_succ] rw [ih] rw [Finset.sum_Icc_succ_top (Nat.succ_pos beta)] ring rw [hsplit, hw.1] simp apply Finset.sum_congr rfl intro ell hell rw [hw.2 ell (Finset.mem_Icc.mp hell).1 (Finset.mem_Icc.mp hell).2] ring · exact variance_envelope_sharpness n k D barY sigma0sq w hsig hP.variance_envelope · -- Fixed-schedule envelope optimum: the best achievable envelope variance over `W_β(p)` is -- `(σ₀²/n)·A_β(p)`, by pulling the nonnegative constant `σ₀²/n` through the `sInf`. have hset : { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ v = sigma0sq / (n : ℝ) * (∑ j, |w j|) ^ 2 } = (sigma0sq / (n : ℝ)) • { v : ℝ | ∃ w : Fin (k + 1) → ℝ, UnbiasedWeights beta k p w ∧ v = (∑ j, |w j|) ^ 2 } := by ext v simp only [Set.mem_smul_set, Set.mem_setOf_eq, smul_eq_mul] constructor · rintro ⟨w, hw, rfl⟩ exact ⟨(∑ j, |w j|) ^ 2, ⟨w, hw, rfl⟩, rfl⟩ · rintro ⟨x, ⟨w, hw, rfl⟩, rfl⟩ exact ⟨w, hw, rfl⟩ unfold amplification rw [hset, Real.sInf_smul_of_nonneg hc, smul_eq_mul] · -- Minimax envelope: the infimum of the fixed-schedule envelope optima over `S_{k,q}` is -- `(σ₀²/n)·M_{β,k,q}`, again by pulling `σ₀²/n ≥ 0` through the `sInf`. have hset : { v : ℝ | ∃ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' ∧ v = sigma0sq / (n : ℝ) * amplification beta k p' } = (sigma0sq / (n : ℝ)) • { v : ℝ | ∃ p' : Fin (k + 1) → ℝ, BudgetedSchedule k q p' ∧ v = amplification beta k p' } := by ext v simp only [Set.mem_smul_set, Set.mem_setOf_eq, smul_eq_mul] constructor · rintro ⟨p', hp', rfl⟩ exact ⟨amplification beta k p', ⟨p', hp', rfl⟩, rfl⟩ · rintro ⟨x, ⟨p', hp', rfl⟩, rfl⟩ exact ⟨p', hp', rfl⟩ unfold minimaxAmplification rw [hset, Real.sInf_smul_of_nonneg hc, smul_eq_mul] · -- Optimal-schedule characterization (conditional): any budgeted `pstar` attaining the -- minimax value `M_{β,k,q}` minimizes the envelope variance `(σ₀²/n)·A_β` over `S_{k,q}`. -- This is `attains inf ⇒ ≤ all others`, NOT an existence/attainment claim, so it is -- provable here without the schedule-class attainment argument of `chebyshev_minimax`. intro pstar _hpstar hpstar_eq p' hp' have hle : amplification beta k pstar ≤ amplification beta k p' := by rw [hpstar_eq] exact minimaxAmplification_le_of_budgeted beta k q p' hp' exact mul_le_mul_of_nonneg_left hle hc
CausalSmith.Experimentation.RolloutChebyshev.tv_envelope_design · CausalSmith/Experimentation/EXP_RolloutChebyshevMinimax_Research/T_tv_envelope_design.lean:24