Formalization: A Lower-Bound Calibration for Joint Margin--Overlap Decay in Offline Policy Learning

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 77 declarations Environment S1 — observed-law policy-learning world

Environment S1 — observed-law policy-learning world

def Policy

Deterministic binary policy X → {0,1}. @realizes pi(𝒳→Bool realizes 𝒳→{0,1})

Definition (Lean source)
abbrev Policy (𝒳 : Type*) := 𝒳 → Bool
CausalSmith.Stat.PolicyRegretMarginOverlap.Policy · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:46
def boolIndicator

Real indicator of a Boolean.

Definition (Lean source)
def boolIndicator (b : Bool) : ℝ := if b then 1 else 0
CausalSmith.Stat.PolicyRegretMarginOverlap.boolIndicator · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:50
structure Observation

Observation O=(X,A,Y) ∈ 𝒳 × {0,1} × [-1,1]. The treatment space {0,1} is encoded at the TYPE level by A : Bool (true ↦ 1, false ↦ 0, via boolIndicator); the outcome space [-1,1] is a RANGE/support constraint carried at the law level (BoundedOutcome, WellFormedLaw) rather than by a subtype, since the witness measure constructions are stated over . @realizes O(carrier 𝒳×Bool×ℝ realizes 𝒳×{0,1}×[-1,1])

Definition (Lean source)
𝒳 :
Type*
X :
𝒳
A :
Y :
CausalSmith.Stat.PolicyRegretMarginOverlap.Observation · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:53
instance instMeasurableSpaceObservation

The σ-algebra on observations: a set of observations is measurable exactly when it is the preimage of a measurable set of covariate-treatment-outcome triples under the coordinate map. So a function of an observation is measurable precisely when it is measurable as a function of the triple.

Definition (Lean source)
instance instMeasurableSpaceObservation : MeasurableSpace (Observation 𝒳) := comap (fun O : Observation 𝒳 => (O.X, O.A, O.Y)) inferInstance
CausalSmith.Stat.PolicyRegretMarginOverlap.instMeasurableSpaceObservation · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:64
def optimalPolicy

Optimal policy π_⋆(x)=1{τ(x) ≥ 0}. @realizes pi_star(Policy-valued, i.e. 𝒳→{0,1})

Definition (Lean source)
noncomputable def optimalPolicy (τ : 𝒳 → ℝ) : Policy 𝒳 := fun x => if 0 ≤ τ x then true else false
CausalSmith.Stat.PolicyRegretMarginOverlap.optimalPolicy · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:71

Disagreement set D_π = {x : π(x) ≠ π_⋆(x)}.

Definition (Lean source)
def disagreementSet (π πstar : Policy 𝒳) : Set 𝒳 := {x | π x ≠ πstar x}
CausalSmith.Stat.PolicyRegretMarginOverlap.disagreementSet · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:77
def disagreementIndicator

Real indicator of disagreement.

Definition (Lean source)
def disagreementIndicator (π πstar : Policy 𝒳) (x : 𝒳) : ℝ := if π x ≠ πstar x then 1 else 0
CausalSmith.Stat.PolicyRegretMarginOverlap.disagreementIndicator · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:81
def welfare

Welfare V_P(π)=E_P[π(X) τ(X)]. @realizes V_P((𝒳→{0,1})→ℝ welfare functional)

Definition (Lean source)
noncomputable def welfare (PX : Measure 𝒳) (τ : 𝒳 → ℝ) (π : Policy 𝒳) : ℝ := ∫ x, boolIndicator (π x) * τ x ∂PX
CausalSmith.Stat.PolicyRegretMarginOverlap.welfare · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:85

Welfare regret R_P(π)=V_P(π_⋆)-V_P(π), with π_⋆=optimalPolicy τ. @realizes R_P((𝒳→{0,1})→ℝ regret functional)

Definition (Lean source)
noncomputable def regret (PX : Measure 𝒳) (τ : 𝒳 → ℝ) (π : Policy 𝒳) : ℝ := welfare PX τ (optimalPolicy τ) - welfare PX τ π
CausalSmith.Stat.PolicyRegretMarginOverlap.regret · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:91
structure ObservedLaw

Build-inline observed-law object: the covariate marginal, the per-draw observation law, and the law-side nuisance functionals the statements range over.

Definition (Lean source)
𝒳 :
Type*
dataMeasure :
PX :
Measure 𝒳
contrast :
𝒳 → ℝ
propensity :
𝒳 → ℝ
mu0 :
𝒳 → ℝ
mu1 :
𝒳 → ℝ
CausalSmith.Stat.PolicyRegretMarginOverlap.ObservedLaw · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:96
def overlap

Overlap p_P(x)=min(e_P(x),1-e_P(x)). @realizes p_P(min(e,1-e); ∈[0,1/2] since e∈[0,1] via WellFormedLaw)

Definition (Lean source)
noncomputable def overlap (P : ObservedLaw 𝒳) (x : 𝒳) : ℝ := min (P.propensity x) (1 - P.propensity x)
CausalSmith.Stat.PolicyRegretMarginOverlap.overlap · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:107
def lawOptimalPolicy

Law-attached optimal policy.

Definition (Lean source)
noncomputable def lawOptimalPolicy (P : ObservedLaw 𝒳) : Policy 𝒳 := optimalPolicy P.contrast
CausalSmith.Stat.PolicyRegretMarginOverlap.lawOptimalPolicy · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:112
def lawWelfare

Law-attached welfare.

Definition (Lean source)
noncomputable def lawWelfare (P : ObservedLaw 𝒳) (π : Policy 𝒳) : ℝ := welfare P.PX P.contrast π
CausalSmith.Stat.PolicyRegretMarginOverlap.lawWelfare · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:116
def lawRegret

Law-attached regret R_P(π).

Definition (Lean source)
noncomputable def lawRegret (P : ObservedLaw 𝒳) (π : Policy 𝒳) : ℝ := regret P.PX P.contrast π
CausalSmith.Stat.PolicyRegretMarginOverlap.lawRegret · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:120
def WellFormedLaw

Well-formedness of an observed law on 𝒳 × {0,1} × [-1,1]: the data law and its covariate marginal are PROBABILITY measures, P_X IS the covariate marginal of dataMeasure, the contrast is the regression difference τ = μ₁ - μ₀, and the propensity takes values in [0,1]. These are the ambient SPACE/probability/marginal facts (not statistical modelling assumptions); carrying them makes the welfare and minimax integrals genuine Bochner integrals (probability measures), not junk values.

Definition (Lean source)
def WellFormedLaw (P : ObservedLaw 𝒳) : Prop := IsProbabilityMeasure P.dataMeasure ∧ IsProbabilityMeasure P.PX ∧ P.dataMeasure.map (fun O => O.X) = P.PX ∧ -- Measurability of the law functionals: a well-formed law's contrast/propensity/regressions -- are measurable (implicit in the `.tex`'s Bochner integrals ∫|τ|·1{D_π}, ∫ e·φ, …). Regularity -- bookkeeping needed to make the welfare/regret integral manipulations genuine. Measurable P.contrast ∧ Measurable P.propensity ∧ Measurable P.mu0 ∧ Measurable P.mu1 ∧ (∀ x, P.contrast x = P.mu1 x - P.mu0 x) ∧ -- @realizes tau_P(contrast x = mu1 x - mu0 x) (∀ x, P.propensity x ∈ Icc (0 : ℝ) 1) ∧ -- @realizes e_P(propensity x ∈ Icc 0 1) (∀ φ : 𝒳 → ℝ, Measurable φ → (∃ M : ℝ, ∀ x, |φ x| ≤ M) → ∫ O, boolIndicator O.A * φ O.X ∂P.dataMeasure = ∫ x, P.propensity x * φ x ∂P.PX) ∧ -- @realizes e_P(e_P = P(A=1∣X): ∫ 1{A}·φ dP = ∫ e_P·φ dP_X) (∀ φ : 𝒳 → ℝ, Measurable φ → (∃ M : ℝ, ∀ x, |φ x| ≤ M) → ∫ O, boolIndicator O.A * O.Y * φ O.X ∂P.dataMeasure = ∫ x, P.propensity x * P.mu1 x * φ x ∂P.PX) ∧ -- @realizes mu_1(mu1 = E[Y∣A=1,X]: ∫ 1{A}·Y·φ dP = ∫ e_P·mu1·φ dP_X) (∀ φ : 𝒳 → ℝ, Measurable φ → (∃ M : ℝ, ∀ x, |φ x| ≤ M) → ∫ O, (1 - boolIndicator O.A) * O.Y * φ O.X ∂P.dataMeasure = ∫ x, (1 - P.propensity x) * P.mu0 x * φ x ∂P.PX) -- @realizes mu_0(mu0 = E[Y∣A=0,X]: ∫ 1{A=0}·Y·φ dP = ∫ (1-e_P)·mu0·φ dP_X)
CausalSmith.Stat.PolicyRegretMarginOverlap.WellFormedLaw · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:124

A1 i.i.d. sampling (ass:iid): the n observations are an i.i.d. sample drawn from the observed law P. This carries the FULL i.i.d. sampling content by reusing the cluster primitive Causalean.Stat.IIDSample — a sequence of measurable maps Z i on a common ambient probability space (Ω, μ) with mutual independence (iIndepFun), identical distribution (IdentDistrib), and law-match μ.map (Z 0) = P.dataMeasure — rather than only asserting that the one-draw law is a probability measure (which omits the i.i.d. content). The conjoined IsProbabilityMeasure P.dataMeasure certifies that the per-draw law, hence the n-fold experiment Measure.pi (fun _ : Fin n => P.dataMeasure) formed downstream, is a probability measure.

Definition (Lean source)
def IsIIDSample (P : ObservedLaw 𝒳) : Prop := IsProbabilityMeasure P.dataMeasure ∧ ∃ (Ω : Type) (_mΩ : MeasurableSpace Ω) (μ : @Measure Ω _mΩ), Nonempty (@IIDSample Ω (Observation 𝒳) _mΩ instMeasurableSpaceObservation μ P.dataMeasure)
CausalSmith.Stat.PolicyRegretMarginOverlap.IsIIDSample · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:164

A2 bounded outcomes: the (potential) outcome Y(a) lies in [-1,1] for both treatment arms a ∈ {0,1}. Treatment is binary at the TYPE level (Observation.A : Bool, true ↦ 1), so the observed-law projection of Y(a) ∈ [-1,1] is the conjunction of: the OBSERVED outcome lies in the EXACT range [-1,1] a.s. under the data law (the realized Y = Y(A), hence the realized arm's potential outcome), and both outcome REGRESSIONS μ₀, μ₁ — the arm-conditional means E[Y(a)|X] for a ∈ {0,1} — also lie in [-1,1]. The ranges are stated as Set.Icc (-1) 1 membership so the encoding realizes the [-1,1] symbol space exactly (not merely an absolute-value surrogate).

Definition (Lean source)
def BoundedOutcome (P : ObservedLaw 𝒳) : Prop := (∀ᵐ O ∂P.dataMeasure, O.Y ∈ Icc (-1 : ℝ) 1) ∧ -- @realizes Y(O.Y ∈ Icc (-1) 1 a.s.) (∀ x, P.mu0 x ∈ Icc (-1 : ℝ) 1 ∧ P.mu1 x ∈ Icc (-1 : ℝ) 1) -- @realizes mu_0(mu0 x ∈ Icc (-1) 1), mu_1(mu1 x ∈ Icc (-1) 1)
CausalSmith.Stat.PolicyRegretMarginOverlap.BoundedOutcome · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:181

A3 positivity: 0 < e_P(X) < 1 holds P_X-a.s. @realizes e_P(a.s. 0 < propensity x ∧ propensity x < 1)

Definition (Lean source)
def Positivity (P : ObservedLaw 𝒳) : Prop := ∀ᵐ x ∂P.PX, 0 < P.propensity x ∧ P.propensity x < 1
CausalSmith.Stat.PolicyRegretMarginOverlap.Positivity · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:195

A4 Tsybakov margin: P(0<|τ|≤u) ≤ C_m u^α for 0 < u ≤ u_0, with the named condition's intrinsic parameter domain — nonnegative margin exponent α, positive constant C_m, positive window u_0 ([Tsybakov 2004]). The domain is load-bearing: without 0 ≤ α the localization bound is false (α = -2 gives exponent 2, and a constant-contrast law forces 1 ≤ C·R², impossible uniformly as R → 0).

Definition (Lean source)
def MarginTail (P : ObservedLaw 𝒳) (Cm α u0 : ℝ) : Prop := 0 ≤ α ∧ 0 < Cm ∧ 0 < u0 ∧ ∀ u : ℝ, 0 < u → u ≤ u0 → P.PX.real {x | 0 < |P.contrast x| ∧ |P.contrast x| ≤ u} ≤ Cm * u ^ α
CausalSmith.Stat.PolicyRegretMarginOverlap.MarginTail · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:201
def ZeroEffectRegular Assumption 7 in the paper ↗

A5 canonical zero-effect region: either the zero-contrast set is null, or every policy in the class agrees with π_⋆ there.

Definition (Lean source)
def ZeroEffectRegular (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) : Prop := P.PX.real {x | P.contrast x = 0} = 0 ∨ ∀ π ∈ policySet, P.PX.real {x | P.contrast x = 0 ∧ π x ≠ lawOptimalPolicy P x} = 0
CausalSmith.Stat.PolicyRegretMarginOverlap.ZeroEffectRegular · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:212

A6 (novel) one-sided overlap-decay envelope: P{p_P ≤ v, 0<|τ|≤u} ≤ C_o u^α v^{1/γ} for 0<v ≤ c_o u^γ (with v^{1/γ}=1 when γ=0) in the margin window 0 < u ≤ u_0.

Definition (Lean source)
def OverlapDecay (P : ObservedLaw 𝒳) (u0 Co co α γ : ℝ) : Prop := ∀ u v : ℝ, 0 < u → u ≤ u0 → 0 < v → v ≤ co * u ^ γ → P.PX.real {x | overlap P x ≤ v ∧ 0 < |P.contrast x| ∧ |P.contrast x| ≤ u} ≤ Co * u ^ α * (if γ = 0 then 1 else v ^ (1 / γ))
CausalSmith.Stat.PolicyRegretMarginOverlap.OverlapDecay · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:220

A7 pointwise measurable finite-VC policy class with a countable pointwise-dense skeleton Π₀ and polynomial (Sauer–Shelah) trace growth at VC-dimension d_Π. @realizes Pi(policySet : Set (Policy 𝒳); measurable, countable dense skeleton, finite-VC)

Definition (Lean source)
def PolicyClassVC (policySet : Set (Policy 𝒳)) (dPi : ℕ) : Prop := (∀ π ∈ policySet, Measurable π) ∧ (∃ Pi0 : Set (Policy 𝒳), Pi0.Countable ∧ Pi0 ⊆ policySet ∧ ∀ π ∈ policySet, ∃ seq : ℕ → Policy 𝒳, (∀ j, seq j ∈ Pi0) ∧ ∀ x, ∀ᶠ j in atTop, seq j x = π x) ∧ (∀ m : ℕ, ∀ s : Fin m → 𝒳, card ((fun π : Policy 𝒳 => fun i => π (s i)) '' policySet) ≤ (m + 1) ^ dPi)
CausalSmith.Stat.PolicyRegretMarginOverlap.PolicyClassVC · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:229

A8 optimum-in-class: π_⋆ ∈ Π.

Definition (Lean source)
def OptimalInClass (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) : Prop := lawOptimalPolicy P ∈ policySet
CausalSmith.Stat.PolicyRegretMarginOverlap.OptimalInClass · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:242

A9 margin-window normalization: 0 < u_0 < 2.

Definition (Lean source)
def MarginWindow (u0 : ℝ) : Prop := 0 < u0 ∧ u0 < 2
CausalSmith.Stat.PolicyRegretMarginOverlap.MarginWindow · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:247

A10 cross-fit L²(P) nuisance rates with product rate O(n^{-1/2}). The per-n L²(P) rate bounds ‖μ̂_a-μ_a‖ ≤ r_μ,n, ‖ê-e‖ ≤ r_e,n are definitional (they DEFINE the rate schedules r_μ,n, r_e,n), so they are stated for every n; the product rate is the genuinely ASYMPTOTIC O(n^{-1/2}) of the NL — stated as an EVENTUAL bound (∀ᶠ n in atTop), not a per-n claim that would be false at n=0 (where (0:ℝ)^{-1/2}=0).

Definition (Lean source)
def NuisanceRate (P : ObservedLaw 𝒳) (muHat0 muHat1 eHat : ℕ → 𝒳 → ℝ) (rMu rE : ℕ → ℝ) : Prop := (∀ n, ∫ x, (muHat0 n x - P.mu0 x) ^ 2 ∂P.PX ≤ (rMu n) ^ 2) ∧ (∀ n, ∫ x, (muHat1 n x - P.mu1 x) ^ 2 ∂P.PX ≤ (rMu n) ^ 2) ∧ (∀ n, ∫ x, (eHat n x - P.propensity x) ^ 2 ∂P.PX ≤ (rE n) ^ 2) ∧ (∃ C : ℝ, 0 < C ∧ ∀ᶠ n : ℕ in atTop, rMu n * rE n ≤ C * (n : ℝ) ^ (-(1 / 2 : ℝ)))
CausalSmith.Stat.PolicyRegretMarginOverlap.NuisanceRate · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:251
def StrictOverlapEndpoint Assumption 10 in the paper ↗

A11 strict-overlap endpoint: when γ=0, p_P ≥ underline_p a.s.

Definition (Lean source)
def StrictOverlapEndpoint (P : ObservedLaw 𝒳) (γ underlineP : ℝ) : Prop := γ = 0 → 0 < underlineP ∧ underlineP ≤ 1 / 2 ∧ (∀ᵐ x ∂P.PX, underlineP ≤ overlap P x)
CausalSmith.Stat.PolicyRegretMarginOverlap.StrictOverlapEndpoint · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:266
def BoundedCrossfitNuisances Assumption 13 in the paper ↗

A12 bounded cross-fit outcome regressions: μ̂_a ∈ [-1,1].

Definition (Lean source)
def BoundedCrossfitNuisances (muHat0 muHat1 : ℕ → 𝒳 → ℝ) : Prop := ∀ n x, muHat0 n x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 n x ∈ Icc (-1 : ℝ) 1
CausalSmith.Stat.PolicyRegretMarginOverlap.BoundedCrossfitNuisances · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:272
def PolynomialNuisanceExponents Assumption 14 in the paper ↗

A13 polynomial nuisance exponents: r_μ ≤ C_μ n^{-a} and r_μ r_e ≤ C_prod n^{-c} for large n, with a ≥ 0, c ≥ 1/2.

Definition (Lean source)
def PolynomialNuisanceExponents (rMu rE : ℕ → ℝ) (a c CMu CProd : ℝ) : Prop := 0 ≤ a ∧ 1 / 2 ≤ c ∧ ∀ᶠ n in atTop, rMu n ≤ CMu * (n : ℝ) ^ (-a) ∧ rMu n * rE n ≤ CProd * (n : ℝ) ^ (-c)
CausalSmith.Stat.PolicyRegretMarginOverlap.PolynomialNuisanceExponents · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:277

A14 fixed-K balanced cross-fitting: K is a fixed positive integer independent of n (a single , not an n-indexed quantity), and the deterministic fold-assignment assign n : Fin n → Fin K realizes a balanced partition I_1,…,I_K of {1,…,n} whose every cell has size ⌊n/K⌋ or ⌊n/K⌋+1.

Definition (Lean source)
def FixedFoldCount (K : ℕ) (assign : (n : ℕ) → Fin n → Fin K) : Prop := 0 < K ∧ ∀ n : ℕ, ∀ k : Fin K, card {i : Fin n // assign n i = k} = n / K ∨ card {i : Fin n // assign n i = k} = n / K + 1
CausalSmith.Stat.PolicyRegretMarginOverlap.FixedFoldCount · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:285
def PolicyCompatible

Policy-compatible increments factor through the binary policy decision π O.X. This is the well-posedness condition making the real-valued increment class a fixed kernel composition with the finite-VC binary policy traces, which is the structure needed for the localized empirical-process rate.

Definition (Lean source)
def PolicyCompatible (g : Policy 𝒳 → Observation 𝒳 → ℝ) : Prop := ∃ G : Observation 𝒳 → Bool → ℝ, ∀ π O, g π O = G O (π O.X)
CausalSmith.Stat.PolicyRegretMarginOverlap.PolicyCompatible · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:296
def VCLocalizedEnvelope Assumption 11 in the paper ↗

A15 localized finite-VC fixed-radius empirical-process envelope. This is a GENUINE in-EXPECTATION bound on a real centered policy-indexed empirical process (P_m - P) g_π built from an i.i.d. sample of size m drawn from P.dataMeasure (not an abstract scalar placeholder): for every policy-compatible increment g with envelope B and localized conditional second moment ≤ B² P_X(D_π), the EXPECTED localized supremum over {π : R_P(π) ≤ r} is bounded by C B m^{-1/2} r^{α/(2+2α)}(log m)^p. The second-moment coupling constant is fixed (, decoupled from the rate constant C).

Definition (Lean source)
def VCLocalizedEnvelope (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (α : ℝ) : Prop := ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ (m : ℕ) (B r : ℝ) (g : Policy 𝒳 → Observation 𝒳 → ℝ), PolicyCompatible g → 0 < m → 0 ≤ B → 0 ≤ r → (∀ π ∈ policySet, ∀ O, |g π O| ≤ B) → (∀ π ∈ policySet, ∫ O, (g π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → ∫ sample, sSup ((fun π => |(m : ℝ)⁻¹ * ∑ i, g π (sample i) - ∫ O, g π O ∂P.dataMeasure|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r}) ∂(Measure.pi (fun _ : Fin m => P.dataMeasure)) ≤ C * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log m) ^ p
CausalSmith.Stat.PolicyRegretMarginOverlap.VCLocalizedEnvelope · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:306
def VCLocalizedEnvelopeUnif

Uniform class-level version of VCLocalizedEnvelope. The constants C,p depend on the policy class and α, not on the individual law P; this is the shape needed before taking a supremum over laws in upperRisk.

Definition (Lean source)
def VCLocalizedEnvelopeUnif (policySet : Set (Policy 𝒳)) (α : ℝ) : Prop := ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ P : ObservedLaw 𝒳, ∀ (m : ℕ) (B r : ℝ) (g : Policy 𝒳 → Observation 𝒳 → ℝ), PolicyCompatible g → 0 < m → 0 ≤ B → 0 ≤ r → (∀ π ∈ policySet, ∀ O, |g π O| ≤ B) → (∀ π ∈ policySet, ∫ O, (g π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → ∫ sample, sSup ((fun π => |(m : ℝ)⁻¹ * ∑ i, g π (sample i) - ∫ O, g π O ∂P.dataMeasure|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r}) ∂(Measure.pi (fun _ : Fin m => P.dataMeasure)) ≤ C * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log m) ^ p
CausalSmith.Stat.PolicyRegretMarginOverlap.VCLocalizedEnvelopeUnif · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:333
theorem forall_vcLocalizedEnvelope

A uniform class-level localized envelope supplies the old per-law envelope for every law.

Formal statement
policySet :
Set (Policy 𝒳)
α :
h :
∀ P : ObservedLaw 𝒳, VCLocalizedEnvelope P policySet α
Proof (Lean source)
theorem VCLocalizedEnvelopeUnif.forall_vcLocalizedEnvelope (policySet : Set (Policy 𝒳)) (α : ℝ) (h : VCLocalizedEnvelopeUnif policySet α) : ∀ P : ObservedLaw 𝒳, VCLocalizedEnvelope P policySet α := by intro P rcases h with ⟨C, p, hC, hp, H⟩ exact ⟨C, p, hC, hp, H P⟩
CausalSmith.Stat.PolicyRegretMarginOverlap.VCLocalizedEnvelopeUnif.forall_vcLocalizedEnvelope · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:355
def VCLocalizedOffsetEnvelope Assumption 16 in the paper ↗

A16 localized finite-VC offset/Rademacher bound. The GENUINE in-EXPECTATION offset positive-part bound on a real centered empirical process (P_m - P) g_π from an i.i.d. sample of size m: E sup_π {2|z_π| - R_P(π)/4}_+ ≤ C (B²/m)^{A_α}(log m)^p, A_α=(1+α)/(2+α), with the same fixed second-moment coupling, for policy-compatible increments.

Definition (Lean source)
def VCLocalizedOffsetEnvelope (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (α : ℝ) : Prop := ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ (m : ℕ) (B : ℝ) (g : Policy 𝒳 → Observation 𝒳 → ℝ), PolicyCompatible g → 0 < m → 0 ≤ B → (∀ π ∈ policySet, ∀ O, |g π O| ≤ B) → (∀ π ∈ policySet, ∫ O, (g π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → ∫ sample, sSup ((fun π => max 0 (2 * |(m : ℝ)⁻¹ * ∑ i, g π (sample i) - ∫ O, g π O ∂P.dataMeasure| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin m => P.dataMeasure)) ≤ C * (B ^ 2 / (m : ℝ)) ^ ((1 + α) / (2 + α)) * (log m) ^ p
CausalSmith.Stat.PolicyRegretMarginOverlap.VCLocalizedOffsetEnvelope · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:368
def VCLocalizedOffsetEnvelopeUnif

Uniform class-level version of VCLocalizedOffsetEnvelope. The constants C,p are hoisted above ∀ P, matching the note's class-level finite-VC offset assumption.

Definition (Lean source)
def VCLocalizedOffsetEnvelopeUnif (policySet : Set (Policy 𝒳)) (α : ℝ) : Prop := ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ P : ObservedLaw 𝒳, ∀ (m : ℕ) (B : ℝ) (g : Policy 𝒳 → Observation 𝒳 → ℝ), PolicyCompatible g → 0 < m → 0 ≤ B → (∀ π ∈ policySet, ∀ O, |g π O| ≤ B) → (∀ π ∈ policySet, ∫ O, (g π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → ∫ sample, sSup ((fun π => max 0 (2 * |(m : ℝ)⁻¹ * ∑ i, g π (sample i) - ∫ O, g π O ∂P.dataMeasure| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin m => P.dataMeasure)) ≤ C * (B ^ 2 / (m : ℝ)) ^ ((1 + α) / (2 + α)) * (log m) ^ p
CausalSmith.Stat.PolicyRegretMarginOverlap.VCLocalizedOffsetEnvelopeUnif · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:389
theorem forall_vcLocalizedOffsetEnvelope

A uniform class-level localized offset envelope supplies the old per-law offset envelope for every law.

Formal statement
policySet :
Set (Policy 𝒳)
α :
∀ P : ObservedLaw 𝒳, VCLocalizedOffsetEnvelope P policySet α
Proof (Lean source)
theorem VCLocalizedOffsetEnvelopeUnif.forall_vcLocalizedOffsetEnvelope (policySet : Set (Policy 𝒳)) (α : ℝ) (h : VCLocalizedOffsetEnvelopeUnif policySet α) : ∀ P : ObservedLaw 𝒳, VCLocalizedOffsetEnvelope P policySet α := by intro P rcases h with ⟨C, p, hC, hp, H⟩ exact ⟨C, p, hC, hp, H P⟩
CausalSmith.Stat.PolicyRegretMarginOverlap.VCLocalizedOffsetEnvelopeUnif.forall_vcLocalizedOffsetEnvelope · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:409
def Aalpha

A_α = (1+α)/(2+α).

Definition (Lean source)
noncomputable def Aalpha (α : ℝ) : ℝ := (1 + α) / (2 + α)
CausalSmith.Stat.PolicyRegretMarginOverlap.Aalpha · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:421
def betaAG

Admissible weak-arm exponent β_{α,γ}.

Definition (Lean source)
noncomputable def betaAG (α γ : ℝ) : ℝ := if γ = 0 then 0 else α * γ / (α + 1)
CausalSmith.Stat.PolicyRegretMarginOverlap.betaAG · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:424
def Dag

Converse denominator D_{α,γ} = 2 + α + β_{α,γ}.

Definition (Lean source)
noncomputable def Dag (α γ : ℝ) : ℝ := 2 + α + betaAG α γ
CausalSmith.Stat.PolicyRegretMarginOverlap.Dag · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:428
def rStar

Information exponent r_⋆(α,γ) = (1+α)/D_{α,γ}.

Definition (Lean source)
noncomputable def rStar (α γ : ℝ) : ℝ := (1 + α) / Dag α γ
CausalSmith.Stat.PolicyRegretMarginOverlap.rStar · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:431

Derived information exponents (β_{α,γ}, D_{α,γ}, r_⋆).

Definition (Lean source)
noncomputable def infoExponents (α γ : ℝ) : ℝ × ℝ × ℝ := (betaAG α γ, Dag α γ, rStar α γ)
CausalSmith.Stat.PolicyRegretMarginOverlap.infoExponents · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:435
def feasiblePhi

The def:feasible-rate balance objective φ(s,t) for a fixed regime.

Definition (Lean source)
noncomputable def feasiblePhi (α γ a c s t : ℝ) : ℝ := min (min (Aalpha α * (1 - 2 * s)) (c - s)) (min (a + s / (2 * γ) + α * t / 2) (2 * a - t))
CausalSmith.Stat.PolicyRegretMarginOverlap.feasiblePhi · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:439
def gJoint

The joint feasible exponent g_joint, the maximal value of φ on the compact feasible box.

Definition (Lean source)
noncomputable def gJoint (α γ a c : ℝ) : ℝ := sSup ((fun st : ℝ × ℝ => feasiblePhi α γ a c st.1 st.2) '' {st : ℝ × ℝ | 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ})
CausalSmith.Stat.PolicyRegretMarginOverlap.gJoint · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:444
def feasibleMaximizer

A joint maximizer (s_feas, t_feas) of φ on the compact feasible box.

Definition (Lean source)
noncomputable def feasibleMaximizer (α γ a c : ℝ) : ℝ × ℝ := Classical.epsilon fun st : ℝ × ℝ => 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ ∧ feasiblePhi α γ a c st.1 st.2 = gJoint α γ a c
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleMaximizer · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:450
def sFeas

The analysis clip exponent s_feas (q_n = q_0 n^{-s_feas}).

Definition (Lean source)
noncomputable def sFeas (α γ a c : ℝ) : ℝ := (feasibleMaximizer α γ a c).1
CausalSmith.Stat.PolicyRegretMarginOverlap.sFeas · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:456
def tFeas

The margin-window exponent t_feas (u_n = ū n^{-t_feas}).

Definition (Lean source)
noncomputable def tFeas (α γ a c : ℝ) : ℝ := (feasibleMaximizer α γ a c).2
CausalSmith.Stat.PolicyRegretMarginOverlap.tFeas · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:459
def qSched

Feasible clip schedule. For γ>0 this is q_n = q_0 n^{-s_feas}; for γ=0 the construction uses the FIXED clip q_n = q_0 (≤ underline_p/2), per def:feasible-rate.

Definition (Lean source)
noncomputable def qSched (α γ a c q0 : ℝ) (n : ℕ) : ℝ := if γ = 0 then q0 else q0 * (n : ℝ) ^ (-(sFeas α γ a c))
CausalSmith.Stat.PolicyRegretMarginOverlap.qSched · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:462
def uSched

Feasible margin-window schedule u_n = ū n^{-t_feas}.

Definition (Lean source)
noncomputable def uSched (α γ a c uBar : ℝ) (n : ℕ) : ℝ := uBar * (n : ℝ) ^ (-(tFeas α γ a c))
CausalSmith.Stat.PolicyRegretMarginOverlap.uSched · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:468
def feasibleAdmissible

Large-n admissibility of the schedule: q_n ≤ c_o u_n^γ eventually.

Definition (Lean source)
def feasibleAdmissible (α γ a c co q0 uBar : ℝ) : Prop := ∀ᶠ n : ℕ in atTop, qSched α γ a c q0 n ≤ co * (uSched α γ a c uBar n) ^ γ
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleAdmissible · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:472
def FeasibleRateInputs

Admissible-input domain of def:feasible-rate: the NL constraints on the chosen window/clip constants ū, q₀ that the feasible-rate construction is stated over. For γ>0: ū ∈ (0,u₀] and q₀ ∈ (0, min{1/2, c_o ū^γ}]. For γ=0: the fixed clip obeys q₀ ∈ (0, underline_p/2]. These input restrictions are part of def:feasible-rate itself (not estimator-side assumptions); without them the selected schedule q_n = qSched, u_n = uSched need not lie in the admissible clipping range, so the conditional achievability exponent is stated over this domain.

Definition (Lean source)
def FeasibleRateInputs (γ co underlineP u0 q0 uBar : ℝ) : Prop := (0 < γ → 0 < uBar ∧ uBar ≤ u0 ∧ 0 < q0 ∧ q0 ≤ min (1 / 2) (co * uBar ^ γ)) ∧ (γ = 0 → 0 < q0 ∧ q0 ≤ underlineP / 2)
CausalSmith.Stat.PolicyRegretMarginOverlap.FeasibleRateInputs · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:477
def rFeas

The solved feasible upper exponent r_feas = min{r_⋆, g_joint} for γ>0, min{A_α, c} for γ=0. Standalone accessor of the FeasibleRate.r field, so a downstream consumer that needs only the exponent VALUE (not the full certified construction, which requires the input-domain certificate) can name it directly.

Definition (Lean source)
noncomputable def rFeas (α γ a c : ℝ) : ℝ := if γ = 0 then min (Aalpha α) c else min (rStar α γ) (gJoint α γ a c)
CausalSmith.Stat.PolicyRegretMarginOverlap.rFeas · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:488

The feasible box of schedule exponents is compact when the overlap exponent is positive. The set of pairs consisting of a clip exponent between zero and one half and a margin-window exponent between zero and the clip exponent divided by the overlap exponent is closed and bounded, hence compact. This is what allows the balance objective to attain its supremum.

Formal statement
γ :
:
0 < γ
IsCompact ({st : ℝ × ℝ | 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ})
Proof (Lean source)
lemma feasibleSet_compact (γ : ℝ) (hγ : 0 < γ) : IsCompact ({st : ℝ × ℝ | 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ}) := by let K : Set (ℝ × ℝ) := {st : ℝ × ℝ | 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ} have hrect : IsCompact (Icc ((0 : ℝ), (0 : ℝ)) ((1 / 2 : ℝ), 1 / (2 * γ))) := isCompact_Icc have hclosed : IsClosed K := by have h1 : IsClosed ({st : ℝ × ℝ | (0 : ℝ) ≤ st.1}) := by simpa using (isClosed_le continuous_const continuous_fst) have h2 : IsClosed ({st : ℝ × ℝ | st.1 ≤ (1 / 2 : ℝ)}) := by simpa using (isClosed_le continuous_fst continuous_const) have h3 : IsClosed ({st : ℝ × ℝ | (0 : ℝ) ≤ st.2}) := by simpa using (isClosed_le continuous_const continuous_snd) have h4 : IsClosed ({st : ℝ × ℝ | st.2 ≤ st.1 / γ}) := by simpa using (isClosed_le continuous_snd (continuous_fst.div_const γ)) simpa [K, Set.setOf_and, Set.inter_assoc] using (((h1.inter h2).inter h3).inter h4) have hsub : K ⊆ Icc ((0 : ℝ), (0 : ℝ)) ((1 / 2 : ℝ), 1 / (2 * γ)) := by intro st hst rcases hst with ⟨hs0, hs1, ht0, hts⟩ constructor · exact ⟨hs0, ht0⟩ · constructor · exact hs1 · have hle : st.1 / γ ≤ (1 / 2 : ℝ) / γ := by gcongr have hcalc : (1 / 2 : ℝ) / γ = 1 / (2 * γ) := by ring linarith simpa [K] using hrect.of_isClosed_subset hclosed hsub
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleSet_compact · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:496

The balance objective attains its supremum on the feasible box when the overlap exponent is positive: there is a pair of schedule exponents inside the box at which the objective equals the joint feasible exponent. Continuity of the objective on a nonempty compact set supplies the maximizer.

Formal statement
α γ a c :
:
0 < γ
∃ st : ℝ × ℝ,
0 ≤ st.1 ∧
st.1 ≤ 1 / 2 ∧
0 ≤ st.2 ∧
st.2 ≤ st.1 / γ ∧
feasiblePhi α γ a c st.1 st.2 = gJoint α γ a c
Proof (Lean source)
lemma feasibleMaximizer_exists (α γ a c : ℝ) (hγ : 0 < γ) : ∃ st : ℝ × ℝ, 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ ∧ feasiblePhi α γ a c st.1 st.2 = gJoint α γ a c := by let K : Set (ℝ × ℝ) := {st : ℝ × ℝ | 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ} have hK : IsCompact K := by simpa [K] using feasibleSet_compact γ hγ have hne : K.Nonempty := by refine ⟨(0, 0), ?_⟩ simp [K] let f : ℝ × ℝ → ℝ := fun st => feasiblePhi α γ a c st.1 st.2 have hf : ContinuousOn f K := by dsimp [f, feasiblePhi, Aalpha] fun_prop rcases hK.exists_sSup_image_eq hne hf with ⟨st, hst, hstmax⟩ refine ⟨st, ?_⟩ rcases hst with ⟨hs0, hs1, ht0, htle⟩ refine ⟨hs0, hs1, ht0, htle, ?_⟩ simpa [gJoint, K, f] using hstmax.symm
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleMaximizer_exists · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:531

Defining property of the selected feasible maximizer. When the overlap exponent is positive, the chosen pair of schedule exponents lies in the feasible box — clip exponent between zero and one half, margin-window exponent between zero and the clip exponent divided by the overlap exponent — and the balance objective evaluated there equals the joint feasible exponent. This is the specification satisfied by the arbitrary choice of maximizer.

Formal statement
α γ a c :
:
0 < γ
0 ≤ (feasibleMaximizer α γ a c).1 ∧
(feasibleMaximizer α γ a c).1 ≤ 1 / 2 ∧
0 ≤ (feasibleMaximizer α γ a c).2 ∧
(feasibleMaximizer α γ a c).2 ≤ (feasibleMaximizer α γ a c).1 / γ ∧
feasiblePhi α γ a c (feasibleMaximizer α γ a c).1 (feasibleMaximizer α γ a c).2
= gJoint α γ a c
Proof (Lean source)
lemma feasibleMaximizer_spec (α γ a c : ℝ) (hγ : 0 < γ) : 0 ≤ (feasibleMaximizer α γ a c).1 ∧ (feasibleMaximizer α γ a c).1 ≤ 1 / 2 ∧ 0 ≤ (feasibleMaximizer α γ a c).2 ∧ (feasibleMaximizer α γ a c).2 ≤ (feasibleMaximizer α γ a c).1 / γ ∧ feasiblePhi α γ a c (feasibleMaximizer α γ a c).1 (feasibleMaximizer α γ a c).2 = gJoint α γ a c := by have hex := feasibleMaximizer_exists α γ a c hγ simpa [feasibleMaximizer] using Classical.epsilon_spec hex
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleMaximizer_spec · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:556
theorem feasibleMaximizer_mem

The feasibleMaximizer epsilon-choice lands in the compact feasible box (γ>0). Existence of a maximizer — continuity of feasiblePhi on the nonempty compact box {0≤s≤1/2, 0≤t≤s/γ} (Mathlib IsCompact.exists_isMaxOn) — makes the Classical.epsilon specification inhabited, so its first/second components are feasible. (Certifies def:feasible-rate's "let (s_feas,t_feas) be any maximizer".)

Formal statement
α γ a c :
:
0 < γ
0 ≤ sFeas α γ a c ∧
sFeas α γ a c ≤ 1 / 2 ∧
0 ≤ tFeas α γ a c ∧
tFeas α γ a c ≤ sFeas α γ a c / γ
Proof (Lean source)
lemma feasibleMaximizer_mem (α γ a c : ℝ) (hγ : 0 < γ) : 0 ≤ sFeas α γ a c ∧ sFeas α γ a c ≤ 1 / 2 ∧ 0 ≤ tFeas α γ a c ∧ tFeas α γ a c ≤ sFeas α γ a c / γ := by rcases feasibleMaximizer_spec α γ a c hγ with ⟨hs0, hs1, ht0, ht1, _hmax⟩ exact ⟨hs0, hs1, ht0, ht1⟩
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleMaximizer_mem · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:572
theorem feasibleMaximizer_isMaxOn

The feasibleMaximizer epsilon-choice MAXIMIZES feasiblePhi over the compact feasible box (γ>0); hence g_joint = feasiblePhi (s_feas) (t_feas).

Formal statement
α γ a c :
:
0 < γ
∀ s' t' : ℝ
if
0 ≤ s'
and
s' ≤ 1 / 2
and
0 ≤ t'
and
t' ≤ s' / γ
then
feasiblePhi α γ a c s' t' ≤ feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c)
Proof (Lean source)
lemma feasibleMaximizer_isMaxOn (α γ a c : ℝ) (hγ : 0 < γ) : ∀ s' t' : ℝ, 0 ≤ s' → s' ≤ 1 / 2 → 0 ≤ t' → t' ≤ s' / γ → feasiblePhi α γ a c s' t' ≤ feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) := by intro s' t' hs0 hs1 ht0 ht1 rcases feasibleMaximizer_spec α γ a c hγ with ⟨_hs0, _hs1, _ht0, _ht1, hmaxeq⟩ have hst_mem : (s', t') ∈ ({st : ℝ × ℝ | 0 ≤ st.1 ∧ st.1 ≤ 1 / 2 ∧ 0 ≤ st.2 ∧ st.2 ≤ st.1 / γ}) := by exact ⟨hs0, hs1, ht0, ht1⟩ have hle : feasiblePhi α γ a c s' t' ≤ gJoint α γ a c := by unfold gJoint refine le_csSup ?_ ?_ · have hK := feasibleSet_compact γ hγ exact hK.bddAbove_image (by dsimp [feasiblePhi, Aalpha] fun_prop) · exact ⟨(s', t'), hst_mem, rfl⟩ calc feasiblePhi α γ a c s' t' ≤ gJoint α γ a c := hle _ = feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) := by simpa [sFeas, tFeas] using hmaxeq.symm
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleMaximizer_isMaxOn · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:584
theorem feasibleMaximizer_value

The selected feasible maximizer attains the joint exponent value.

Formal statement
α γ a c :
:
0 < γ
feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) = gJoint α γ a c
Proof (Lean source)
lemma feasibleMaximizer_value (α γ a c : ℝ) (hγ : 0 < γ) : feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) = gJoint α γ a c := by rcases feasibleMaximizer_spec α γ a c hγ with ⟨_hs0, _hs1, _ht0, _ht1, hmaxeq⟩ simpa [sFeas, tFeas] using hmaxeq
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleMaximizer_value · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:610
theorem feasibleRate_admissible_of_inputs

Eventual schedule admissibility q_n ≤ c_o u_n^γ (γ>0): the selected clip q_n = q_0 n^{-s_feas} stays under c_o u_n^γ = c_o ū^γ n^{-γ t_feas} for all large n, because q_0 ≤ c_o ū^γ (input domain FeasibleRateInputs) and t_feas ≤ s_feas/γ (maximizer feasibility) give the exponent comparison. This is the construction's "Then q_n ≤ c_o u_n^γ for all large n" conclusion, derived from the inputs rather than separately assumed.

Formal statement
α γ a c co underlineP u0 q0 uBar :
hin :
FeasibleRateInputs γ co underlineP u0 q0 uBar
0 < γ → feasibleAdmissible α γ a c co q0 uBar
Proof (Lean source)
lemma feasibleRate_admissible_of_inputs (α γ a c co underlineP u0 q0 uBar : ℝ) (hin : FeasibleRateInputs γ co underlineP u0 q0 uBar) : 0 < γ → feasibleAdmissible α γ a c co q0 uBar := by intro hγ unfold feasibleAdmissible rcases (hin.1 hγ) with ⟨huBar0, _huBar_le, hq0, hq0le⟩ have hq0le_co : q0 ≤ co * uBar ^ γ := by exact le_trans hq0le (min_le_right _ _) have hγne : γ ≠ 0 := ne_of_gt hγ rcases feasibleMaximizer_mem α γ a c hγ with ⟨_hs0, _hs1, _ht0, htle⟩ filter_upwards [Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hn have hn1 : (1 : ℝ) ≤ (n : ℝ) := by exact_mod_cast hn have hnpos : (0 : ℝ) < n := lt_of_lt_of_le (by norm_num) hn1 have hbase_nonneg : (0 : ℝ) ≤ n := le_of_lt hnpos have hγt_le_s : γ * tFeas α γ a c ≤ sFeas α γ a c := by simpa [mul_comm] using (le_div_iff₀ hγ).mp htle have hpow_exp : (n : ℝ) ^ (-(sFeas α γ a c)) ≤ (n : ℝ) ^ (-(γ * tFeas α γ a c)) := by apply Real.rpow_le_rpow_of_exponent_le hn1 linarith have hpow_nonneg : 0 ≤ (n : ℝ) ^ (-(sFeas α γ a c)) := Real.rpow_nonneg hbase_nonneg _ have hmain : q0 * (n : ℝ) ^ (-(sFeas α γ a c)) ≤ (co * uBar ^ γ) * (n : ℝ) ^ (-(γ * tFeas α γ a c)) := by calc q0 * (n : ℝ) ^ (-(sFeas α γ a c)) ≤ (co * uBar ^ γ) * (n : ℝ) ^ (-(sFeas α γ a c)) := by exact mul_le_mul_of_nonneg_right hq0le_co hpow_nonneg _ ≤ (co * uBar ^ γ) * (n : ℝ) ^ (-(γ * tFeas α γ a c)) := by have hcoef_nonneg : 0 ≤ co * uBar ^ γ := le_trans (le_of_lt hq0) hq0le_co exact mul_le_mul_of_nonneg_left hpow_exp hcoef_nonneg have hpow_mul : (uBar * (n : ℝ) ^ (-(tFeas α γ a c))) ^ γ = uBar ^ γ * (n : ℝ) ^ (-(γ * tFeas α γ a c)) := by rw [Real.mul_rpow (le_of_lt huBar0) (Real.rpow_nonneg hbase_nonneg _)] rw [← Real.rpow_mul hbase_nonneg] ring_nf rw [qSched, uSched, if_neg hγne] calc q0 * (n : ℝ) ^ (-(sFeas α γ a c)) ≤ (co * uBar ^ γ) * (n : ℝ) ^ (-(γ * tFeas α γ a c)) := hmain _ = co * (uBar ^ γ * (n : ℝ) ^ (-(γ * tFeas α γ a c))) := by ring _ = co * (uBar * (n : ℝ) ^ (-(tFeas α γ a c))) ^ γ := by rw [hpow_mul]
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleRate_admissible_of_inputs · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:617
structure FeasibleRate Definition 7 in the paper ↗

Certified feasible-rate object (def:feasible-rate). Bundles the construction DATA — the maximizer exponents (s_feas, t_feas), the SELECTED clip/window schedules q_n = qSched, u_n = uSched (with the γ=0 fixed-clip branch baked into qSched), and the solved exponent r_feas — TOGETHER WITH the certifying PROPERTIES the NL construction asserts, bundled INTO the object rather than split into separate consumer hypotheses: the input-domain restriction on the chosen window/clip constants ū, q₀ (inputs); feasibility and maximality of (s_feas, t_feas) on the compact box for γ>0 (feasible, maximal, so g_joint = φ(s_feas, t_feas)); the definitional schedule/exponent ties (qDef, uDef, rDef); and the eventual schedule admissibility q_n ≤ c_o u_n^γ (admissible).

Definition (Lean source)
α γ a c co underlineP u0 q0 uBar :
Analysis clip exponent `s_feas` (`q_n = q_0 n^{-s_feas}` for `γ>0`).
s :
Margin-window exponent `t_feas` (`u_n = ū n^{-t_feas}`).
t :
Solved feasible upper exponent `r_feas`.
r :
Selected clip schedule `q_n` (γ-branched).
q :
ℕ → ℝ
Selected window schedule `u_n`.
u :
ℕ → ℝ
NL input-domain restriction on the chosen window/clip constants `ū, q₀` (`ū ∈ (0,u₀]`, `q₀ ∈ (0, min{1/2, c_o ū^γ}]` for `γ>0`; `q₀ ∈ (0, underline_p/2]` for `γ=0`).
inputs :
FeasibleRateInputs γ co underlineP u0 q0 uBar
`(s_feas, t_feas)` lies in the compact feasible box (`γ>0`).
feasible :
0 < γ → 0 ≤ s ∧ s ≤ 1 / 2 ∧ 0 ≤ t ∧ t ≤ s / γ
`(s_feas, t_feas)` MAXIMIZES `feasiblePhi` over the compact box (`γ>0`), so `g_joint = feasiblePhi (s_feas) (t_feas)`.
maximal :
0 < γ → ∀ s' t' : ℝ, 0
≤ s' → s' ≤ 1 / 2 → 0 ≤ t' → t' ≤ s' / γ → feasiblePhi α γ a c s' t' ≤ feasiblePhi α γ a c s t
Selected clip schedule definition `q_n = qSched`.
qDef :
q = qSched α γ a c q0
Selected window schedule definition `u_n = uSched`.
uDef :
u = uSched α γ a c uBar
Solved-exponent definition `r_feas = min{r_⋆, g_joint}` (`γ>0`) / `min{A_α, c}` (`γ=0`).
rDef :
r = rFeas α γ a c
Eventual schedule admissibility `q_n ≤ c_o u_n^γ` (`γ>0`).
admissible :
0 < γ → feasibleAdmissible α γ a c co q0 uBar
CausalSmith.Stat.PolicyRegretMarginOverlap.FeasibleRate · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:671
def feasibleRate

Feasible-rate construction (def:feasible-rate). Given the NL input-domain certificate hin, packages the maximizer exponents (s_feas, t_feas), the selected schedules, the solved exponent r_feas, and the certifying properties (feasibility from feasibleMaximizer_mem, maximality from feasibleMaximizer_isMaxOn, admissibility from feasibleRate_admissible_of_inputs) into the certified FeasibleRate object. The exponent value is rFeas α γ a c.

Definition (Lean source)
noncomputable def feasibleRate (α γ a c co underlineP u0 q0 uBar : ℝ) (hin : FeasibleRateInputs γ co underlineP u0 q0 uBar) : FeasibleRate α γ a c co underlineP u0 q0 uBar where s := sFeas α γ a c t := tFeas α γ a c r := rFeas α γ a c q := qSched α γ a c q0 u := uSched α γ a c uBar inputs := hin feasible := feasibleMaximizer_mem α γ a c maximal := feasibleMaximizer_isMaxOn α γ a c qDef := rfl uDef := rfl rDef := rfl admissible := feasibleRate_admissible_of_inputs α γ a c co underlineP u0 q0 uBar hin
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleRate · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:713
def hLower

Lower-bound contrast height h_n = n^{-1/D_{α,γ}}.

Definition (Lean source)
noncomputable def hLower (α γ : ℝ) (n : ℕ) : ℝ := (n : ℝ) ^ (-(1 / Dag α γ))
CausalSmith.Stat.PolicyRegretMarginOverlap.hLower · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:735
def qLower

Lower-bound weak-arm scale q_n = 1/4 if β_{α,γ}=0 else h_n^{β_{α,γ}}.

Definition (Lean source)
noncomputable def qLower (α γ : ℝ) (n : ℕ) : ℝ := if betaAG α γ = 0 then 1 / 4 else (hLower α γ n) ^ betaAG α γ
CausalSmith.Stat.PolicyRegretMarginOverlap.qLower · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:739
def clippedPropensity Definition 8 in the paper ↗

Clipped propensity e_q(x)=min(1-q, max(q, e(x))).

Definition (Lean source)
noncomputable def clippedPropensity (q : ℝ) (e : 𝒳 → ℝ) (x : 𝒳) : ℝ := min (1 - q) (max q (e x))
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPropensity · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:746
def clippedAIPWScore Definition 9 in the paper ↗

Clipped AIPW score Γ_q(O;η)=μ₁-μ₀+(A/e_q)(Y-μ₁)-((1-A)/(1-e_q))(Y-μ₀).

Definition (Lean source)
noncomputable def clippedAIPWScore (q : ℝ) (mu0 mu1 e : 𝒳 → ℝ) (O : Observation 𝒳) : ℝ := mu1 O.X - mu0 O.X + (boolIndicator O.A / clippedPropensity q e O.X) * (O.Y - mu1 O.X) - ((1 - boolIndicator O.A) / (1 - clippedPropensity q e O.X)) * (O.Y - mu0 O.X)
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedAIPWScore · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:751
def empiricalWelfareScore

Cross-fitted empirical clipped-AIPW welfare criterion V̂_{n,q}(π)=n⁻¹ ∑_i π(X_i) Γ_q(O_i; η̂^{(-k(i))}), where assign i = k(i) is the evaluation fold of observation i and η̂^{(-k)} are the foldwise cross-fitted nuisances indexed by fold k.

Definition (Lean source)
noncomputable def empiricalWelfareScore {n K : ℕ} (q : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (sample : Fin n → Observation 𝒳) (π : Policy 𝒳) : ℝ := (n : ℝ)⁻¹ * ∑ i, boolIndicator (π (sample i).X) * clippedAIPWScore q (muHat0 (assign i)) (muHat1 (assign i)) (eHat (assign i)) (sample i)
CausalSmith.Stat.PolicyRegretMarginOverlap.empiricalWelfareScore · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:759

Feasible clipped-AIPW 1/n-ERM over the countable pointwise-dense skeleton Π₀ enumerated by enum : ℕ → Policy 𝒳. With foldwise cross-fitted nuisances η̂^{(-k)} and fold assignment assign, π̂_n = enum j_n where j_n is the SMALLEST index j such that enum j is a 1/n-near-maximizer of the cross-fitted criterion over the whole enumeration (sInf of the near-maximizer index set).

Definition (Lean source)
noncomputable def feasibleERM {n K : ℕ} (q : ℝ) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (sample : Fin n → Observation 𝒳) : Policy 𝒳 := enum (sInf {j : ℕ | ∀ j' : ℕ, empiricalWelfareScore q muHat0 muHat1 eHat assign sample (enum j') ≤ empiricalWelfareScore q muHat0 muHat1 eHat assign sample (enum j) + (n : ℝ)⁻¹})
CausalSmith.Stat.PolicyRegretMarginOverlap.feasibleERM · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:771
def DenseSkeleton

enum enumerates the countable pointwise-dense skeleton Π₀ of the policy class (the ass:policy-class / def:feasible-erm requirement): every enum j lies in Π, and every π ∈ Π is the pointwise limit of an enum-indexed subsequence. This is the note's dense-Π₀ enumeration condition on enum; it is what reduces sup_Π V̂ to sup_j V̂(enum j), so the feasibleERM near-maximizer is a genuine Π-wide 1/n-ERM rather than an ERM over an ARBITRARY enumeration.

Definition (Lean source)
def DenseSkeleton (enum : ℕ → Policy 𝒳) (policySet : Set (Policy 𝒳)) : Prop := (∀ j, enum j ∈ policySet) ∧ ∀ π ∈ policySet, ∃ seq : ℕ → ℕ, ∀ x, ∀ᶠ j in atTop, enum (seq j) x = π x
CausalSmith.Stat.PolicyRegretMarginOverlap.DenseSkeleton · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:785

Minimax regret M_n = inf_{π̂} sup_{P ∈ 𝓟} E_P R_P(π̂). The infimum ranges ONLY over MEASURABLE Π-valued estimators: est sample ∈ policySet for every realized sample (Π-valued), and the induced per-law regret map sample ↦ R_P(est sample) is measurable for every law (so each E_P R_P(π̂) is genuinely the Bochner integral, not a junk value). The regret loss is bounded in [0,2], so the iInf/iSup are well-posed.

Definition (Lean source)
noncomputable def minimaxRegret (𝓟 : Set (ObservedLaw 𝒳)) (policySet : Set (Policy 𝒳)) (n : ℕ) : ℝ := ⨅ est : {est : (Fin n → Observation 𝒳) → Policy 𝒳 // (∀ sample, est sample ∈ policySet) ∧ ∀ P : ObservedLaw 𝒳, Measurable (fun sample : Fin n → Observation 𝒳 => lawRegret P (est sample))}, ⨆ P : 𝓟, ∫ sample, lawRegret P.1 (est.1 sample) ∂(Measure.pi (fun _ : Fin n => P.1.dataMeasure))
CausalSmith.Stat.PolicyRegretMarginOverlap.minimaxRegret · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:797
structure LawClass

Baseline observed-law class 𝒫_{α,γ}: the bundle of the six member properties at fixed uniform constants.

Definition (Lean source)
α γ Cm u0 Co co underlineP :
policySet :
Set (Policy 𝒳)
P :
Ambient space/probability/marginal/range well-formedness of the observed law on `𝒳 × {0,1} × [-1,1]` (probability measures, `P_X` the marginal, `τ = μ₁-μ₀`, propensity in `[0,1]`); this is the law-space definition, not a 7th modelling assumption.
wf :
bdd :
pos :
margin :
MarginTail P Cm α u0
zero :
ZeroEffectRegular P policySet
overlapDecay :
OverlapDecay P u0 Co co α γ
strict :
StrictOverlapEndpoint P γ underlineP
CausalSmith.Stat.PolicyRegretMarginOverlap.LawClass · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:814

Regime-indexed conditional feasible upper risk U_n(α,γ,a,c; η̂) = sup_P E_P R_P(π̂_n). The estimator is the feasible cross-fit clipped-AIPW ERM feasibleERM run with the SELECTED schedule clip q_n = qSched α γ a c q0 n and the supplied foldwise cross-fitted nuisances η̂ (n-indexed, fold-indexed).

Definition (Lean source)
noncomputable def upperRisk {n K : ℕ} (α γ Cm u0 Co co underlineP a c CMu CProd q0 : ℝ) (dPi : ℕ) (policySet : Set (Policy 𝒳)) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : ℕ → Fin K → 𝒳 → ℝ) (assign : (m : ℕ) → Fin m → Fin K) (rMu rE : ℕ → ℝ) : ℝ := sSup ((fun P : ObservedLaw 𝒳 => ∫ sample, lawRegret P (feasibleERM (qSched α γ a c q0 n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure))) '' {P | LawClass α γ Cm u0 Co co underlineP policySet P ∧ OptimalInClass P policySet ∧ IsIIDSample P ∧ (∀ k : Fin K, NuisanceRate P (fun m => muHat0 m k) (fun m => muHat1 m k) (fun m => eHat m k) rMu rE) ∧ (∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) ∧ PolynomialNuisanceExponents rMu rE a c CMu CProd ∧ PolicyClassVC policySet dPi ∧ VCLocalizedEnvelope P policySet α ∧ VCLocalizedOffsetEnvelope P policySet α ∧ FixedFoldCount K assign ∧ DenseSkeleton enum policySet})
CausalSmith.Stat.PolicyRegretMarginOverlap.upperRisk · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:831
theorem regret_eq_disagreement_integral Theorem 1 in the paper ↗

thm:welfare-identity. Under the well-formed law (τ = μ₁-μ₀) and bounded outcomes, regret equals the |τ|-weighted disagreement mass. hwf is load-bearing: the integral identity needs τ integrable, and BoundedOutcome bounds only μ₀,μ₁ — the contrast field is bounded (τ ∈ [-2,2]) only once WellFormedLaw ties τ = μ₁-μ₀. Both are global standing setup conditions of the observed law.

Formal statement
P :
π :
Policy 𝒳
hwf :
hbdd :
:
lawRegret P π = ∫ x, |P.contrast x| * disagreementIndicator π (lawOptimalPolicy P) x ∂P.PX
Proof (Lean source)
theorem regret_eq_disagreement_integral (P : ObservedLaw 𝒳) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hπ : Measurable π) : lawRegret P π = ∫ x, |P.contrast x| * disagreementIndicator π (lawOptimalPolicy P) x ∂P.PX := by rcases hwf with ⟨_hprobData, _hprobPX, _hmap, hτmeas, _hemeas, _hmu0meas, _hmu1meas, hτeq, _herange, _heSem, _hmu1Sem, _hmu0Sem⟩ have hτ_bound : ∀ x, |P.contrast x| ≤ (2 : ℝ) := by intro x rw [hτeq x] have hmu0 : |P.mu0 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).1.1, (hbdd.2 x).1.2⟩ have hmu1 : |P.mu1 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).2.1, (hbdd.2 x).2.2⟩ calc |P.mu1 x - P.mu0 x| ≤ |P.mu1 x| + |P.mu0 x| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1 hmu0 _ = (2 : ℝ) := by norm_num have hoptSet : MeasurableSet {x : 𝒳 | 0 ≤ P.contrast x} := by exact measurableSet_le measurable_const hτmeas have hπSet : MeasurableSet {x : 𝒳 | π x = true} := by exact hπ (measurableSet_singleton true) have hf_meas : Measurable (fun x => if 0 ≤ P.contrast x then P.contrast x else 0) := Measurable.ite hoptSet hτmeas measurable_const have hg_meas : Measurable (fun x => if π x = true then P.contrast x else 0) := Measurable.ite hπSet hτmeas measurable_const have hf_int : Integrable (fun x => if 0 ≤ P.contrast x then P.contrast x else 0) P.PX := by refine Integrable.of_bound hf_meas.aestronglyMeasurable 2 ?_ filter_upwards with x by_cases hx : 0 ≤ P.contrast x <;> simp [hx, hτ_bound x] have hg_int : Integrable (fun x => if π x = true then P.contrast x else 0) P.PX := by refine Integrable.of_bound hg_meas.aestronglyMeasurable 2 ?_ filter_upwards with x by_cases hx : π x = true <;> simp [hx, hτ_bound x] simp [lawRegret, regret, welfare, lawOptimalPolicy, optimalPolicy, boolIndicator] rw [← integral_sub hf_int hg_int] apply integral_congr_ae filter_upwards with x by_cases hτnon : 0 ≤ P.contrast x · by_cases hπtrue : π x = true · simp [hτnon, hπtrue, abs_of_nonneg hτnon, disagreementIndicator, optimalPolicy] · simp [hτnon, hπtrue, abs_of_nonneg hτnon, disagreementIndicator, optimalPolicy] · have hτneg : P.contrast x < 0 := lt_of_not_ge hτnon by_cases hπtrue : π x = true · simp [hτnon, hπtrue, abs_of_neg hτneg, disagreementIndicator, optimalPolicy] · simp [hτnon, hπtrue, abs_of_neg hτneg, disagreementIndicator, optimalPolicy]
CausalSmith.Stat.PolicyRegretMarginOverlap.regret_eq_disagreement_integral · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:888
theorem measurableSet_disagreementSet

The disagreement set is measurable when the policy and contrast are measurable.

Formal statement
P :
π :
Policy 𝒳
hτmeas :
Measurable P.contrast
:
Proof (Lean source)
lemma measurableSet_disagreementSet (P : ObservedLaw 𝒳) (π : Policy 𝒳) (hτmeas : Measurable P.contrast) (hπ : Measurable π) : MeasurableSet (disagreementSet π (lawOptimalPolicy P)) := by have hπtrue : MeasurableSet {x : 𝒳 | π x = true} := hπ (measurableSet_singleton true) have hπfalse : MeasurableSet {x : 𝒳 | π x = false} := hπ (measurableSet_singleton false) have hopttrue : MeasurableSet {x : 𝒳 | lawOptimalPolicy P x = true} := by have hτnonneg : MeasurableSet {x : 𝒳 | 0 ≤ P.contrast x} := measurableSet_le measurable_const hτmeas simpa [lawOptimalPolicy, optimalPolicy] using hτnonneg have hoptfalse : MeasurableSet {x : 𝒳 | lawOptimalPolicy P x = false} := by simpa [Set.compl_setOf] using hopttrue.compl have hrepr : disagreementSet π (lawOptimalPolicy P) = ({x : 𝒳 | π x = true} ∩ {x | lawOptimalPolicy P x = false}) ∪ ({x : 𝒳 | π x = false} ∩ {x | lawOptimalPolicy P x = true}) := by ext x cases hpi : π x <;> cases hopt : lawOptimalPolicy P x <;> simp [disagreementSet, hpi, hopt] rw [hrepr] exact (hπtrue.inter hoptfalse).union (hπfalse.inter hopttrue)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurableSet_disagreementSet · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:947
theorem regret_disagreement_large_contrast_le

The welfare identity controls disagreement on the region with contrast above u.

Formal statement
P :
π :
Policy 𝒳
hwf :
hbdd :
:
u :
hu :
0 < u
P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | u < |P.contrast x|})
lawRegret P π / u
Proof (Lean source)
lemma regret_disagreement_large_contrast_le (P : ObservedLaw 𝒳) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hπ : Measurable π) {u : ℝ} (hu : 0 < u) : P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | u < |P.contrast x|}) ≤ lawRegret P π / u := by have hreg := regret_eq_disagreement_integral P π hwf hbdd hπ rcases hwf with ⟨_hprobData, hprobPX, _hmap, hτmeas, _hemeas, _hmu0meas, _hmu1meas, hτeq, _herange, _heSem, _hmu1Sem, _hmu0Sem⟩ letI : IsProbabilityMeasure P.PX := hprobPX let D : Set 𝒳 := disagreementSet π (lawOptimalPolicy P) let E : Set 𝒳 := D ∩ {x | u < |P.contrast x|} let f : 𝒳 → ℝ := fun x => |P.contrast x| * disagreementIndicator π (lawOptimalPolicy P) x have hτ_bound : ∀ x, |P.contrast x| ≤ (2 : ℝ) := by intro x rw [hτeq x] have hmu0 : |P.mu0 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).1.1, (hbdd.2 x).1.2⟩ have hmu1 : |P.mu1 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).2.1, (hbdd.2 x).2.2⟩ calc |P.mu1 x - P.mu0 x| ≤ |P.mu1 x| + |P.mu0 x| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1 hmu0 _ = (2 : ℝ) := by norm_num have hDmeas : MeasurableSet D := measurableSet_disagreementSet P π hτmeas hπ have hEmeas : MeasurableSet E := by exact hDmeas.inter (by simpa [Real.norm_eq_abs] using (measurableSet_lt measurable_const hτmeas.norm)) have hf_meas : Measurable f := by have hτabs : Measurable (fun x => |P.contrast x|) := by simpa [Real.norm_eq_abs] using hτmeas.norm dsimp [f] apply hτabs.mul unfold disagreementIndicator exact Measurable.ite hDmeas measurable_const measurable_const have hf_int : Integrable f P.PX := by refine Integrable.of_bound hf_meas.aestronglyMeasurable 2 ?_ filter_upwards with x have hind : |disagreementIndicator π (lawOptimalPolicy P) x| ≤ (1 : ℝ) := by unfold disagreementIndicator split <;> simp calc |f x| = |P.contrast x| * |disagreementIndicator π (lawOptimalPolicy P) x| := by simp [f, abs_mul] _ ≤ 2 * 1 := by gcongr exact hτ_bound x _ = (2 : ℝ) := by norm_num have hf_nonneg : 0 ≤ᵐ[P.PX] f := by filter_upwards with x have hind : 0 ≤ disagreementIndicator π (lawOptimalPolicy P) x := by unfold disagreementIndicator split <;> norm_num exact mul_nonneg (abs_nonneg _) hind have hf_ge_u : ∀ x ∈ E, u ≤ f x := by intro x hx rcases hx with ⟨hxD, hxlarge⟩ have hxD' : π x ≠ lawOptimalPolicy P x := by simpa [D, disagreementSet] using hxD have hind : disagreementIndicator π (lawOptimalPolicy P) x = 1 := by simp [disagreementIndicator, hxD'] calc u ≤ |P.contrast x| := le_of_lt hxlarge _ = f x := by simp [f, hind] have hfiniteE : P.PX E ≠ ⊤ := measure_ne_top P.PX E have hset_ge : u * P.PX.real E ≤ ∫ x in E, f x ∂P.PX := setIntegral_ge_of_const_le_real hEmeas hfiniteE hf_ge_u hf_int.integrableOn have hset_le : ∫ x in E, f x ∂P.PX ≤ ∫ x, f x ∂P.PX := setIntegral_le_integral hf_int hf_nonneg have hmul_le : u * P.PX.real E ≤ lawRegret P π := by rw [hreg] exact hset_ge.trans hset_le rw [show disagreementSet π (lawOptimalPolicy P) ∩ {x | u < |P.contrast x|} = E by rfl] rw [le_div_iff₀ hu] simpa [mul_comm] using hmul_le
CausalSmith.Stat.PolicyRegretMarginOverlap.regret_disagreement_large_contrast_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:971
theorem disagreement_measure_le_margin_plus_regret_over_u

The margin/large-contrast decomposition used in thm:margin-localization: up to the zero-effect null part, D_π ⊆ {0<|τ|≤u} ∪ (D_π ∩ {|τ|>u}), hence P_X(D_π) ≤ C_m u^α + R_P(π)/u.

Formal statement
P :
policySet :
Set (Policy 𝒳)
Cm α u0 :
hmargin :
MarginTail P Cm α u0
hze :
ZeroEffectRegular P policySet
hwf :
hbdd :
hπmeas :
∀ π ∈ policySet, Measurable π
π :
Policy 𝒳
hπmem :
π ∈ policySet
u :
hu :
0 < u
hu_le :
u ≤ u0
P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ Cm * u ^ α + lawRegret P π / u
Proof (Lean source)
lemma disagreement_measure_le_margin_plus_regret_over_u (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (Cm α u0 : ℝ) (hmargin : MarginTail P Cm α u0) (hze : ZeroEffectRegular P policySet) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hπmeas : ∀ π ∈ policySet, Measurable π) (π : Policy 𝒳) (hπmem : π ∈ policySet) {u : ℝ} (hu : 0 < u) (hu_le : u ≤ u0) : P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ Cm * u ^ α + lawRegret P π / u := by letI : IsProbabilityMeasure P.PX := hwf.2.1 let D : Set 𝒳 := disagreementSet π (lawOptimalPolicy P) let ZD : Set 𝒳 := {x | P.contrast x = 0 ∧ π x ≠ lawOptimalPolicy P x} let S : Set 𝒳 := {x | 0 < |P.contrast x| ∧ |P.contrast x| ≤ u} let B : Set 𝒳 := D ∩ {x | u < |P.contrast x|} have hZD_zero : P.PX.real ZD = 0 := by rcases hze with hzero | hzeroD · have hle : P.PX.real ZD ≤ P.PX.real {x | P.contrast x = 0} := by exact measureReal_mono (μ := P.PX) (by intro x hx exact hx.1) (measure_ne_top P.PX {x | P.contrast x = 0}) have hle0 : P.PX.real ZD ≤ 0 := by simpa [hzero] using hle exact le_antisymm hle0 measureReal_nonneg · simpa [ZD] using hzeroD π hπmem have hsmall : P.PX.real S ≤ Cm * u ^ α := by exact hmargin.2.2.2 u hu hu_le have hbig : P.PX.real B ≤ lawRegret P π / u := by simpa [B, D] using regret_disagreement_large_contrast_le P π hwf hbdd (hπmeas π hπmem) hu have hsubset : D ⊆ ZD ∪ S ∪ B := by intro x hxD by_cases hτzero : P.contrast x = 0 · left left exact ⟨hτzero, by simpa [D, disagreementSet] using hxD⟩ · by_cases hsmallContrast : |P.contrast x| ≤ u · left right exact ⟨abs_pos.mpr hτzero, hsmallContrast⟩ · right exact ⟨hxD, lt_of_not_ge hsmallContrast⟩ calc P.PX.real (disagreementSet π (lawOptimalPolicy P)) = P.PX.real D := rfl _ ≤ P.PX.real (ZD ∪ S ∪ B) := measureReal_mono (μ := P.PX) hsubset (measure_ne_top P.PX (ZD ∪ S ∪ B)) _ ≤ P.PX.real (ZD ∪ S) + P.PX.real B := measureReal_union_le _ _ _ ≤ (P.PX.real ZD + P.PX.real S) + P.PX.real B := by have h := measureReal_union_le (μ := P.PX) ZD S linarith _ = P.PX.real S + P.PX.real B := by rw [hZD_zero] ring _ ≤ Cm * u ^ α + lawRegret P π / u := add_le_add hsmall hbig
CausalSmith.Stat.PolicyRegretMarginOverlap.disagreement_measure_le_margin_plus_regret_over_u · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:1053
theorem margin_localization Theorem 2 in the paper ↗

thm:margin-localization. Under the margin and zero-effect conditions, disagreement mass is controlled by regret at the fast exponent α/(1+α): P_X(D_π) ≤ C R_P(π)^{α/(1+α)} for every π ∈ policySet.

Formal statement
Cm α u0 :
∃ C : ℝ
if
0 < C ∧ ∀ (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)), MarginTail P Cm α u0
and
ZeroEffectRegular P policySet
and
(∀ π ∈ policySet, Measurable π)
then
∀ π ∈ policySet,
P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ C * (lawRegret P π) ^ (α / (1 + α))
Proof (Lean source)
theorem margin_localization (Cm α u0 : ℝ) : -- UNIFORM constant `C = C(C_m,u_0,α)`: the `∃ C` is hoisted ABOVE `∀ P` so the -- constant depends only on the margin parameters, not on the specific law (the -- `.tex` states "there is C=C(C_m,u_0,α) such that for every π …"); a per-law -- `∃ C(P)` inside `∀ P` would be a strictly weaker claim. ∃ C : ℝ, 0 < C ∧ ∀ (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)), MarginTail P Cm α u0 → ZeroEffectRegular P policySet → WellFormedLaw P → BoundedOutcome P → (∀ π ∈ policySet, Measurable π) → ∀ π ∈ policySet, P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ C * (lawRegret P π) ^ (α / (1 + α)) := by classical let C : ℝ := |Cm| + 2 + if 0 < u0 then u0 ^ (-α) else 0 refine ⟨C, ?_, ?_⟩ · have htail_nonneg : 0 ≤ (if 0 < u0 then u0 ^ (-α) else 0) := by split_ifs with hu0 · exact Real.rpow_nonneg hu0.le _ · norm_num have hCmabs : 0 ≤ |Cm| := abs_nonneg Cm dsimp [C] nlinarith · intro P policySet hmargin hze hwf hbdd hπmeas π hπmem rcases hmargin with ⟨hαnonneg, hCmpos, hu0pos, _hmarginTail⟩ letI : IsProbabilityMeasure P.PX := hwf.2.1 let r : ℝ := lawRegret P π have hC_eq : C = |Cm| + 2 + u0 ^ (-α) := by simp [C, hu0pos] have hCge_small : Cm + 1 ≤ C := by rw [hC_eq, abs_of_pos hCmpos] have hpow_nonneg : 0 ≤ u0 ^ (-α) := Real.rpow_nonneg hu0pos.le _ nlinarith have hCge_large : u0 ^ (-α) ≤ C := by rw [hC_eq] have hCmabs : 0 ≤ |Cm| := abs_nonneg Cm nlinarith have hreg_eq := regret_eq_disagreement_integral P π hwf hbdd (hπmeas π hπmem) have hr_nonneg : 0 ≤ r := by dsimp [r] rw [hreg_eq] exact integral_nonneg (fun x => mul_nonneg (abs_nonneg _) (by unfold disagreementIndicator split <;> norm_num)) have hprobD : P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ 1 := measureReal_le_one by_cases hαzero : α = 0 · have hCge_one : 1 ≤ C := by rw [hC_eq, hαzero, abs_of_pos hCmpos] have hpow : u0 ^ (-(0 : ℝ)) = 1 := by simp rw [hpow] nlinarith calc P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ 1 := hprobD _ ≤ C * (lawRegret P π) ^ (α / (1 + α)) := by simpa [hαzero] using hCge_one · have hαpos : 0 < α := lt_of_le_of_ne hαnonneg (Ne.symm hαzero) by_cases hrpos : 0 < r · let u : ℝ := r ^ (1 / (1 + α)) have hu_pos : 0 < u := Real.rpow_pos_of_pos hrpos _ by_cases hu_le : u ≤ u0 · have hdecomp : P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ Cm * u ^ α + lawRegret P π / u := disagreement_measure_le_margin_plus_regret_over_u P policySet Cm α u0 ⟨hαnonneg, hCmpos, hu0pos, _hmarginTail⟩ hze hwf hbdd hπmeas π hπmem hu_pos hu_le have hupow : u ^ α = r ^ (α / (1 + α)) := by dsimp [u] rw [← Real.rpow_mul (le_of_lt hrpos)] congr 1 ring have hdiv : lawRegret P π / u = r ^ (α / (1 + α)) := by dsimp [r, u] calc lawRegret P π / (lawRegret P π) ^ (1 / (1 + α)) = r / r ^ (1 / (1 + α)) := rfl _ = r ^ (α / (1 + α)) := by have hden : 1 + α ≠ 0 := by positivity calc r / r ^ (1 / (1 + α)) = r ^ (1 : ℝ) / r ^ (1 / (1 + α)) := by rw [Real.rpow_one] _ = r ^ ((1 : ℝ) - 1 / (1 + α)) := by rw [Real.rpow_sub hrpos] _ = r ^ (α / (1 + α)) := by congr 1 field_simp [hden] ring have hmain : P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ (Cm + 1) * r ^ (α / (1 + α)) := by calc P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ Cm * u ^ α + lawRegret P π / u := hdecomp _ = Cm * r ^ (α / (1 + α)) + r ^ (α / (1 + α)) := by rw [hupow, hdiv] _ = (Cm + 1) * r ^ (α / (1 + α)) := by ring have hpow_nonneg : 0 ≤ r ^ (α / (1 + α)) := Real.rpow_nonneg hrpos.le _ exact hmain.trans (mul_le_mul_of_nonneg_right hCge_small hpow_nonneg) · have hu0_lt : u0 < u := lt_of_not_ge hu_le have hpows : u0 ^ α ≤ r ^ (α / (1 + α)) := by calc u0 ^ α ≤ u ^ α := by exact Real.rpow_le_rpow hu0pos.le (le_of_lt hu0_lt) hαpos.le _ = r ^ (α / (1 + α)) := by dsimp [u] rw [← Real.rpow_mul (le_of_lt hrpos)] congr 1 ring have hone_le : 1 ≤ C * r ^ (α / (1 + α)) := by have hcoef_pos : 0 < u0 ^ (-α) := Real.rpow_pos_of_pos hu0pos _ have hbase_nonneg : 0 ≤ r ^ (α / (1 + α)) := Real.rpow_nonneg hrpos.le _ have hone : (u0 ^ (-α)) * (u0 ^ α) = 1 := by rw [← Real.rpow_add hu0pos] ring_nf simp calc 1 = (u0 ^ (-α)) * (u0 ^ α) := hone.symm _ ≤ (u0 ^ (-α)) * r ^ (α / (1 + α)) := mul_le_mul_of_nonneg_left hpows hcoef_pos.le _ ≤ C * r ^ (α / (1 + α)) := mul_le_mul_of_nonneg_right hCge_large hbase_nonneg exact hprobD.trans hone_le · have hr_eq : r = 0 := le_antisymm (le_of_not_gt hrpos) hr_nonneg have hD_le_zero : P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ 0 := by refine le_of_forall_pos_le_add ?_ intro ε hε let a : ℝ := ε / (Cm + 1) have hdenpos : 0 < Cm + 1 := by linarith have ha_pos : 0 < a := div_pos hε hdenpos let u : ℝ := min u0 (a ^ (1 / α)) have hu_pos : 0 < u := by dsimp [u] exact lt_min hu0pos (Real.rpow_pos_of_pos ha_pos _) have hu_le : u ≤ u0 := by dsimp [u] exact min_le_left _ _ have hu_le_a : u ≤ a ^ (1 / α) := by dsimp [u] exact min_le_right _ _ have hdecomp : P.PX.real (disagreementSet π (lawOptimalPolicy P)) ≤ Cm * u ^ α + lawRegret P π / u := disagreement_measure_le_margin_plus_regret_over_u P policySet Cm α u0 ⟨hαnonneg, hCmpos, hu0pos, _hmarginTail⟩ hze hwf hbdd hπmeas π hπmem hu_pos hu_le have hupow_le : u ^ α ≤ a := by have hpow_le : u ^ α ≤ (a ^ (1 / α)) ^ α := Real.rpow_le_rpow hu_pos.le hu_le_a hαpos.le have ha_pow : (a ^ (1 / α)) ^ α = a := by rw [← Real.rpow_mul ha_pos.le (1 / α) α] have hmul : (1 / α) * α = (1 : ℝ) := by field_simp [hαpos.ne'] rw [hmul, Real.rpow_one] exact hpow_le.trans_eq ha_pow have hCm_u_le : Cm * u ^ α ≤ Cm * a := mul_le_mul_of_nonneg_left hupow_le hCmpos.le have hCm_a_le : Cm * a ≤ ε := by dsimp [a] field_simp [hdenpos.ne'] nlinarith have hdiv_zero : lawRegret P π / u = 0 := by dsimp [r] at hr_eq rw [hr_eq] simp have hle_eps : Cm * u ^ α + lawRegret P π / u ≤ ε := by rw [hdiv_zero] linarith linarith have hD_zero : P.PX.real (disagreementSet π (lawOptimalPolicy P)) = 0 := le_antisymm hD_le_zero measureReal_nonneg have hpow_zero : (lawRegret P π) ^ (α / (1 + α)) = 0 := by have h_exp_ne : α / (1 + α) ≠ 0 := by have hden : 1 + α ≠ 0 := by positivity exact div_ne_zero hαpos.ne' hden dsimp [r] at hr_eq rw [hr_eq] exact Real.zero_rpow h_exp_ne rw [hD_zero, hpow_zero] simp
CausalSmith.Stat.PolicyRegretMarginOverlap.margin_localization · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:1112
theorem overlap_envelope Proposition 1 in the paper ↗

prop:overlap-envelope. At the tight window v=h^β, u=h^{β/γ}, the envelope value equals h^{(α+1)β/γ}, admissibility ≥ h^α is equivalent to β ≤ αγ/(α+1)=β_{α,γ}, with equality at β=β_{α,γ}. Hence (final conjunct) a block of mass ~h^α with weak-arm exponent β' meets the ass:overlap-decay envelope iff β' ≤ β_{α,γ}, so β_{α,γ} ≥ 0 is the LEAST INFORMATIVE (largest) admissible weak-arm exponent.

Formal statement
α γ h β :
:
0 ≤ α
:
0 < γ
hh0 :
0 < h
hh1 :
h < 1
_hβ :
0 ≤ β
(h ^ (β / γ)) ^ α * (h ^ β) ^ (1 / γ) = h ^ ((α + 1) * β / γ) ∧
((h ^ (β / γ)) ^ α * (h ^ β) ^ (1 / γ) ≥ h ^ α ↔ β ≤ betaAG α γ) ∧
(β = betaAG α γ → (h ^ (β / γ)) ^ α * (h ^ β) ^ (1 / γ) = h ^ α) ∧
(0 ≤ betaAG α γ ∧ ∀ β' : ℝ, 0 ≤ β' → ((h ^ (β' / γ)) ^ α * (h ^ β') ^ (1 / γ) ≥ h ^ α ↔ β' ≤ betaAG α γ))
Proof (Lean source)
lemma overlap_envelope (α γ h β : ℝ) (hα : 0 ≤ α) (hγ : 0 < γ) (hh0 : 0 < h) (hh1 : h < 1) (_hβ : 0 ≤ β) : (h ^ (β / γ)) ^ α * (h ^ β) ^ (1 / γ) = h ^ ((α + 1) * β / γ) ∧ ((h ^ (β / γ)) ^ α * (h ^ β) ^ (1 / γ) ≥ h ^ α ↔ β ≤ betaAG α γ) ∧ (β = betaAG α γ → (h ^ (β / γ)) ^ α * (h ^ β) ^ (1 / γ) = h ^ α) ∧ (0 ≤ betaAG α γ ∧ ∀ β' : ℝ, 0 ≤ β' → ((h ^ (β' / γ)) ^ α * (h ^ β') ^ (1 / γ) ≥ h ^ α ↔ β' ≤ betaAG α γ)) := by have hpow : ∀ b : ℝ, (h ^ (b / γ)) ^ α * (h ^ b) ^ (1 / γ) = h ^ ((α + 1) * b / γ) := by intro b rw [← Real.rpow_mul (le_of_lt hh0), ← Real.rpow_mul (le_of_lt hh0)] rw [← Real.rpow_add hh0] congr 1 field_simp [ne_of_gt hγ] have halg : ∀ b : ℝ, (h ^ ((α + 1) * b / γ) ≥ h ^ α ↔ b ≤ betaAG α γ) := by intro b rw [ge_iff_le] rw [Real.rpow_le_rpow_left_iff_of_base_lt_one hh0 hh1] simp [betaAG, ne_of_gt hγ] have hα1 : 0 < α + 1 := by linarith constructor · intro hle calc b = ((α + 1) * b / γ) * γ / (α + 1) := by field_simp [ne_of_gt hγ, ne_of_gt hα1] _ ≤ α * γ / (α + 1) := by gcongr · intro hle calc ((α + 1) * b / γ) ≤ ((α + 1) * (α * γ / (α + 1)) / γ) := by gcongr _ = α := by field_simp [ne_of_gt hγ, ne_of_gt hα1] refine ⟨hpow β, ?_, ?_, ?_⟩ · rw [hpow β] exact halg β · intro hb rw [hpow β, hb] have hα1 : 0 < α + 1 := by linarith have hcalc : ((α + 1) * (α * γ / (α + 1)) / γ) = α := by field_simp [ne_of_gt hγ, ne_of_gt hα1] simp [betaAG, ne_of_gt hγ, hcalc] · constructor · simp [betaAG, ne_of_gt hγ] positivity · intro β' hβ' rw [hpow β'] exact halg β'
CausalSmith.Stat.PolicyRegretMarginOverlap.overlap_envelope · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:1317
theorem integrable_of_measurable_bounded

A measurable real function that is bounded in absolute value by a single constant is integrable against any finite measure.

Formal statement
α :
f :
α → ℝ
hfmeas :
hfbdd :
∃ M : ℝ, ∀ x, |f x| ≤ M
Proof (Lean source)
lemma integrable_of_measurable_bounded {α : Type*} [MeasurableSpace α] {μ : Measure α} [IsFiniteMeasure μ] {f : α → ℝ} (hfmeas : Measurable f) (hfbdd : ∃ M : ℝ, ∀ x, |f x| ≤ M) : Integrable f μ := by rcases hfbdd with ⟨M, hM⟩ refine MeasureTheory.Integrable.of_bound hfmeas.aestronglyMeasurable (max M 0) ?_ exact Filter.Eventually.of_forall (fun x => by simpa [Real.norm_eq_abs] using le_trans (hM x) (le_max_left M 0))
CausalSmith.Stat.PolicyRegretMarginOverlap.integrable_of_measurable_bounded · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Basic.lean:1377
Helpers.BochnerIntegrability 4 declarations This file discharges the hBochner regularity hypothesis previously assumed on feasible_upper / crude_localized_master_bound: eventually in n, for every law in the class, the selected regret loss and the localized/offset

Discharging the Bochner integrability side conditions (bochner_integrability_gate)

This file discharges the hBochner regularity hypothesis previously assumed on feasible_upper / crude_localized_master_bound: eventually in n, for every law in the class, the selected regret loss and the localized/offset empirical-process suprema over the policy class are measurable, BddAbove, and integrable against the n-fold product data measure.

The measurability of the supremum over the (uncountable) policy class is obtained by reducing it to the countable pointwise-dense skeleton Π₀ carried by PolicyClassVC, using the paper-agnostic machinery Causalean.Mathlib.MeasureTheory.integrable_sSup_image_of_countable_dense. The reduction requires sequential continuity of the process in the policy argument along skeleton sequences, which is the dominated-convergence content proved here (lawRegret_tendsto_of_skeleton, pooledCrossfitProcess_tendsto_of_skeleton, foldSubCentered_tendsto_of_skeleton).

theorem lawRegret_tendsto_of_skeleton

Welfare-regret continuity along a pointwise-convergent skeleton sequence: if seq j x = π x eventually for every x, then lawRegret P (seq j) → lawRegret P π. (welfare = ∫ boolIndicator(π x)·τ x dP_X converges by dominated convergence with dominating function |τ| ≤ 2.)

Formal statement
P :
hwf :
hbdd :
π :
Policy 𝒳
seq :
ℕ → Policy 𝒳
hπmeas :
hseqmeas :
∀ j, Measurable (seq j)
hseq :
∀ x, ∀ᶠ j in atTop, seq j x = π x
Tendsto (fun j => lawRegret P (seq j)) atTop (nhds (lawRegret P π))
Proof (Lean source)
lemma lawRegret_tendsto_of_skeleton (P : ObservedLaw 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (π : Policy 𝒳) (seq : ℕ → Policy 𝒳) (hπmeas : Measurable π) (hseqmeas : ∀ j, Measurable (seq j)) (hseq : ∀ x, ∀ᶠ j in atTop, seq j x = π x) : Tendsto (fun j => lawRegret P (seq j)) atTop (nhds (lawRegret P π)) := by rcases hwf with ⟨_hPprob, hPXprob, _hmap, hτmeas, _hpropmeas, _hmu0meas, _hmu1meas, hτeq, _hprop, _hceA, _hceY1, _hceY0⟩ letI : IsProbabilityMeasure P.PX := hPXprob have hτbound : ∀ x, |P.contrast x| ≤ (2 : ℝ) := by intro x have hmu0 : |P.mu0 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).1.1, (hbdd.2 x).1.2⟩ have hmu1 : |P.mu1 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).2.1, (hbdd.2 x).2.2⟩ calc |P.contrast x| = |P.mu1 x - P.mu0 x| := by rw [hτeq] _ ≤ |P.mu1 x| + |P.mu0 x| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1 hmu0 _ = (2 : ℝ) := by norm_num have hwelfare : Tendsto (fun j => ∫ x, boolIndicator (seq j x) * P.contrast x ∂P.PX) atTop (nhds (∫ x, boolIndicator (π x) * P.contrast x ∂P.PX)) := by refine MeasureTheory.tendsto_integral_of_dominated_convergence (fun _ => (2 : ℝ)) ?_ (MeasureTheory.integrable_const 2) ?_ ?_ · intro j exact (((measurable_of_finite boolIndicator).comp (hseqmeas j)).mul hτmeas).aestronglyMeasurable · intro j exact Filter.Eventually.of_forall fun x => by rw [Real.norm_eq_abs, abs_mul] have hb : |boolIndicator (seq j x)| ≤ (1 : ℝ) := by cases seq j x <;> simp [boolIndicator] nlinarith [mul_le_mul hb (hτbound x) (abs_nonneg (P.contrast x)) (by norm_num : (0 : ℝ) ≤ 1)] · exact Filter.Eventually.of_forall fun x => by have heq : (fun j => boolIndicator (seq j x) * P.contrast x) =ᶠ[atTop] (fun _ => boolIndicator (π x) * P.contrast x) := by filter_upwards [hseq x] with j hj rw [hj] exact Filter.Tendsto.congr' heq.symm tendsto_const_nhds simpa only [lawRegret, regret, welfare] using hwelfare.const_sub (welfare P.PX P.contrast (optimalPolicy P.contrast))
CausalSmith.Stat.PolicyRegretMarginOverlap.lawRegret_tendsto_of_skeleton · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/BochnerIntegrability.lean:72
theorem pooledCrossfitProcess_tendsto_of_skeleton

Pooled cross-fit process continuity along a pointwise-convergent skeleton sequence, for a uniformly bounded, policy-compatible, measurable increment g. The finite-sample average n⁻¹ ∑ᵢ g(assign i)(seq j)(sample i) is eventually exactly equal to its π-value (each of the finitely many evaluation points stabilizes), and each centering integral ∫ g(assign i)(seq j) dP converges by dominated convergence (dominating constant B).

Formal statement
n K :
P :
IsProbabilityMeasure P.dataMeasure
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
B :
hB :
0 ≤ B
hbound :
∀ (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳), |g k π O| ≤ B
hcompat :
∀ k : Fin K, PolicyCompatible (g k)
hmeas :
∀ (k : Fin K) (ρ : Policy 𝒳)
then
Measurable (g k ρ)
assign :
Fin n → Fin K
sample :
Fin n → Observation 𝒳
π :
Policy 𝒳
seq :
ℕ → Policy 𝒳
hseqmeas :
∀ j, Measurable (seq j)
hseq :
∀ x, ∀ᶠ j in atTop, seq j x = π x
Tendsto (fun j => pooledCrossfitProcess P g assign sample (seq j)) atTop (nhds (pooledCrossfitProcess P g assign sample π))
Proof (Lean source)
lemma pooledCrossfitProcess_tendsto_of_skeleton {n K : ℕ} (P : ObservedLaw 𝒳) [IsProbabilityMeasure P.dataMeasure] (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (B : ℝ) (hB : 0 ≤ B) (hbound : ∀ (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳), |g k π O| ≤ B) (hcompat : ∀ k : Fin K, PolicyCompatible (g k)) (hmeas : ∀ (k : Fin K) (ρ : Policy 𝒳), Measurable ρ → Measurable (g k ρ)) (assign : Fin n → Fin K) (sample : Fin n → Observation 𝒳) (π : Policy 𝒳) (seq : ℕ → Policy 𝒳) (hseqmeas : ∀ j, Measurable (seq j)) (hseq : ∀ x, ∀ᶠ j in atTop, seq j x = π x) : Tendsto (fun j => pooledCrossfitProcess P g assign sample (seq j)) atTop (nhds (pooledCrossfitProcess P g assign sample π)) := by have hsum : Tendsto (fun j => ∑ i : Fin n, (g (assign i) (seq j) (sample i) - ∫ O, g (assign i) (seq j) O ∂P.dataMeasure)) atTop (nhds (∑ i : Fin n, (g (assign i) π (sample i) - ∫ O, g (assign i) π O ∂P.dataMeasure))) := by apply tendsto_finset_sum intro i _hi have heval : Tendsto (fun j => g (assign i) (seq j) (sample i)) atTop (nhds (g (assign i) π (sample i))) := by rcases hcompat (assign i) with ⟨G, hG⟩ have heq : (fun j => g (assign i) (seq j) (sample i)) =ᶠ[atTop] (fun _ => g (assign i) π (sample i)) := by filter_upwards [hseq (sample i).X] with j hj rw [hG (seq j) (sample i), hG π (sample i), hj] exact Filter.Tendsto.congr' heq.symm tendsto_const_nhds have hcenter := centeringIntegral_tendsto_of_skeleton P (g (assign i)) B (hbound (assign i)) (hmeas (assign i)) (hcompat (assign i)) π seq hseqmeas hseq exact heval.sub hcenter simpa only [pooledCrossfitProcess] using hsum.const_mul ((n : ℝ)⁻¹)
CausalSmith.Stat.PolicyRegretMarginOverlap.pooledCrossfitProcess_tendsto_of_skeleton · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/BochnerIntegrability.lean:124
theorem foldSubCentered_tendsto_of_skeleton

Fold-subsample centered process continuity along a pointwise-convergent skeleton sequence (same dominated-convergence content as pooledCrossfitProcess_tendsto_of_skeleton, specialized to a single fold's subsample average). This is the building block for the foldOffsetSubSup integrability conjunct.

Formal statement
n K :
P :
IsProbabilityMeasure P.dataMeasure
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
B :
hB :
0 ≤ B
hbound :
∀ (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳), |g k π O| ≤ B
hcompat :
∀ k : Fin K, PolicyCompatible (g k)
hmeas :
∀ (k : Fin K) (ρ : Policy 𝒳)
then
Measurable (g k ρ)
assign :
Fin n → Fin K
k :
Fin K
sample :
foldIndex assign k → Observation 𝒳
π :
Policy 𝒳
seq :
ℕ → Policy 𝒳
hseqmeas :
∀ j, Measurable (seq j)
hseq :
∀ x, ∀ᶠ j in atTop, seq j x = π x
Tendsto (fun j => ((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k (seq j) (sample i) - ∫ O, g k (seq j) O ∂P.dataMeasure)) atTop (nhds (((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)))
Proof (Lean source)
lemma foldSubCentered_tendsto_of_skeleton {n K : ℕ} (P : ObservedLaw 𝒳) [IsProbabilityMeasure P.dataMeasure] (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (B : ℝ) (hB : 0 ≤ B) (hbound : ∀ (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳), |g k π O| ≤ B) (hcompat : ∀ k : Fin K, PolicyCompatible (g k)) (hmeas : ∀ (k : Fin K) (ρ : Policy 𝒳), Measurable ρ → Measurable (g k ρ)) (assign : Fin n → Fin K) (k : Fin K) (sample : foldIndex assign k → Observation 𝒳) (π : Policy 𝒳) (seq : ℕ → Policy 𝒳) (hseqmeas : ∀ j, Measurable (seq j)) (hseq : ∀ x, ∀ᶠ j in atTop, seq j x = π x) : Tendsto (fun j => ((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k (seq j) (sample i) - ∫ O, g k (seq j) O ∂P.dataMeasure)) atTop (nhds (((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure))) := by have hsum : Tendsto (fun j => ∑ i : foldIndex assign k, (g k (seq j) (sample i) - ∫ O, g k (seq j) O ∂P.dataMeasure)) atTop (nhds (∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure))) := by apply tendsto_finset_sum intro i _hi have heval : Tendsto (fun j => g k (seq j) (sample i)) atTop (nhds (g k π (sample i))) := by rcases hcompat k with ⟨G, hG⟩ have heq : (fun j => g k (seq j) (sample i)) =ᶠ[atTop] (fun _ => g k π (sample i)) := by filter_upwards [hseq (sample i).X] with j hj rw [hG (seq j) (sample i), hG π (sample i), hj] exact Filter.Tendsto.congr' heq.symm tendsto_const_nhds have hcenter := centeringIntegral_tendsto_of_skeleton P (g k) B (hbound k) (hmeas k) (hcompat k) π seq hseqmeas hseq exact heval.sub hcenter exact hsum.const_mul ((card (foldIndex assign k) : ℝ)⁻¹)
CausalSmith.Stat.PolicyRegretMarginOverlap.foldSubCentered_tendsto_of_skeleton · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/BochnerIntegrability.lean:166
theorem bochner_discharge

Discharges the four Bochner integrability/BddAbove side conditions (hBochner) of the feasible achievability bound: eventually in n, for every law in the class, the selected regret loss is integrable, and the pooled/fold localized offset-process suprema over the policy class are integrable, BddAbove, and (per fold) integrable.

Formal statement
K :
α γ Cm u0 Co co underlineP :
policySet :
Set (Policy 𝒳)
dPi :
enum :
ℕ → Policy 𝒳
muHat0 muHat1 eHat :
ℕ → Fin K → 𝒳 → ℝ
assign :
(m : ℕ) → Fin m → Fin K
qSeq :
ℕ → ℝ
hvc :
PolicyClassVC policySet dPi
hskel :
DenseSkeleton enum policySet
hbn :
∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)
hμ0meas :
∀ n k, Measurable (muHat0 n k)
hμ1meas :
∀ n k, Measurable (muHat1 n k)
hemeas :
∀ n k, Measurable (eHat n k)
hq_pos :
∀ᶠ n : ℕ in atTop, 0 < qSeq n
hq_half :
∀ᶠ n : ℕ in atTop, qSeq n ≤ 1 / 2
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → let g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrement P (qSeq n) (muHat0 n) (muHat1 n) (eHat n) Integrable (fun sample : Fin n → Observation 𝒳 => lawRegret P (feasibleERM (qSeq n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) ∧
Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) ∧
(∀ sample : Fin n → Observation 𝒳, BddAbove ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet)) ∧
(∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P g (assign n) policySet k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure)))
Proof (Lean source)
lemma bochner_discharge {K : ℕ} (α γ Cm u0 Co co underlineP : ℝ) (policySet : Set (Policy 𝒳)) (dPi : ℕ) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : ℕ → Fin K → 𝒳 → ℝ) (assign : (m : ℕ) → Fin m → Fin K) (qSeq : ℕ → ℝ) (hvc : PolicyClassVC policySet dPi) (hskel : DenseSkeleton enum policySet) (hbn : ∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) (hμ0meas : ∀ n k, Measurable (muHat0 n k)) (hμ1meas : ∀ n k, Measurable (muHat1 n k)) (hemeas : ∀ n k, Measurable (eHat n k)) (hq_pos : ∀ᶠ n : ℕ in atTop, 0 < qSeq n) (hq_half : ∀ᶠ n : ℕ in atTop, qSeq n ≤ 1 / 2) : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → let g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrement P (qSeq n) (muHat0 n) (muHat1 n) (eHat n) Integrable (fun sample : Fin n → Observation 𝒳 => lawRegret P (feasibleERM (qSeq n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) ∧ Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) ∧ (∀ sample : Fin n → Observation 𝒳, BddAbove ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet)) ∧ (∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P g (assign n) policySet k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure))) := by classical filter_upwards [hq_pos, hq_half, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hqpos hqhalf hn intro P hLaw letI : IsProbabilityMeasure P.dataMeasure := hLaw.wf.1 intro g let q : ℝ := qSeq n let B : ℝ := (36 : ℝ) / q let gT : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrementTrunc P q B (muHat0 n) (muHat1 n) (eHat n) have hqn : 0 < q := by simpa [q] using hqpos have hq1 : q ≤ 1 / 2 := by simpa [q] using hqhalf have hB : 0 ≤ B := by dsimp [B]; positivity have hbn' : ∀ k x, (muHat0 n) k x ∈ Icc (-1 : ℝ) 1 ∧ (muHat1 n) k x ∈ Icc (-1 : ℝ) 1 := fun k x => hbn k n x have hgTmeas : ∀ k (ρ : Policy 𝒳), Measurable ρ → Measurable (gT k ρ) := by intro k ρ hρ exact clippedPolicyIncrementTrunc_measurable P q B (muHat0 n) (muHat1 n) (eHat n) k ρ hLaw.wf hρ (hμ0meas n k) (hμ1meas n k) (hemeas n k) have hgTbound : ∀ k π O, |gT k π O| ≤ B := by intro k π O exact clippedPolicyIncrementTrunc_bound P q B (muHat0 n) (muHat1 n) (eHat n) k π O hB obtain ⟨Pi0, hPi0count, hPi0sub, hPi0dense⟩ := hvc.2.1 have hpoolbound : ∀ sample π, |pooledCrossfitProcess P gT (assign n) sample π| ≤ 2 * B := by intro sample π simpa [pooledCrossfitProcess] using (abs_centered_average_le P (fun i O => gT (assign n i) π O) sample B hB (fun i O => hgTbound (assign n i) π O)) have hfoldbound : ∀ (k : Fin K) (sample : foldIndex (assign n) k → Observation 𝒳) (π : Policy 𝒳), |((card (foldIndex (assign n) k) : ℝ)⁻¹) * ∑ i, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure)| ≤ 2 * B := by intro k sample π exact abs_centered_average_le P (fun _ O => gT k π O) sample B hB (fun _ O => hgTbound k π O) have hregnonneg : ∀ π ∈ policySet, 0 ≤ lawRegret P π := by intro π hπ exact lawRegret_nonneg P π hLaw.wf hLaw.bdd (hvc.1 π hπ) have hoffbound : ∀ (sample : Fin n → Observation 𝒳), ∀ π ∈ policySet, |max 0 (2 * |pooledCrossfitProcess P gT (assign n) sample π| - lawRegret P π / 4)| ≤ 4 * B + 1 := by intro sample π hπ rw [abs_of_nonneg (le_max_left _ _)] apply max_le · nlinarith [hB] · nlinarith [hpoolbound sample π, hregnonneg π hπ] have hfoldoffbound : ∀ (k : Fin K) (sample : foldIndex (assign n) k → Observation 𝒳), ∀ π ∈ policySet, |max 0 (2 * |((card (foldIndex (assign n) k) : ℝ)⁻¹) * ∑ i, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure)| - lawRegret P π / 4)| ≤ 4 * B + 1 := by intro k sample π hπ rw [abs_of_nonneg (le_max_left _ _)] apply max_le · nlinarith [hB] · nlinarith [hfoldbound k sample π, hregnonneg π hπ] have hIntRegret : Integrable (fun sample : Fin n → Observation 𝒳 => lawRegret P (feasibleERM q enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) := by refine Integrable.of_bound (measurable_feasible_regret P q enum (muHat0 n) (muHat1 n) (eHat n) (assign n) policySet dPi hvc hskel.1 (hμ0meas n) (hμ1meas n) (hemeas n) (Nat.pos_of_ne_zero (by omega))).aestronglyMeasurable 4 ?_ filter_upwards with sample have hmem := hskel.1 (sInf {j : ℕ | ∀ j', empiricalWelfareScore q (muHat0 n) (muHat1 n) (eHat n) (assign n) sample (enum j') ≤ empiricalWelfareScore q (muHat0 n) (muHat1 n) (eHat n) (assign n) sample (enum j) + (n : ℝ)⁻¹}) exact (abs_le.mpr ⟨ le_trans (by norm_num) (lawRegret_nonneg P _ hLaw.wf hLaw.bdd (hvc.1 _ hmem)), lawRegret_le_four P _ hLaw.wf hLaw.bdd (hvc.1 _ hmem)⟩) have hIntPoolT : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P gT (assign n) sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) := by refine integrable_sSup_image_of_countable_dense _ policySet Pi0 _ (4 * B + 1) (by nlinarith [hB]) hPi0count ?_ ?_ hoffbound · intro π hπ exact measurable_pooled_offset_eval P gT (assign n) π (fun k => hgTmeas k π (hvc.1 π (hPi0sub hπ))) · intro sample refine sSup_image_eq_of_dense_tendsto _ policySet Pi0 hPi0sub (bddAbove_image_of_bound policySet _ (4 * B + 1) (fun sample π hπ => (le_abs_self _).trans (hoffbound sample π hπ)) sample) ?_ intro π hπ rcases hPi0dense π hπ with ⟨seq, hseq, hseqconv⟩ refine ⟨seq, hseq, ?_⟩ have hp := pooledCrossfitProcess_tendsto_of_skeleton P gT B hB hgTbound (fun k => clippedPolicyIncrementTrunc_compatible P q B (muHat0 n) (muHat1 n) (eHat n) k) hgTmeas (assign n) sample π seq (fun j => hvc.1 (seq j) (hPi0sub (hseq j))) hseqconv have hr := lawRegret_tendsto_of_skeleton P hLaw.wf hLaw.bdd π seq (hvc.1 π hπ) (fun j => hvc.1 (seq j) (hPi0sub (hseq j))) hseqconv exact (tendsto_const_nhds.max ((hp.abs.const_mul 2).sub (hr.div_const 4))) have hIntFoldT : ∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P gT (assign n) policySet k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure)) := by intro k unfold foldOffsetSubSup refine integrable_sSup_image_of_countable_dense _ policySet Pi0 _ (4 * B + 1) (by nlinarith [hB]) hPi0count ?_ ?_ (hfoldoffbound k) · intro π hπ exact measurable_fold_offset_eval P gT (assign n) k π (fun k' => hgTmeas k' π (hvc.1 π (hPi0sub hπ))) · intro sample refine sSup_image_eq_of_dense_tendsto _ policySet Pi0 hPi0sub (bddAbove_image_of_bound policySet _ (4 * B + 1) (fun sample π hπ => (le_abs_self _).trans (hfoldoffbound k sample π hπ)) sample) ?_ intro π hπ rcases hPi0dense π hπ with ⟨seq, hseq, hseqconv⟩ refine ⟨seq, hseq, ?_⟩ have hp := foldSubCentered_tendsto_of_skeleton P gT B hB hgTbound (fun k => clippedPolicyIncrementTrunc_compatible P q B (muHat0 n) (muHat1 n) (eHat n) k) hgTmeas (assign n) k sample π seq (fun j => hvc.1 (seq j) (hPi0sub (hseq j))) hseqconv have hr := lawRegret_tendsto_of_skeleton P hLaw.wf hLaw.bdd π seq (hvc.1 π hπ) (fun j => hvc.1 (seq j) (hPi0sub (hseq j))) hseqconv exact (tendsto_const_nhds.max ((hp.abs.const_mul 2).sub (hr.div_const 4))) -- Uniform-in-`π` bound on the UNTRUNCATED pooled process, for a fixed sample. have hpool_untrunc : ∀ (sample : Fin n → Observation 𝒳) (π : Policy 𝒳), |pooledCrossfitProcess P g (assign n) sample π| ≤ (n : ℝ)⁻¹ * ∑ i : Fin n, |clippedAIPWScore q (muHat0 n (assign n i)) (muHat1 n (assign n i)) (eHat n (assign n i)) (sample i)| + 6 / q := by intro sample π have hnR : (0 : ℝ) < (n : ℝ) := by exact_mod_cast hn have h6q : (0 : ℝ) ≤ 6 / q := le_of_lt (div_pos (by norm_num) hqn) set Γ : Fin n → ℝ := fun i => clippedAIPWScore q (muHat0 n (assign n i)) (muHat1 n (assign n i)) (eHat n (assign n i)) (sample i) with hΓ have hscore_ae : ∀ k : Fin K, ∀ᵐ O ∂P.dataMeasure, |clippedAIPWScore q (muHat0 n k) (muHat1 n k) (eHat n k) O| ≤ 6 / q := by intro k filter_upwards [hLaw.bdd.1] with O hO exact clipped_score_abs_le_six q (muHat0 n k) (muHat1 n k) (eHat n k) O (hbn' k) hqn hq1 hO have hgeq : ∀ (k : Fin K) (O : Observation 𝒳), g k π O = (boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)) * clippedAIPWScore q (muHat0 n k) (muHat1 n k) (eHat n k) O := fun k O => rfl have hterm : ∀ i : Fin n, |g (assign n i) π (sample i) - ∫ O, g (assign n i) π O ∂P.dataMeasure| ≤ |Γ i| + 6 / q := by intro i have hb : |boolIndicator (π (sample i).X) - boolIndicator (lawOptimalPolicy P (sample i).X)| ≤ 1 := boolIndicator_diff_abs_le_one _ _ have h1 : |g (assign n i) π (sample i)| ≤ |Γ i| := by rw [hgeq, abs_mul, hΓ] calc |boolIndicator (π (sample i).X) - boolIndicator (lawOptimalPolicy P (sample i).X)| * |clippedAIPWScore q (muHat0 n (assign n i)) (muHat1 n (assign n i)) (eHat n (assign n i)) (sample i)| ≤ 1 * |clippedAIPWScore q (muHat0 n (assign n i)) (muHat1 n (assign n i)) (eHat n (assign n i)) (sample i)| := mul_le_mul_of_nonneg_right hb (abs_nonneg _) _ = |Γ i| := by rw [one_mul, hΓ] have h2 : |∫ O, g (assign n i) π O ∂P.dataMeasure| ≤ 6 / q := by have hae : ∀ᵐ O ∂P.dataMeasure, ‖g (assign n i) π O‖ ≤ 6 / q := by filter_upwards [hscore_ae (assign n i)] with O hO rw [Real.norm_eq_abs, hgeq, abs_mul] have hbO : |boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)| ≤ 1 := boolIndicator_diff_abs_le_one _ _ calc |boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)| * |clippedAIPWScore q (muHat0 n (assign n i)) (muHat1 n (assign n i)) (eHat n (assign n i)) O| ≤ 1 * (6 / q) := mul_le_mul hbO hO (abs_nonneg _) (by norm_num) _ = 6 / q := one_mul _ have hnorm := norm_integral_le_of_norm_le_const (μ := P.dataMeasure) hae have huniv : P.dataMeasure.real univ = 1 := by simp [MeasureTheory.measureReal_def, measure_univ] rw [huniv, mul_one, Real.norm_eq_abs] at hnorm exact hnorm calc |g (assign n i) π (sample i) - ∫ O, g (assign n i) π O ∂P.dataMeasure| ≤ |g (assign n i) π (sample i)| + |∫ O, g (assign n i) π O ∂P.dataMeasure| := abs_sub _ _ _ ≤ |Γ i| + 6 / q := add_le_add h1 h2 have hsum_bound : |∑ i : Fin n, (g (assign n i) π (sample i) - ∫ O, g (assign n i) π O ∂P.dataMeasure)| ≤ ∑ i : Fin n, (|Γ i| + 6 / q) := (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum (fun i _ => hterm i)) have hsplit : ∑ i : Fin n, (|Γ i| + 6 / q) = (∑ i : Fin n, |Γ i|) + (n : ℝ) * (6 / q) := by rw [Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] rw [pooledCrossfitProcess, abs_mul, abs_of_nonneg (by positivity : (0 : ℝ) ≤ (n : ℝ)⁻¹)] calc (n : ℝ)⁻¹ * |∑ i : Fin n, (g (assign n i) π (sample i) - ∫ O, g (assign n i) π O ∂P.dataMeasure)| ≤ (n : ℝ)⁻¹ * ∑ i : Fin n, (|Γ i| + 6 / q) := mul_le_mul_of_nonneg_left hsum_bound (by positivity) _ = (n : ℝ)⁻¹ * ((∑ i : Fin n, |Γ i|) + (n : ℝ) * (6 / q)) := by rw [hsplit] _ = (n : ℝ)⁻¹ * ∑ i : Fin n, |Γ i| + 6 / q := by field_simp refine ⟨?_, ?_, ?_, ?_⟩ · simpa [q] using hIntRegret · exact hIntPoolT.congr (pooledOffsetSup_trunc_eq_original_ae_36 P q (muHat0 n) (muHat1 n) (eHat n) (assign n) policySet hLaw.wf hLaw.bdd hbn' hqn hq1) · intro sample refine ⟨2 * ((n : ℝ)⁻¹ * ∑ i : Fin n, |clippedAIPWScore q (muHat0 n (assign n i)) (muHat1 n (assign n i)) (eHat n (assign n i)) (sample i)| + 6 / q), ?_⟩ -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.bochner_discharge · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/BochnerIntegrability.lean:536
Helpers.ClipBias 21 declarations Provides clipped AIPW drift and clip-bias helper lemmas.

Provides clipped AIPW drift and clip-bias helper lemmas.

def clipBias

Pointwise clip-bias drift b_q(x) of the clipped-AIPW conditional mean.

Definition (Lean source)
noncomputable def clipBias (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (x : 𝒳) : ℝ := (clippedPropensity q eHat x - P.propensity x) * ((muHat1 x - P.mu1 x) / clippedPropensity q eHat x + (muHat0 x - P.mu0 x) / (1 - clippedPropensity q eHat x))
def driftIntegral

Policy-weighted population drift P[(π-π_⋆) b_q].

Definition (Lean source)
noncomputable def driftIntegral (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (π : Policy 𝒳) : ℝ := ∫ x, (boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x ∂P.PX
CausalSmith.Stat.PolicyRegretMarginOverlap.driftIntegral · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:25
def clippedPolicyIncrement

Cross-fit centered-process increment for the feasible clipped-AIPW ERM bridge.

Definition (Lean source)
noncomputable def clippedPolicyIncrement {K : ℕ} (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳) : ℝ := (boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)) * clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPolicyIncrement · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:31

The clipped-AIPW score truncated to the symmetric window [-B, B]: the score is returned unchanged where it already lies in the window, and replaced by the nearer endpoint elsewhere.

Definition (Lean source)
noncomputable def clippedScoreTrunc (q B : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (O : Observation 𝒳) : ℝ := clipReal B (clippedAIPWScore q muHat0 muHat1 eHat O)
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedScoreTrunc · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:42

The truncated cross-fit policy increment for fold k: the difference between the treatment indicator of the candidate policy and that of the law-optimal policy at the observation's covariate, multiplied by the B-truncated clipped-AIPW score built from fold k's cross-fitted nuisances.

Definition (Lean source)
noncomputable def clippedPolicyIncrementTrunc {K : ℕ} (P : ObservedLaw 𝒳) (q B : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳) : ℝ := (boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)) * clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPolicyIncrementTrunc · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:54
theorem measurable_observation_X

The covariate coordinate of an observation is a measurable function of the observation.

Formal statement
Measurable (fun O : Observation 𝒳 => O.X)
Proof (Lean source)
lemma measurable_observation_X : Measurable (fun O : Observation 𝒳 => O.X) := by exact measurable_fst.comp measurable_observation_tuple
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_observation_X · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:73
theorem measurable_observation_Y

The outcome coordinate of an observation is a measurable function of the observation.

Formal statement
Measurable (fun O : Observation 𝒳 => O.Y)
Proof (Lean source)
lemma measurable_observation_Y : Measurable (fun O : Observation 𝒳 => O.Y) := by exact measurable_snd.comp (measurable_snd.comp measurable_observation_tuple)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_observation_Y · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:83
theorem measurable_boolIndicator_observation_A

The real treatment indicator of an observation — one when treated, zero when untreated — is a measurable function of the observation.

Formal statement
Measurable (fun O : Observation 𝒳 => boolIndicator O.A)
Proof (Lean source)
lemma measurable_boolIndicator_observation_A : Measurable (fun O : Observation 𝒳 => boolIndicator O.A) := by exact (measurable_of_finite (fun b : Bool => boolIndicator b)).comp measurable_observation_A
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_boolIndicator_observation_A · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:89
theorem measurable_clippedPropensity

Clipping a measurable propensity function into the band [q, 1-q] leaves it measurable.

Formal statement
q :
e :
𝒳 → ℝ
he :
Proof (Lean source)
lemma measurable_clippedPropensity (q : ℝ) {e : 𝒳 → ℝ} (he : Measurable e) : Measurable (clippedPropensity q e) := by exact Measurable.min measurable_const (Measurable.max measurable_const he)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_clippedPropensity · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:96
theorem clipReal_eq_self_of_abs_le

Truncation to the symmetric window [-B, B] acts as the identity on any real number already bounded in absolute value by B.

Formal statement
B z :
hz :
|z| ≤ B
clipReal B z = z
Proof (Lean source)
lemma clipReal_eq_self_of_abs_le {B z : ℝ} (hz : |z| ≤ B) : clipReal B z = z := by have hz' := abs_le.mp hz unfold clipReal rw [min_eq_right hz'.2, max_eq_right hz'.1]
CausalSmith.Stat.PolicyRegretMarginOverlap.clipReal_eq_self_of_abs_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:112
theorem clippedPolicyIncrementTrunc_compatible

The truncated cross-fit policy increment is policy-compatible: it depends on the candidate policy only through the single binary treatment decision that policy makes at the observation's covariate.

Formal statement
K :
P :
q B :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
k :
Fin K
PolicyCompatible (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k)
Proof (Lean source)
lemma clippedPolicyIncrementTrunc_compatible {K : ℕ} (P : ObservedLaw 𝒳) (q B : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (k : Fin K) : PolicyCompatible (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k) := by refine ⟨fun O b => (boolIndicator b - boolIndicator (lawOptimalPolicy P O.X)) * clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O, ?_⟩ intro π O rfl
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPolicyIncrementTrunc_compatible · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:149
theorem clippedPolicyIncrementTrunc_measurable

For a well-formed law, a measurable candidate policy, and measurable fold-k cross-fitted nuisances, the truncated cross-fit policy increment is a measurable function of the observation.

Formal statement
K :
P :
q B :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
k :
Fin K
π :
Policy 𝒳
hwf :
:
hμ0meas :
Measurable (muHat0 k)
hμ1meas :
Measurable (muHat1 k)
hemeas :
Measurable (eHat k)
Measurable (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π)
Proof (Lean source)
lemma clippedPolicyIncrementTrunc_measurable {K : ℕ} (P : ObservedLaw 𝒳) (q B : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (k : Fin K) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hπ : Measurable π) (hμ0meas : Measurable (muHat0 k)) (hμ1meas : Measurable (muHat1 k)) (hemeas : Measurable (eHat k)) : Measurable (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π) := by have hπind : Measurable (fun O : Observation 𝒳 => boolIndicator (π O.X)) := (measurable_of_finite (fun b : Bool => boolIndicator b)).comp (hπ.comp measurable_observation_X) have hstar : Measurable (fun O : Observation 𝒳 => boolIndicator (lawOptimalPolicy P O.X)) := (measurable_of_finite (fun b : Bool => boolIndicator b)).comp ((lawOptimalPolicy_measurable P hwf).comp measurable_observation_X) have hscore : Measurable (fun O : Observation 𝒳 => clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O) := measurable_clipReal (measurable_clippedAIPWScore_observation q (muHat0 k) (muHat1 k) (eHat k) hμ0meas hμ1meas hemeas) exact (hπind.sub hstar).mul hscore
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPolicyIncrementTrunc_measurable · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:166
theorem clippedPolicyIncrementTrunc_bound

The truncated cross-fit policy increment is bounded in absolute value by the truncation level B, uniformly over candidate policies and observations, for any nonnegative B. So B is a genuine envelope for the whole increment class.

Formal statement
K :
P :
q B :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
k :
Fin K
π :
Policy 𝒳
O :
hB :
0 ≤ B
|clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O| ≤ B
Proof (Lean source)
lemma clippedPolicyIncrementTrunc_bound {K : ℕ} (P : ObservedLaw 𝒳) (q B : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (k : Fin K) (π : Policy 𝒳) (O : Observation 𝒳) (hB : 0 ≤ B) : |clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O| ≤ B := by have hdiff : |boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)| ≤ (1 : ℝ) := boolIndicator_sub_abs_le_one _ _ have hscore : |clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O| ≤ B := by simpa [clippedScoreTrunc] using clipReal_abs_le (B := B) (z := clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O) hB calc |clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O| = |boolIndicator (π O.X) - boolIndicator (lawOptimalPolicy P O.X)| * |clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O| := by simp [clippedPolicyIncrementTrunc, abs_mul] _ ≤ 1 * B := by exact mul_le_mul hdiff hscore (abs_nonneg _) zero_le_one _ = B := by ring
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPolicyIncrementTrunc_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:190
theorem bounded_mul

A pointwise product of two uniformly bounded real functions on the covariate space is again uniformly bounded.

Formal statement
f g :
𝒳 → ℝ
hf :
∃ M : ℝ, ∀ x, |f x| ≤ M
hg :
∃ M : ℝ, ∀ x, |g x| ≤ M
∃ M : ℝ, ∀ x, |f x * g x| ≤ M
Proof (Lean source)
lemma bounded_mul {f g : 𝒳 → ℝ} (hf : ∃ M : ℝ, ∀ x, |f x| ≤ M) (hg : ∃ M : ℝ, ∀ x, |g x| ≤ M) : ∃ M : ℝ, ∀ x, |f x * g x| ≤ M := by rcases hf with ⟨Mf, hMf⟩ rcases hg with ⟨Mg, hMg⟩ refine ⟨max Mf 0 * max Mg 0, ?_⟩ intro x have hf' : |f x| ≤ max Mf 0 := le_trans (hMf x) (le_max_left Mf 0) have hg' : |g x| ≤ max Mg 0 := le_trans (hMg x) (le_max_left Mg 0) calc |f x * g x| = |f x| * |g x| := abs_mul _ _ _ ≤ max Mf 0 * max Mg 0 := by gcongr
CausalSmith.Stat.PolicyRegretMarginOverlap.bounded_mul · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:217
theorem clippedPropensity_lower_min

The clipped propensity is at least min(q, 1-q), whatever value the underlying propensity takes. No constraint on the clipping level q is needed.

Formal statement
q :
e :
𝒳 → ℝ
x :
𝒳
min q (1 - q) ≤ clippedPropensity q e x
Proof (Lean source)
lemma clippedPropensity_lower_min (q : ℝ) (e : 𝒳 → ℝ) (x : 𝒳) : min q (1 - q) ≤ clippedPropensity q e x := by unfold clippedPropensity exact le_min (min_le_right q (1 - q)) (le_trans (min_le_left q (1 - q)) (le_max_left q (e x)))
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPropensity_lower_min · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:373
theorem clippedPropensity_le_one_sub

The clipped propensity never exceeds the upper clipping level 1 - q, whatever value the underlying propensity takes.

Formal statement
q :
e :
𝒳 → ℝ
x :
𝒳
clippedPropensity q e x ≤ 1 - q
Proof (Lean source)
lemma clippedPropensity_le_one_sub (q : ℝ) (e : 𝒳 → ℝ) (x : 𝒳) : clippedPropensity q e x ≤ 1 - q := by unfold clippedPropensity exact min_le_left (1 - q) (max q (e x))
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPropensity_le_one_sub · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:382
theorem clippedPropensity_pos

When the clipping level lies strictly between zero and one, the clipped propensity is strictly positive — this is what keeps the treated arm's inverse-propensity weight finite.

Formal statement
q :
e :
𝒳 → ℝ
x :
𝒳
hq :
0 < q
hq1 :
q < 1
Proof (Lean source)
lemma clippedPropensity_pos (q : ℝ) (e : 𝒳 → ℝ) (x : 𝒳) (hq : 0 < q) (hq1 : q < 1) : 0 < clippedPropensity q e x := by have hr : 0 < min q (1 - q) := lt_min hq (by linarith) exact lt_of_lt_of_le hr (clippedPropensity_lower_min q e x)
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPropensity_pos · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:390
theorem one_sub_clippedPropensity_pos

For a strictly positive clipping level, one minus the clipped propensity is strictly positive — this is what keeps the control arm's inverse-propensity weight finite.

Formal statement
q :
e :
𝒳 → ℝ
x :
𝒳
hq :
0 < q
0 < 1 - clippedPropensity q e x
Proof (Lean source)
lemma one_sub_clippedPropensity_pos (q : ℝ) (e : 𝒳 → ℝ) (x : 𝒳) (hq : 0 < q) : 0 < 1 - clippedPropensity q e x := by have hle := clippedPropensity_le_one_sub q e x linarith
CausalSmith.Stat.PolicyRegretMarginOverlap.one_sub_clippedPropensity_pos · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:400
theorem clippedPolicyIncrementTrunc_second_moment

The second moment of the truncated cross-fit policy increment under the data law is at most the squared truncation level times the covariate probability of the set where the candidate policy and the law-optimal policy disagree.

Formal statement
K :
P :
q B :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
k :
Fin K
π :
Policy 𝒳
hwf :
:
hB :
0 ≤ B
∫ O, (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O) ^ 2 ∂P.dataMeasure
≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))
Proof (Lean source)
lemma clippedPolicyIncrementTrunc_second_moment {K : ℕ} (P : ObservedLaw 𝒳) (q B : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (k : Fin K) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hπ : Measurable π) (hB : 0 ≤ B) : ∫ O, (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P)) := by classical let D : Set 𝒳 := disagreementSet π (lawOptimalPolicy P) let ind : 𝒳 → ℝ := D.indicator (fun _ : 𝒳 => (1 : ℝ)) have hτmeas : Measurable P.contrast := hwf.2.2.2.1 have hDmeas : MeasurableSet D := measurableSet_disagreementSet P π hτmeas hπ have hind_meas : Measurable ind := measurable_const.indicator hDmeas have hBsq_nonneg : 0 ≤ B ^ 2 := sq_nonneg B have hcov_meas : Measurable (fun x : 𝒳 => B ^ 2 * ind x) := measurable_const.mul hind_meas have hcov_bdd : ∃ M : ℝ, ∀ x : 𝒳, |B ^ 2 * ind x| ≤ M := by refine ⟨B ^ 2, ?_⟩ intro x by_cases hx : x ∈ D <;> simp [ind, hx, abs_of_nonneg hBsq_nonneg, hBsq_nonneg] have hcov_int : Integrable (fun O : Observation 𝒳 => B ^ 2 * ind O.X) P.dataMeasure := integrable_covariate_test P hwf hcov_meas hcov_bdd have hpoint : ∀ O : Observation 𝒳, (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O) ^ 2 ≤ B ^ 2 * ind O.X := by intro O by_cases hD : π O.X ≠ lawOptimalPolicy P O.X · have habs : |clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O| ≤ B := clippedPolicyIncrementTrunc_bound P q B muHat0 muHat1 eHat k π O hB have hsq : (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O) ^ 2 ≤ B ^ 2 := by rw [← sq_abs] exact sq_le_sq.mpr (by simpa [abs_of_nonneg (abs_nonneg _), abs_of_nonneg hB] using habs) simpa [ind, D, disagreementSet, hD] using hsq · have hEq : π O.X = lawOptimalPolicy P O.X := not_not.mp hD have hgzero : clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O = 0 := by simp [clippedPolicyIncrementTrunc, hEq] simp [hgzero, ind, D, disagreementSet, hD] have hnonneg : 0 ≤ᵐ[P.dataMeasure] fun O : Observation 𝒳 => (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O) ^ 2 := by filter_upwards with O exact sq_nonneg _ have hle : ∫ O, (clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat k π O) ^ 2 ∂P.dataMeasure ≤ ∫ O, B ^ 2 * ind O.X ∂P.dataMeasure := integral_mono_of_nonneg hnonneg hcov_int (Filter.Eventually.of_forall hpoint) have hrhs : ∫ O, B ^ 2 * ind O.X ∂P.dataMeasure = B ^ 2 * P.PX.real D := by calc ∫ O, B ^ 2 * ind O.X ∂P.dataMeasure = ∫ x, B ^ 2 * ind x ∂P.PX := covariate_integral_eq_px P hwf (fun x : 𝒳 => B ^ 2 * ind x) hcov_meas _ = B ^ 2 * ∫ x, ind x ∂P.PX := by rw [integral_const_mul] _ = B ^ 2 * P.PX.real D := by congr 1 exact integral_indicator_one (μ := P.PX) hDmeas simpa [D, hrhs] using hle
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPolicyIncrementTrunc_second_moment · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:531
theorem bounded_law_contrast

Under a well-formed law with bounded outcomes, the conditional treatment-effect contrast is uniformly bounded over the covariate space — the witnessing constant is 2, since the contrast is the difference of two outcome regressions each valued in [-1,1].

Formal statement
P :
hwf :
hbdd :
∃ M : ℝ, ∀ x, |P.contrast x| ≤ M
Proof (Lean source)
lemma bounded_law_contrast (P : ObservedLaw 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) : ∃ M : ℝ, ∀ x, |P.contrast x| ≤ M := by rcases hwf with ⟨_, _, _, _, _, _, _, hτeq, _⟩ refine ⟨2, ?_⟩ intro x have hmu0 : |P.mu0 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).1.1, (hbdd.2 x).1.2⟩ have hmu1 : |P.mu1 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).2.1, (hbdd.2 x).2.2⟩ calc |P.contrast x| = |P.mu1 x - P.mu0 x| := by rw [hτeq] _ ≤ |P.mu1 x| + |P.mu0 x| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1 hmu0 _ = (2 : ℝ) := by norm_num
CausalSmith.Stat.PolicyRegretMarginOverlap.bounded_law_contrast · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:666
theorem clip_bias Lemma 12 in the paper ↗

lem:clip-bias. Exact clipped-score conditional-mean drift identity E_P[Γ_q(O;η̄)∣X]-τ_P = (ē_q-e_P)(Δ₁/ē_q+Δ₀/(1-ē_q)) = b_q. This is the GENUINE conditional-expectation identity: its first conjunct is stated against the data law P.dataMeasure via the observed-law SEMANTIC conditions packaged in WellFormedLaw P (which pin e_P=P(A=1∣X), μ_a=E[Y∣A=a,X]), so it is NOT a free-standing algebraic identity over the nuisance fields — it ties the dataMeasure-integral of the clipped score to the closed-form drift b_q = clipBias. In tested (conditional-expectation defining) form: for every bounded measurable covariate test function φ, ∫ φ(X) Γ_q dP - ∫ φ τ_P dP_X = ∫ φ b_q dP_X, i.e. E_P[Γ_q∣X] = τ_P + b_q a.s. hbdd (bounded outcomes) is the regularity premise making the score integrals genuine. The second conjunct records the NL CANCELLATION characterization read off b_q: the drift vanishes WHERE the clipped propensity already equals the true propensity (ē_q(x)=e_P(x)) or both regression errors vanish (μ̂_a(x)=μ_a(x)) — so double-robust cancellation does NOT follow merely from p_P(x)>q.

Formal statement
P :
q :
muHat0 muHat1 eHat :
𝒳 → ℝ
hwf :
hbdd :
hpos :
regularity: nuisances are measurable bounded plug-ins (BoundedCrossfitNuisances)
hμ0meas :
Measurable muHat0
hμ1meas :
Measurable muHat1
hemeas :
hμ0bdd :
∃ M : ℝ, ∀ x, |muHat0 x| ≤ M
hμ1bdd :
∃ M : ℝ, ∀ x, |muHat1 x| ≤ M
hq :
0 < q
hq1 :
q < 1
φ :
𝒳 → ℝ
hφmeas :
hφbdd :
∃ M : ℝ, ∀ x, |φ x| ≤ M
((∫ O, φ O.X * clippedAIPWScore q muHat0 muHat1 eHat O ∂P.dataMeasure) - ∫ x, φ x * P.contrast x ∂P.PX = ∫ x, φ x * clipBias P q muHat0 muHat1 eHat x ∂P.PX) ∧
(∀ x : 𝒳, clippedPropensity q eHat x = P.propensity x ∨ (muHat1 x = P.mu1 x ∧ muHat0 x = P.mu0 x) → clipBias P q muHat0 muHat1 eHat x = 0) ∧
(∃ (P' : ObservedLaw ℝ) (q' : ℝ) (m0 m1 e' : ℝ → ℝ) (x : ℝ), WellFormedLaw P' ∧ BoundedOutcome P' ∧ Positivity P' ∧ 0 < q' ∧ q' < 1 ∧ q' < overlap P' x ∧ clipBias P' q' m0 m1 e' x ≠ 0)
Proof (Lean source)
lemma clip_bias (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hpos : Positivity P) -- regularity: nuisances are measurable bounded plug-ins (BoundedCrossfitNuisances) (hμ0meas : Measurable muHat0) (hμ1meas : Measurable muHat1) (hemeas : Measurable eHat) (hμ0bdd : ∃ M : ℝ, ∀ x, |muHat0 x| ≤ M) (hμ1bdd : ∃ M : ℝ, ∀ x, |muHat1 x| ≤ M) (hq : 0 < q) (hq1 : q < 1) (φ : 𝒳 → ℝ) (hφmeas : Measurable φ) (hφbdd : ∃ M : ℝ, ∀ x, |φ x| ≤ M) : ((∫ O, φ O.X * clippedAIPWScore q muHat0 muHat1 eHat O ∂P.dataMeasure) - ∫ x, φ x * P.contrast x ∂P.PX = ∫ x, φ x * clipBias P q muHat0 muHat1 eHat x ∂P.PX) ∧ (∀ x : 𝒳, clippedPropensity q eHat x = P.propensity x ∨ (muHat1 x = P.mu1 x ∧ muHat0 x = P.mu0 x) → clipBias P q muHat0 muHat1 eHat x = 0) ∧ (∃ (P' : ObservedLaw ℝ) (q' : ℝ) (m0 m1 e' : ℝ → ℝ) (x : ℝ), WellFormedLaw P' ∧ BoundedOutcome P' ∧ Positivity P' ∧ 0 < q' ∧ q' < 1 ∧ q' < overlap P' x ∧ clipBias P' q' m0 m1 e' x ≠ 0) := by have _hpos_retained : Positivity P := hpos rcases hwf with ⟨hPprob, hPXprob, hmap, hτmeas, hpropmeas, hPmu0meas, hPmu1meas, hτdef, hprop01, hA, hAY, hCY⟩ let hwf' : WellFormedLaw P := ⟨hPprob, hPXprob, hmap, hτmeas, hpropmeas, hPmu0meas, hPmu1meas, hτdef, hprop01, hA, hAY, hCY⟩ letI : IsProbabilityMeasure P.dataMeasure := hPprob letI : IsProbabilityMeasure P.PX := hPXprob have hcpmeas : Measurable (clippedPropensity q eHat) := measurable_clippedPropensity q hemeas have hψ0meas : Measurable (fun x => φ x * (muHat1 x - muHat0 x)) := hφmeas.mul (hμ1meas.sub hμ0meas) have hψ0bdd : ∃ M : ℝ, ∀ x, |φ x * (muHat1 x - muHat0 x)| ≤ M := bounded_mul hφbdd (bounded_sub hμ1bdd hμ0bdd) have hψ1meas : Measurable (fun x => φ x / clippedPropensity q eHat x) := hφmeas.div hcpmeas have hψ1bdd : ∃ M : ℝ, ∀ x, |φ x / clippedPropensity q eHat x| ≤ M := bounded_div_clipped q eHat φ hq hq1 hφbdd have hψ2meas : Measurable (fun x => muHat1 x * φ x / clippedPropensity q eHat x) := (hμ1meas.mul hφmeas).div hcpmeas have hψ2bdd : ∃ M : ℝ, ∀ x, |muHat1 x * φ x / clippedPropensity q eHat x| ≤ M := bounded_mul_div_clipped q eHat muHat1 φ hq hq1 hμ1bdd hφbdd have hψ3meas : Measurable (fun x => φ x / (1 - clippedPropensity q eHat x)) := hφmeas.div (measurable_const.sub hcpmeas) have hψ3bdd : ∃ M : ℝ, ∀ x, |φ x / (1 - clippedPropensity q eHat x)| ≤ M := bounded_div_one_sub_clipped q eHat φ hq hφbdd have hψ4meas : Measurable (fun x => muHat0 x * φ x / (1 - clippedPropensity q eHat x)) := (hμ0meas.mul hφmeas).div (measurable_const.sub hcpmeas) have hψ4bdd : ∃ M : ℝ, ∀ x, |muHat0 x * φ x / (1 - clippedPropensity q eHat x)| ≤ M := bounded_mul_div_one_sub_clipped q eHat muHat0 φ hq hμ0bdd hφbdd have hf0_data : Integrable (fun O : Observation 𝒳 => φ O.X * (muHat1 O.X - muHat0 O.X)) P.dataMeasure := integrable_covariate_test P hwf' hψ0meas hψ0bdd have hf1_data : Integrable (fun O : Observation 𝒳 => boolIndicator O.A * O.Y * (φ O.X / clippedPropensity q eHat O.X)) P.dataMeasure := integrable_treated_outcome_test P hwf' hbdd hψ1meas hψ1bdd have hf2_data : Integrable (fun O : Observation 𝒳 => boolIndicator O.A * (muHat1 O.X * φ O.X / clippedPropensity q eHat O.X)) P.dataMeasure := integrable_treated_test P hwf' hψ2meas hψ2bdd have hf3_data : Integrable (fun O : Observation 𝒳 => (1 - boolIndicator O.A) * O.Y * (φ O.X / (1 - clippedPropensity q eHat O.X))) P.dataMeasure := integrable_control_outcome_test P hwf' hbdd hψ3meas hψ3bdd have hf4_data : Integrable (fun O : Observation 𝒳 => (1 - boolIndicator O.A) * (muHat0 O.X * φ O.X / (1 - clippedPropensity q eHat O.X))) P.dataMeasure := integrable_control_test P hwf' hψ4meas hψ4bdd have hscore_split : ∫ O, φ O.X * clippedAIPWScore q muHat0 muHat1 eHat O ∂P.dataMeasure = ((((∫ O, φ O.X * (muHat1 O.X - muHat0 O.X) ∂P.dataMeasure) + ∫ O, boolIndicator O.A * O.Y * (φ O.X / clippedPropensity q eHat O.X) ∂P.dataMeasure) - ∫ O, boolIndicator O.A * (muHat1 O.X * φ O.X / clippedPropensity q eHat O.X) ∂P.dataMeasure) - ∫ O, (1 - boolIndicator O.A) * O.Y * (φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure + ∫ O, (1 - boolIndicator O.A) * (muHat0 O.X * φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure) := by calc ∫ O, φ O.X * clippedAIPWScore q muHat0 muHat1 eHat O ∂P.dataMeasure = ∫ O, (((φ O.X * (muHat1 O.X - muHat0 O.X) + boolIndicator O.A * O.Y * (φ O.X / clippedPropensity q eHat O.X)) - boolIndicator O.A * (muHat1 O.X * φ O.X / clippedPropensity q eHat O.X)) - (1 - boolIndicator O.A) * O.Y * (φ O.X / (1 - clippedPropensity q eHat O.X))) + (1 - boolIndicator O.A) * (muHat0 O.X * φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure := by apply integral_congr_ae exact Filter.Eventually.of_forall (clippedAIPWScore_test_expand_pointwise q muHat0 muHat1 eHat φ) _ = ((((∫ O, φ O.X * (muHat1 O.X - muHat0 O.X) ∂P.dataMeasure) + ∫ O, boolIndicator O.A * O.Y * (φ O.X / clippedPropensity q eHat O.X) ∂P.dataMeasure) - ∫ O, boolIndicator O.A * (muHat1 O.X * φ O.X / clippedPropensity q eHat O.X) ∂P.dataMeasure) - ∫ O, (1 - boolIndicator O.A) * O.Y * (φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure + ∫ O, (1 - boolIndicator O.A) * (muHat0 O.X * φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure) := by let f0 : Observation 𝒳 → ℝ := fun O => φ O.X * (muHat1 O.X - muHat0 O.X) let f1 : Observation 𝒳 → ℝ := fun O => boolIndicator O.A * O.Y * (φ O.X / clippedPropensity q eHat O.X) let f2 : Observation 𝒳 → ℝ := fun O => boolIndicator O.A * (muHat1 O.X * φ O.X / clippedPropensity q eHat O.X) let f3 : Observation 𝒳 → ℝ := fun O => (1 - boolIndicator O.A) * O.Y * (φ O.X / (1 - clippedPropensity q eHat O.X)) let f4 : Observation 𝒳 → ℝ := fun O => (1 - boolIndicator O.A) * (muHat0 O.X * φ O.X / (1 - clippedPropensity q eHat O.X)) change ∫ O, (((f0 O + f1 O) - f2 O) - f3 O) + f4 O ∂P.dataMeasure = ((((∫ O, f0 O ∂P.dataMeasure) + ∫ O, f1 O ∂P.dataMeasure) - ∫ O, f2 O ∂P.dataMeasure) - ∫ O, f3 O ∂P.dataMeasure) + ∫ O, f4 O ∂P.dataMeasure have hs4 : ∫ O, (((f0 O + f1 O) - f2 O) - f3 O) + f4 O ∂P.dataMeasure = ∫ O, ((f0 O + f1 O) - f2 O) - f3 O ∂P.dataMeasure + ∫ O, f4 O ∂P.dataMeasure := by simpa [f0, f1, f2, f3, f4, Pi.add_apply, Pi.sub_apply] using (integral_add (((hf0_data.add hf1_data).sub hf2_data).sub hf3_data) hf4_data) have hs3 : ∫ O, ((f0 O + f1 O) - f2 O) - f3 O ∂P.dataMeasure = ∫ O, (f0 O + f1 O) - f2 O ∂P.dataMeasure - ∫ O, f3 O ∂P.dataMeasure := by simpa [f0, f1, f2, f3, Pi.add_apply, Pi.sub_apply] using (integral_sub ((hf0_data.add hf1_data).sub hf2_data) hf3_data) have hs2 : ∫ O, (f0 O + f1 O) - f2 O ∂P.dataMeasure = ∫ O, f0 O + f1 O ∂P.dataMeasure - ∫ O, f2 O ∂P.dataMeasure := by simpa [f0, f1, f2, Pi.add_apply, Pi.sub_apply] using (integral_sub (hf0_data.add hf1_data) hf2_data) have hs1 : ∫ O, f0 O + f1 O ∂P.dataMeasure = ∫ O, f0 O ∂P.dataMeasure + ∫ O, f1 O ∂P.dataMeasure := by simpa [f0, f1, Pi.add_apply] using (integral_add hf0_data hf1_data) rw [hs4, hs3, hs2, hs1] have hI0 : ∫ O, φ O.X * (muHat1 O.X - muHat0 O.X) ∂P.dataMeasure = ∫ x, φ x * (muHat1 x - muHat0 x) ∂P.PX := covariate_integral_eq_px P hwf' (fun x => φ x * (muHat1 x - muHat0 x)) hψ0meas have hI1 : ∫ O, boolIndicator O.A * O.Y * (φ O.X / clippedPropensity q eHat O.X) ∂P.dataMeasure = ∫ x, P.propensity x * P.mu1 x * (φ x / clippedPropensity q eHat x) ∂P.PX := hAY (fun x => φ x / clippedPropensity q eHat x) hψ1meas hψ1bdd have hI2 : ∫ O, boolIndicator O.A * (muHat1 O.X * φ O.X / clippedPropensity q eHat O.X) ∂P.dataMeasure = ∫ x, P.propensity x * (muHat1 x * φ x / clippedPropensity q eHat x) ∂P.PX := hA (fun x => muHat1 x * φ x / clippedPropensity q eHat x) hψ2meas hψ2bdd have hI3 : ∫ O, (1 - boolIndicator O.A) * O.Y * (φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure = ∫ x, (1 - P.propensity x) * P.mu0 x * (φ x / (1 - clippedPropensity q eHat x)) ∂P.PX := hCY (fun x => φ x / (1 - clippedPropensity q eHat x)) hψ3meas hψ3bdd have hI4 : ∫ O, (1 - boolIndicator O.A) * (muHat0 O.X * φ O.X / (1 - clippedPropensity q eHat O.X)) ∂P.dataMeasure = ∫ x, (1 - P.propensity x) * (muHat0 x * φ x / (1 - clippedPropensity q eHat x)) ∂P.PX := control_test_integral_eq P hwf' hψ4meas hψ4bdd have hscore_px : -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.clip_bias · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/ClipBias.lean:902
Helpers.CrossfitProcess 25 declarations Provides centered empirical-process and cross-fit process helpers.

Provides centered empirical-process and cross-fit process helpers.

def centeredEmpProcess

Centered policy-indexed empirical process (P_m - P) g_π = m⁻¹ ∑_i g_π(O_i) - E_P g_π for an increment function g on a size-m sample.

Definition (Lean source)
noncomputable def centeredEmpProcess {m : ℕ} (P : ObservedLaw 𝒳) (g : Policy 𝒳 → Observation 𝒳 → ℝ) (sample : Fin m → Observation 𝒳) (π : Policy 𝒳) : ℝ := (m : ℝ)⁻¹ * ∑ i, g π (sample i) - ∫ O, g π O ∂P.dataMeasure
CausalSmith.Stat.PolicyRegretMarginOverlap.centeredEmpProcess · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:42
def expectedLocalizedSup

Expected localized supremum E_P sup_{π ∈ Π : R_P(π) ≤ r} |(P_m - P) g_π|, the i.i.d. sample of size m drawn from P.

Definition (Lean source)
noncomputable def expectedLocalizedSup {m : ℕ} (P : ObservedLaw 𝒳) (g : Policy 𝒳 → Observation 𝒳 → ℝ) (policySet : Set (Policy 𝒳)) (r : ℝ) : ℝ := ∫ sample, sSup ((fun π => |centeredEmpProcess P g sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r}) ∂(Measure.pi (fun _ : Fin m => P.dataMeasure))
CausalSmith.Stat.PolicyRegretMarginOverlap.expectedLocalizedSup · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:49
def pooledCrossfitProcess

Pooled cross-fit centered process: average of the foldwise centered increments g (assign i), with each evaluation fold i.i.d. conditional on its training fold.

Definition (Lean source)
noncomputable def pooledCrossfitProcess {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (sample : Fin n → Observation 𝒳) (π : Policy 𝒳) : ℝ := (n : ℝ)⁻¹ * ∑ i, (g (assign i) π (sample i) - ∫ O, g (assign i) π O ∂P.dataMeasure)
CausalSmith.Stat.PolicyRegretMarginOverlap.pooledCrossfitProcess · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:57
def expectedPooledLocalizedSup

Expected pooled cross-fit localized supremum.

Definition (Lean source)
noncomputable def expectedPooledLocalizedSup {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (r : ℝ) : ℝ := ∫ sample, sSup ((fun π => |pooledCrossfitProcess P g assign sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r}) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure))
CausalSmith.Stat.PolicyRegretMarginOverlap.expectedPooledLocalizedSup · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:66
def expectedPooledOffsetSup

Expected pooled cross-fit offset positive-part supremum E_P sup_π {2|G_cf(π)| - R_P(π)/4}_+.

Definition (Lean source)
noncomputable def expectedPooledOffsetSup {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) : ℝ := ∫ sample, sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure))
CausalSmith.Stat.PolicyRegretMarginOverlap.expectedPooledOffsetSup · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:74
def foldIndex

Index set of cross-fitting fold k: the observations of a size-n sample whose fold assignment is k.

Definition (Lean source)
abbrev foldIndex {n K : ℕ} (assign : Fin n → Fin K) (k : Fin K) := {i : Fin n // assign i = k}
def foldProjection

Restriction of a sample to cross-fitting fold k: the sub-sample listing only the observations assigned to that fold.

Definition (Lean source)
def foldProjection {n K : ℕ} (assign : Fin n → Fin K) (k : Fin K) (sample : Fin n → Observation 𝒳) : foldIndex assign k → Observation 𝒳 := fun i => sample i.1
CausalSmith.Stat.PolicyRegretMarginOverlap.foldProjection · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:89
theorem measurePreserving_foldProjection

Restricting an i.i.d. product sample to one cross-fitting fold is measure preserving onto the product law over that fold. Delegates to Causalean.Stat.measurePreserving_pi_restrict.

Formal statement
n K :
P :
assign :
Fin n → Fin K
k :
Fin K
IsProbabilityMeasure P.dataMeasure
MeasurePreserving (foldProjection (𝒳 := 𝒳) assign k) (Measure.pi (fun _ : Fin n => P.dataMeasure)) (Measure.pi (fun _ : foldIndex assign k => P.dataMeasure))
Proof (Lean source)
lemma measurePreserving_foldProjection {n K : ℕ} (P : ObservedLaw 𝒳) (assign : Fin n → Fin K) (k : Fin K) [IsProbabilityMeasure P.dataMeasure] : MeasurePreserving (foldProjection (𝒳 := 𝒳) assign k) (Measure.pi (fun _ : Fin n => P.dataMeasure)) (Measure.pi (fun _ : foldIndex assign k => P.dataMeasure)) := measurePreserving_pi_restrict P.dataMeasure (fun i => assign i = k)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurePreserving_foldProjection · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:95
def foldCenteredProcess

Centered empirical process of cross-fitting fold k: the average of the fold-k increment at the policy over the fold's OWN observations, minus that increment's population mean under the data law. The average is normalized by the number of observations in the fold, not by the total sample size.

Definition (Lean source)
noncomputable def foldCenteredProcess {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (k : Fin K) (sample : Fin n → Observation 𝒳) (π : Policy 𝒳) : ℝ := ((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i.1) - ∫ O, g k π O ∂P.dataMeasure)
CausalSmith.Stat.PolicyRegretMarginOverlap.foldCenteredProcess · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:144
def foldLocalizedSup

Localized supremum of the fold-k centered process: the largest absolute deviation attained over the policies of the class whose regret is at most the localization radius r.

Definition (Lean source)
noncomputable def foldLocalizedSup {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (r : ℝ) (k : Fin K) (sample : Fin n → Observation 𝒳) : ℝ := sSup ((fun π => |foldCenteredProcess P g assign k sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r})
CausalSmith.Stat.PolicyRegretMarginOverlap.foldLocalizedSup · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:155
def foldOffsetSup

Offset supremum of the fold-k centered process: the largest value over the whole policy class of twice the absolute deviation minus a quarter of that policy's regret, truncated below at zero. Charging each policy its own regret is what makes the supremum finite without fixing a localization radius in advance.

Definition (Lean source)
noncomputable def foldOffsetSup {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (k : Fin K) (sample : Fin n → Observation 𝒳) : ℝ := sSup ((fun π => max 0 (2 * |foldCenteredProcess P g assign k sample π| - lawRegret P π / 4)) '' policySet)
def foldLocalizedSubSup

The fold-k localized supremum read as a function of the FOLD'S OWN sub-sample rather than of the full sample. This is the form that can be integrated against the product law over the fold's index set, which is how a fold is treated as an independent sample of its own size.

Definition (Lean source)
noncomputable def foldLocalizedSubSup {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (r : ℝ) (k : Fin K) (sample : foldIndex assign k → Observation 𝒳) : ℝ := sSup ((fun π => |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r})
CausalSmith.Stat.PolicyRegretMarginOverlap.foldLocalizedSubSup · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:177
def foldOffsetSubSup

The fold-k offset supremum read as a function of the FOLD'S OWN sub-sample rather than of the full sample — the form that can be integrated against the product law over the fold's index set.

Definition (Lean source)
noncomputable def foldOffsetSubSup {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (k : Fin K) (sample : foldIndex assign k → Observation 𝒳) : ℝ := sSup ((fun π => max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)| - lawRegret P π / 4)) '' policySet)
CausalSmith.Stat.PolicyRegretMarginOverlap.foldOffsetSubSup · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:191
theorem integral_foldLocalizedSup_eq_expected

Averaging the fold-k localized supremum over the full-sample product law gives exactly the expected localized supremum for an i.i.d. sample whose size is the number of observations in that fold.

Formal statement
n K :
P :
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
r :
k :
Fin K
IsProbabilityMeasure P.dataMeasure
hm :
0 < card (foldIndex assign k)
hInt_sub :
Integrable (fun sample : foldIndex assign k → Observation 𝒳 => foldLocalizedSubSup P g assign policySet r k sample) (Measure.pi (fun _ : foldIndex assign k => P.dataMeasure))
∫ sample : Fin n → Observation 𝒳, foldLocalizedSup P g assign policySet r k sample ∂(Measure.pi (fun _ : Fin n => P.dataMeasure))
= expectedLocalizedSup (m := card (foldIndex assign k)) P (g k) policySet r
Proof (Lean source)
lemma integral_foldLocalizedSup_eq_expected {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (r : ℝ) (k : Fin K) [IsProbabilityMeasure P.dataMeasure] (hm : 0 < card (foldIndex assign k)) (hInt_sub : Integrable (fun sample : foldIndex assign k → Observation 𝒳 => foldLocalizedSubSup P g assign policySet r k sample) (Measure.pi (fun _ : foldIndex assign k => P.dataMeasure))) : ∫ sample : Fin n → Observation 𝒳, foldLocalizedSup P g assign policySet r k sample ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) = expectedLocalizedSup (m := card (foldIndex assign k)) P (g k) policySet r := by classical calc ∫ sample : Fin n → Observation 𝒳, foldLocalizedSup P g assign policySet r k sample ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) = ∫ sample : foldIndex assign k → Observation 𝒳, foldLocalizedSubSup P g assign policySet r k sample ∂(Measure.pi (fun _ : foldIndex assign k => P.dataMeasure)) := integral_comp_pi_restrict P.dataMeasure (fun i => assign i = k) (fun z => foldLocalizedSubSup P g assign policySet r k z) _ = expectedLocalizedSup (m := card (foldIndex assign k)) P (g k) policySet r := integral_foldLocalizedSubSup_eq_expected P g assign policySet r k hm
CausalSmith.Stat.PolicyRegretMarginOverlap.integral_foldLocalizedSup_eq_expected · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:422
theorem integral_foldOffsetSup_eq_expected

Averaging the fold-k offset supremum over the full-sample product law gives exactly the expected offset supremum of the centered empirical process for an i.i.d. sample whose size is the number of observations in that fold — the offset counterpart of the localized fold reduction.

Formal statement
n K :
P :
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
k :
Fin K
IsProbabilityMeasure P.dataMeasure
hm :
0 < card (foldIndex assign k)
hInt_sub :
Integrable (fun sample : foldIndex assign k → Observation 𝒳 => foldOffsetSubSup P g assign policySet k sample) (Measure.pi (fun _ : foldIndex assign k => P.dataMeasure))
∫ sample : Fin n → Observation 𝒳, foldOffsetSup P g assign policySet k sample ∂(Measure.pi (fun _ : Fin n => P.dataMeasure))
= ∫ sample, sSup ((fun π => max 0 (2 * |centeredEmpProcess P (g k) sample π| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin (card (foldIndex assign k)) => P.dataMeasure))
Proof (Lean source)
lemma integral_foldOffsetSup_eq_expected {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (k : Fin K) [IsProbabilityMeasure P.dataMeasure] (hm : 0 < card (foldIndex assign k)) (hInt_sub : Integrable (fun sample : foldIndex assign k → Observation 𝒳 => foldOffsetSubSup P g assign policySet k sample) (Measure.pi (fun _ : foldIndex assign k => P.dataMeasure))) : ∫ sample : Fin n → Observation 𝒳, foldOffsetSup P g assign policySet k sample ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) = ∫ sample, sSup ((fun π => max 0 (2 * |centeredEmpProcess P (g k) sample π| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin (card (foldIndex assign k)) => P.dataMeasure)) := by classical calc ∫ sample : Fin n → Observation 𝒳, foldOffsetSup P g assign policySet k sample ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) = ∫ sample : foldIndex assign k → Observation 𝒳, foldOffsetSubSup P g assign policySet k sample ∂(Measure.pi (fun _ : foldIndex assign k => P.dataMeasure)) := integral_comp_pi_restrict P.dataMeasure (fun i => assign i = k) (fun z => foldOffsetSubSup P g assign policySet k z) _ = ∫ sample, sSup ((fun π => max 0 (2 * |centeredEmpProcess P (g k) sample π| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin (card (foldIndex assign k)) => P.dataMeasure)) := integral_foldOffsetSubSup_eq_expected P g assign policySet k hm
CausalSmith.Stat.PolicyRegretMarginOverlap.integral_foldOffsetSup_eq_expected · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:457
theorem sum_foldWeights_eq_one

The cross-fitting fold weights — each fold's size divided by the total sample size — sum to one. So the pooled cross-fit process is a genuine convex combination of the foldwise processes.

Formal statement
n K :
assign :
Fin n → Fin K
hn :
0 < n
(∑ k : Fin K, (card (foldIndex assign k) : ℝ) / (n : ℝ)) = 1
Proof (Lean source)
lemma sum_foldWeights_eq_one {n K : ℕ} (assign : Fin n → Fin K) (hn : 0 < n) : (∑ k : Fin K, (card (foldIndex assign k) : ℝ) / (n : ℝ)) = 1 := by classical have hnR : (n : ℝ) ≠ 0 := by exact_mod_cast (ne_of_gt hn) have hcard := sum_foldIndex_card assign calc (∑ k : Fin K, (card (foldIndex assign k) : ℝ) / (n : ℝ)) = ((∑ k : Fin K, (card (foldIndex assign k) : ℝ)) / (n : ℝ)) := by rw [Finset.sum_div] _ = 1 := by rw [← Nat.cast_sum, hcard] field_simp [hnR]
CausalSmith.Stat.PolicyRegretMarginOverlap.sum_foldWeights_eq_one · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:595
theorem inv_card_sum_assign_eq_sum_foldWeights

Averaging any fold-indexed quantity across the observations of the sample is the same as taking its fold-weighted average, with each fold weighted by its size relative to the sample size.

Formal statement
n K :
assign :
Fin n → Fin K
H :
Fin K → ℝ
hn :
0 < n
(n : ℝ)⁻¹ * ∑ i : Fin n, H (assign i)
= ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * H k
Proof (Lean source)
lemma inv_card_sum_assign_eq_sum_foldWeights {n K : ℕ} (assign : Fin n → Fin K) (H : Fin K → ℝ) (hn : 0 < n) : (n : ℝ)⁻¹ * ∑ i : Fin n, H (assign i) = ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * H k := by classical let e : Fin n ≃ Sigma (foldIndex assign) := { toFun := fun i => ⟨assign i, ⟨i, rfl⟩⟩ invFun := fun p => p.2.1 left_inv := fun i => rfl right_inv := fun p => by cases p with | mk k i => cases i with | mk i hi => subst k rfl } have hregroup : (∑ i : Fin n, H (assign i)) = ∑ k : Fin K, ∑ _i : foldIndex assign k, H k := by calc (∑ i : Fin n, H (assign i)) = ∑ p : Sigma (foldIndex assign), H p.1 := by simpa [e] using (Fintype.sum_equiv e (fun i : Fin n => H (assign i)) (fun p : Sigma (foldIndex assign) => H p.1) (by intro i; rfl)) _ = ∑ k : Fin K, ∑ _i : foldIndex assign k, H k := by rw [Fintype.sum_sigma] have hnR : (n : ℝ) ≠ 0 := by exact_mod_cast (ne_of_gt hn) calc (n : ℝ)⁻¹ * ∑ i : Fin n, H (assign i) = (n : ℝ)⁻¹ * ∑ k : Fin K, ∑ _i : foldIndex assign k, H k := by rw [hregroup] _ = ∑ k : Fin K, (n : ℝ)⁻¹ * ∑ _i : foldIndex assign k, H k := by rw [Finset.mul_sum] _ = ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * H k := by apply Finset.sum_congr rfl intro k _hk simp [div_eq_inv_mul, mul_comm, mul_left_comm]
CausalSmith.Stat.PolicyRegretMarginOverlap.inv_card_sum_assign_eq_sum_foldWeights · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:611
theorem foldIndex_card_le

No cross-fitting fold contains more observations than the whole sample.

Formal statement
n K :
assign :
Fin n → Fin K
k :
Fin K
card (foldIndex assign k) ≤ n
Proof (Lean source)
lemma foldIndex_card_le {n K : ℕ} (assign : Fin n → Fin K) (k : Fin K) : card (foldIndex assign k) ≤ n := by classical simpa using Fintype.card_le_of_injective (fun i : foldIndex assign k => (i.1 : Fin n)) (by intro a b h; exact Subtype.ext h)
CausalSmith.Stat.PolicyRegretMarginOverlap.foldIndex_card_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:655
theorem fold_weight_mul_inv_sqrt_le

A fold's weight times its own root-m rate is at most the full-sample root-n rate: (m/n)·m^{-1/2} ≤ n^{-1/2} whenever 0 < m ≤ n.

Formal statement
m n :
hm :
0 < m
hmn :
m ≤ n
((m : ℝ) / (n : ℝ)) * (m : ℝ) ^ (-(1 / 2 : ℝ)) ≤ (n : ℝ) ^ (-(1 / 2 : ℝ))
Proof (Lean source)
lemma fold_weight_mul_inv_sqrt_le {m n : ℕ} (hm : 0 < m) (hmn : m ≤ n) : ((m : ℝ) / (n : ℝ)) * (m : ℝ) ^ (-(1 / 2 : ℝ)) ≤ (n : ℝ) ^ (-(1 / 2 : ℝ)) := by have hn : 0 < n := lt_of_lt_of_le hm hmn have hmR : 0 < (m : ℝ) := by exact_mod_cast hm have hnR : 0 < (n : ℝ) := by exact_mod_cast hn rw [Real.rpow_neg hmR.le, Real.rpow_neg hnR.le] rw [← Real.sqrt_eq_rpow (m : ℝ), ← Real.sqrt_eq_rpow (n : ℝ)] have hsqrt_le : sqrt (m : ℝ) ≤ sqrt (n : ℝ) := Real.sqrt_le_sqrt (by exact_mod_cast hmn) have hsqrt_n_nonneg : 0 ≤ sqrt (n : ℝ) := Real.sqrt_nonneg _ have hsqrt_m_nonneg : 0 ≤ sqrt (m : ℝ) := Real.sqrt_nonneg _ have hmul : sqrt (m : ℝ) * sqrt (n : ℝ) ≤ (n : ℝ) := by calc sqrt (m : ℝ) * sqrt (n : ℝ) ≤ sqrt (n : ℝ) * sqrt (n : ℝ) := by exact mul_le_mul_of_nonneg_right hsqrt_le hsqrt_n_nonneg _ = (n : ℝ) := by rw [Real.mul_self_sqrt hnR.le] have hm_eq : (m : ℝ) = sqrt (m : ℝ) * sqrt (m : ℝ) := by rw [Real.mul_self_sqrt hmR.le] have hcross : (m : ℝ) * sqrt (n : ℝ) ≤ (n : ℝ) * sqrt (m : ℝ) := by calc (m : ℝ) * sqrt (n : ℝ) = sqrt (m : ℝ) * (sqrt (m : ℝ) * sqrt (n : ℝ)) := by conv_lhs => rw [hm_eq] ring _ ≤ sqrt (m : ℝ) * (n : ℝ) := by exact mul_le_mul_of_nonneg_left hmul hsqrt_m_nonneg _ = (n : ℝ) * sqrt (m : ℝ) := by ring field_simp [hmR.ne', hnR.ne', Real.sqrt_pos.2 hmR, Real.sqrt_pos.2 hnR] exact hcross
CausalSmith.Stat.PolicyRegretMarginOverlap.fold_weight_mul_inv_sqrt_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:663
theorem fold_weight_mul_offset_rpow_le

The pooling step for the offset rate: (m/n)·(B²/m)^A ≤ (B²/n)^A whenever 0 < m ≤ n and the exponent A is at most one.

Formal statement
m n :
B A :
hm :
0 < m
hmn :
m ≤ n
hA1 :
A ≤ 1
((m : ℝ) / (n : ℝ)) * (B ^ 2 / (m : ℝ)) ^ A ≤ (B ^ 2 / (n : ℝ)) ^ A
Proof (Lean source)
lemma fold_weight_mul_offset_rpow_le {m n : ℕ} {B A : ℝ} (hm : 0 < m) (hmn : m ≤ n) (hA1 : A ≤ 1) : ((m : ℝ) / (n : ℝ)) * (B ^ 2 / (m : ℝ)) ^ A ≤ (B ^ 2 / (n : ℝ)) ^ A := by have hn : 0 < n := lt_of_lt_of_le hm hmn have hmR : 0 < (m : ℝ) := by exact_mod_cast hm have hnR : 0 < (n : ℝ) := by exact_mod_cast hn let x : ℝ := (m : ℝ) / (n : ℝ) have hxpos : 0 < x := div_pos hmR hnR have hxnonneg : 0 ≤ x := hxpos.le have hxle : x ≤ 1 := by dsimp [x] exact div_le_one_of_le₀ (by exact_mod_cast hmn) hnR.le have hbnonneg : 0 ≤ B ^ 2 / (n : ℝ) := div_nonneg (sq_nonneg B) hnR.le have hxpow_le : x ^ (1 - A) ≤ 1 := by exact Real.rpow_le_one hxnonneg hxle (sub_nonneg.mpr hA1) have heq_base : B ^ 2 / (m : ℝ) = (B ^ 2 / (n : ℝ)) / x := by dsimp [x] field_simp [hmR.ne', hnR.ne'] calc ((m : ℝ) / (n : ℝ)) * (B ^ 2 / (m : ℝ)) ^ A = x * (((B ^ 2 / (n : ℝ)) / x) ^ A) := by rw [heq_base] _ = x * ((B ^ 2 / (n : ℝ)) ^ A / x ^ A) := by rw [Real.div_rpow hbnonneg hxnonneg] _ = (B ^ 2 / (n : ℝ)) ^ A * x ^ (1 - A) := by have hxA_ne : x ^ A ≠ 0 := (Real.rpow_pos_of_pos hxpos A).ne' have hsub := Real.rpow_sub hxpos 1 A rw [Real.rpow_one] at hsub rw [hsub] field_simp [hxA_ne] _ ≤ (B ^ 2 / (n : ℝ)) ^ A * 1 := by exact mul_le_mul_of_nonneg_left hxpow_le (Real.rpow_nonneg hbnonneg A) _ = (B ^ 2 / (n : ℝ)) ^ A := by ring
CausalSmith.Stat.PolicyRegretMarginOverlap.fold_weight_mul_offset_rpow_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:700
theorem log_nat_rpow_le

The logarithmic factor is monotone in the sample size: (log m)^p ≤ (log n)^p for a nonnegative power p and 1 ≤ m ≤ n. So replacing a fold's size by the full sample size in a (log ·)^p factor only weakens the bound.

Formal statement
m n :
p :
hm :
0 < m
hmn :
m ≤ n
hp :
0 ≤ p
(log (m : ℝ)) ^ p ≤ (log (n : ℝ)) ^ p
Proof (Lean source)
lemma log_nat_rpow_le {m n : ℕ} {p : ℝ} (hm : 0 < m) (hmn : m ≤ n) (hp : 0 ≤ p) : (log (m : ℝ)) ^ p ≤ (log (n : ℝ)) ^ p := by have hmR : 0 < (m : ℝ) := by exact_mod_cast hm have hmnR : (m : ℝ) ≤ (n : ℝ) := by exact_mod_cast hmn have hlog_nonneg : 0 ≤ log (m : ℝ) := Real.log_nonneg (by exact_mod_cast Nat.succ_le_of_lt hm) have hlog_le : log (m : ℝ) ≤ log (n : ℝ) := Real.log_le_log hmR hmnR exact Real.rpow_le_rpow hlog_nonneg hlog_le hp
CausalSmith.Stat.PolicyRegretMarginOverlap.log_nat_rpow_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:739
theorem lawOptimalPolicy_measurable

The law-optimal policy — treat exactly where the contrast is nonnegative — is a measurable policy whenever the law is well formed, since well-formedness makes the contrast measurable.

Formal statement
P :
hwf :
Proof (Lean source)
lemma lawOptimalPolicy_measurable (P : ObservedLaw 𝒳) (hwf : WellFormedLaw P) : Measurable (lawOptimalPolicy P) := by rcases hwf with ⟨_hPprob, _hPXprob, _hmap, hτmeas, _⟩ refine measurable_to_bool (f := lawOptimalPolicy P) ?_ change MeasurableSet {x | lawOptimalPolicy P x = true} simpa [lawOptimalPolicy, optimalPolicy] using measurableSet_le measurable_const hτmeas
CausalSmith.Stat.PolicyRegretMarginOverlap.lawOptimalPolicy_measurable · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:825
theorem lawRegret_nonneg

Welfare regret is nonnegative for every measurable policy, under a well-formed law with bounded outcomes. By the welfare identity it is the integral of the absolute contrast against the disagreement indicator, and both factors are nonnegative.

Formal statement
P :
π :
Policy 𝒳
hwf :
hbdd :
:
0 ≤ lawRegret P π
Proof (Lean source)
lemma lawRegret_nonneg (P : ObservedLaw 𝒳) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hπ : Measurable π) : 0 ≤ lawRegret P π := by rw [regret_eq_disagreement_integral P π hwf hbdd hπ] exact integral_nonneg (fun x => mul_nonneg (abs_nonneg _) (by unfold disagreementIndicator split <;> norm_num))
CausalSmith.Stat.PolicyRegretMarginOverlap.lawRegret_nonneg · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:879
theorem pooledLocalizedSup_pointwise_le_sum_fold

Sample by sample, the localized supremum of the pooled cross-fit process is at most the fold-weighted sum of the foldwise localized suprema.

Formal statement
n K :
P :
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
r B :
sample :
Fin n → Observation 𝒳
IsProbabilityMeasure P.dataMeasure
hn :
0 < n
hB :
0 ≤ B
hbound :
∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B
sSup ((fun π => |pooledCrossfitProcess P g assign sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r})
≤ ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * foldLocalizedSup P g assign policySet r k sample
Proof (Lean source)
lemma pooledLocalizedSup_pointwise_le_sum_fold {n K : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (r B : ℝ) (sample : Fin n → Observation 𝒳) [IsProbabilityMeasure P.dataMeasure] (hn : 0 < n) (hB : 0 ≤ B) (hbound : ∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B) : sSup ((fun π => |pooledCrossfitProcess P g assign sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r}) ≤ ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * foldLocalizedSup P g assign policySet r k sample := by classical let loc : Set (Policy 𝒳) := {π | π ∈ policySet ∧ lawRegret P π ≤ r} let w : Fin K → ℝ := fun k => (card (foldIndex assign k) : ℝ) / (n : ℝ) have hw_nonneg : ∀ k, 0 ≤ w k := by intro k exact div_nonneg (by positivity) (by exact_mod_cast hn.le) have hfold_nonneg : ∀ k, 0 ≤ foldLocalizedSup P g assign policySet r k sample := by intro k apply Real.sSup_nonneg rintro y ⟨π, hπ, rfl⟩ exact abs_nonneg _ have hR_nonneg : 0 ≤ ∑ k : Fin K, w k * foldLocalizedSup P g assign policySet r k sample := by exact sum_nonneg (fun k _ => mul_nonneg (hw_nonneg k) (hfold_nonneg k)) apply Real.sSup_le ?_ hR_nonneg rintro y ⟨π, hπloc, rfl⟩ have hpool := pooledCrossfitProcess_eq_sum_fold P g assign sample π hn have hbdd_fold : ∀ k : Fin K, BddAbove ((fun π => |foldCenteredProcess P g assign k sample π|) '' loc) := by intro k refine ⟨2 * B, ?_⟩ rintro y ⟨π, hπ, rfl⟩ exact abs_foldCenteredProcess_le P g assign k sample π B hB (hbound k π hπ.1) calc |pooledCrossfitProcess P g assign sample π| = |∑ k : Fin K, w k * foldCenteredProcess P g assign k sample π| := by rw [hpool] _ ≤ ∑ k : Fin K, |w k * foldCenteredProcess P g assign k sample π| := Finset.abs_sum_le_sum_abs _ _ _ = ∑ k : Fin K, w k * |foldCenteredProcess P g assign k sample π| := by apply Finset.sum_congr rfl intro k _ rw [abs_mul, abs_of_nonneg (hw_nonneg k)] _ ≤ ∑ k : Fin K, w k * foldLocalizedSup P g assign policySet r k sample := by apply Finset.sum_le_sum intro k _ exact mul_le_mul_of_nonneg_left (le_csSup (hbdd_fold k) ⟨π, hπloc, rfl⟩) (hw_nonneg k)
CausalSmith.Stat.PolicyRegretMarginOverlap.pooledLocalizedSup_pointwise_le_sum_fold · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:936
theorem pooledOffsetSup_pointwise_le_sum_fold

Sample by sample, the offset supremum of the pooled cross-fit process is at most the fold-weighted sum of the foldwise offset suprema.

Formal statement
n K dPi :
P :
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
B :
sample :
Fin n → Observation 𝒳
hpc :
PolicyClassVC policySet dPi
hwf :
hbdd :
IsProbabilityMeasure P.dataMeasure
hn :
0 < n
hB :
0 ≤ B
hbound :
∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B
sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet)
≤ ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * foldOffsetSup P g assign policySet k sample
Proof (Lean source)
lemma pooledOffsetSup_pointwise_le_sum_fold {n K dPi : ℕ} (P : ObservedLaw 𝒳) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (B : ℝ) (sample : Fin n → Observation 𝒳) (hpc : PolicyClassVC policySet dPi) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) [IsProbabilityMeasure P.dataMeasure] (hn : 0 < n) (hB : 0 ≤ B) (hbound : ∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B) : sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet) ≤ ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * foldOffsetSup P g assign policySet k sample := by classical let w : Fin K → ℝ := fun k => (card (foldIndex assign k) : ℝ) / (n : ℝ) have hw_nonneg : ∀ k, 0 ≤ w k := by intro k exact div_nonneg (by positivity) (by exact_mod_cast hn.le) have hw_sum : (∑ k : Fin K, w k) = 1 := sum_foldWeights_eq_one assign hn have hfold_nonneg : ∀ k, 0 ≤ foldOffsetSup P g assign policySet k sample := by intro k apply Real.sSup_nonneg rintro y ⟨π, hπ, rfl⟩ exact le_max_left _ _ have hR_nonneg : 0 ≤ ∑ k : Fin K, w k * foldOffsetSup P g assign policySet k sample := by exact sum_nonneg (fun k _ => mul_nonneg (hw_nonneg k) (hfold_nonneg k)) apply Real.sSup_le ?_ hR_nonneg rintro y ⟨π, hπmem, rfl⟩ have hpool := pooledCrossfitProcess_eq_sum_fold P g assign sample π hn have hbdd_fold : ∀ k : Fin K, BddAbove ((fun π => max 0 (2 * |foldCenteredProcess P g assign k sample π| - lawRegret P π / 4)) '' policySet) := by intro k refine ⟨4 * B + 1, ?_⟩ rintro y ⟨π, hπ, rfl⟩ have hfold : |foldCenteredProcess P g assign k sample π| ≤ 2 * B := abs_foldCenteredProcess_le P g assign k sample π B hB (hbound k π hπ) have hreg : (-4 : ℝ) ≤ lawRegret P π := lawRegret_lower_bound P π hwf hbdd (hpc.1 π hπ) have hmain : 2 * |foldCenteredProcess P g assign k sample π| - lawRegret P π / 4 ≤ 4 * B + 1 := by nlinarith have hnon : 0 ≤ 4 * B + 1 := by nlinarith exact max_le hnon hmain calc max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4) = max 0 (2 * |∑ k : Fin K, w k * foldCenteredProcess P g assign k sample π| - lawRegret P π / 4) := by rw [hpool] _ ≤ ∑ k : Fin K, w k * max 0 (2 * |foldCenteredProcess P g assign k sample π| - lawRegret P π / 4) := max_weighted_abs_sub_le_sum w (fun k => foldCenteredProcess P g assign k sample π) (lawRegret P π) hw_nonneg hw_sum _ ≤ ∑ k : Fin K, w k * foldOffsetSup P g assign policySet k sample := by apply Finset.sum_le_sum intro k _ exact mul_le_mul_of_nonneg_left (le_csSup (hbdd_fold k) ⟨π, hπmem, rfl⟩) (hw_nonneg k)
CausalSmith.Stat.PolicyRegretMarginOverlap.pooledOffsetSup_pointwise_le_sum_fold · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/CrossfitProcess.lean:990
Helpers.DriftBound 12 declarations Provides clipped-region localization and drift-bound helpers.

Provides clipped-region localization and drift-bound helpers.

theorem clipped_region_localization Lemma 13 in the paper ↗

lem:clipped-region-localization. For γ>0, the disagreement mass inside the clipped region is controlled: P_X(D_π ∩ {p_P≤q}) ≤ C u^α q^{1/γ}+r/u.

Formal statement
P :
policySet :
Set (Policy 𝒳)
Co co α γ u0 :
hod :
OverlapDecay P u0 Co co α γ
hze :
ZeroEffectRegular P policySet
hbdd :
hwf :
hπmeas :
∀ π ∈ policySet, Measurable π
:
0 < γ
0 < max Co 1 ∧
∀ π ∈ policySet,
∀ u q : ℝ,
0 < u → u
≤ u0 → 0 < q → q ≤ co * u ^ γ → P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) ≤ max Co 1 * u ^ α * q ^ (1 / γ)
+ lawRegret P π / u
Proof (Lean source)
lemma clipped_region_localization (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (Co co α γ u0 : ℝ) (hod : OverlapDecay P u0 Co co α γ) (hze : ZeroEffectRegular P policySet) (hbdd : BoundedOutcome P) (hwf : WellFormedLaw P) (hπmeas : ∀ π ∈ policySet, Measurable π) (hγ : 0 < γ) : 0 < max Co 1 ∧ ∀ π ∈ policySet, ∀ u q : ℝ, 0 < u → u ≤ u0 → 0 < q → q ≤ co * u ^ γ → P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) ≤ max Co 1 * u ^ α * q ^ (1 / γ) + lawRegret P π / u := by refine ⟨lt_of_lt_of_le zero_lt_one (le_max_right Co 1), ?_⟩ intro π hπmem u q hu hu_le hq hqle letI : IsProbabilityMeasure P.PX := hwf.2.1 let D : Set 𝒳 := disagreementSet π (lawOptimalPolicy P) let T : Set 𝒳 := D ∩ {x | overlap P x ≤ q} let ZD : Set 𝒳 := {x | P.contrast x = 0 ∧ π x ≠ lawOptimalPolicy P x} let S : Set 𝒳 := {x | overlap P x ≤ q ∧ 0 < |P.contrast x| ∧ |P.contrast x| ≤ u} let B : Set 𝒳 := D ∩ {x | u < |P.contrast x|} have hZD_zero : P.PX.real ZD = 0 := by rcases hze with hzero | hzeroD · have hle : P.PX.real ZD ≤ P.PX.real {x | P.contrast x = 0} := by exact measureReal_mono (μ := P.PX) (by intro x hx exact hx.1) (measure_ne_top P.PX {x | P.contrast x = 0}) have hle0 : P.PX.real ZD ≤ 0 := by simpa [hzero] using hle exact le_antisymm hle0 measureReal_nonneg · simpa [ZD] using hzeroD π hπmem have hsmall : P.PX.real S ≤ max Co 1 * u ^ α * q ^ (1 / γ) := by have hod' := hod u q hu hu_le hq hqle have hfac_nonneg : 0 ≤ u ^ α * q ^ (1 / γ) := mul_nonneg (Real.rpow_nonneg hu.le _) (Real.rpow_nonneg hq.le _) have hcoef : Co * (u ^ α * q ^ (1 / γ)) ≤ max Co 1 * (u ^ α * q ^ (1 / γ)) := mul_le_mul_of_nonneg_right (le_max_left Co 1) hfac_nonneg calc P.PX.real S ≤ Co * u ^ α * q ^ (1 / γ) := by simpa [S, hγ.ne'] using hod' _ = Co * (u ^ α * q ^ (1 / γ)) := by ring _ ≤ max Co 1 * (u ^ α * q ^ (1 / γ)) := hcoef _ = max Co 1 * u ^ α * q ^ (1 / γ) := by ring have hbig : P.PX.real B ≤ lawRegret P π / u := by simpa [B, D] using regret_disagreement_large_contrast_le P π hwf hbdd (hπmeas π hπmem) hu have hsubset : T ⊆ ZD ∪ S ∪ B := by intro x hx rcases hx with ⟨hxD, hxOverlap⟩ by_cases hτzero : P.contrast x = 0 · left left exact ⟨hτzero, by simpa [D, disagreementSet] using hxD⟩ · by_cases hsmallContrast : |P.contrast x| ≤ u · left right exact ⟨hxOverlap, abs_pos.mpr hτzero, hsmallContrast⟩ · right exact ⟨hxD, lt_of_not_ge hsmallContrast⟩ have htarget_decomp : P.PX.real T ≤ P.PX.real S + P.PX.real B := by calc P.PX.real T ≤ P.PX.real (ZD ∪ S ∪ B) := measureReal_mono (μ := P.PX) hsubset (measure_ne_top P.PX (ZD ∪ S ∪ B)) _ ≤ P.PX.real (ZD ∪ S) + P.PX.real B := measureReal_union_le _ _ _ ≤ (P.PX.real ZD + P.PX.real S) + P.PX.real B := by have h := measureReal_union_le (μ := P.PX) ZD S linarith _ = P.PX.real S + P.PX.real B := by rw [hZD_zero] ring calc P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) = P.PX.real T := rfl _ ≤ P.PX.real S + P.PX.real B := htarget_decomp _ ≤ max Co 1 * u ^ α * q ^ (1 / γ) + lawRegret P π / u := add_le_add hsmall hbig
CausalSmith.Stat.PolicyRegretMarginOverlap.clipped_region_localization · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:19
theorem l2_abs_product_integral_le Lemma l2_abs_product_integral_le in the paper ↗

Cauchy–Schwarz in the shape used to form product rates: if two square-integrable functions have mean squares bounded by r_f^2 and r_g^2, then the integral of the product of their absolute values is at most r_f r_g. This is the step that turns two separate root-mean-square nuisance rates into a single product rate.

Formal statement
Ω :
Type*
Ω → ℝ
rf rg :
hf :
MemLp f 2 μ
hg :
MemLp g 2 μ
hsqf :
∫ x, f x ^ 2 ∂μ ≤ rf ^ 2
hsqg :
∫ x, g x ^ 2 ∂μ ≤ rg ^ 2
hrf :
0 ≤ rf
hrg :
0 ≤ rg
∫ x, |f x| * |g x| ∂μ ≤ rf * rg
Proof (Lean source)
lemma l2_abs_product_integral_le {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} {f g : Ω → ℝ} {rf rg : ℝ} (hf : MemLp f 2 μ) (hg : MemLp g 2 μ) (hsqf : ∫ x, f x ^ 2 ∂μ ≤ rf ^ 2) (hsqg : ∫ x, g x ^ 2 ∂μ ≤ rg ^ 2) (hrf : 0 ≤ rf) (hrg : 0 ≤ rg) : ∫ x, |f x| * |g x| ∂μ ≤ rf * rg := by have hf_nonneg : ∀ᵐ x ∂μ, 0 ≤ |f x| := by filter_upwards with x exact abs_nonneg _ have hg_nonneg : ∀ᵐ x ∂μ, 0 ≤ |g x| := by filter_upwards with x exact abs_nonneg _ have hf_abs2 : MemLp (fun x => |f x|) (ofReal 2) μ := by simpa using (hf.norm : MemLp (fun x => ‖f x‖) 2 μ) have hg_abs2 : MemLp (fun x => |g x|) (ofReal 2) μ := by simpa using (hg.norm : MemLp (fun x => ‖g x‖) 2 μ) have hholder : ∫ x, |f x| * |g x| ∂μ ≤ (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) * (∫ x, |g x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) := integral_mul_le_Lp_mul_Lq_of_nonneg Real.HolderConjugate.two_two hf_nonneg hg_nonneg hf_abs2 hg_abs2 have hf_sq_eq : (∫ x, |f x| ^ (2 : ℝ) ∂μ) = ∫ x, f x ^ 2 ∂μ := by apply integral_congr_ae filter_upwards with x rw [Real.rpow_two] exact sq_abs (f x) have hg_sq_eq : (∫ x, |g x| ^ (2 : ℝ) ∂μ) = ∫ x, g x ^ 2 ∂μ := by apply integral_congr_ae filter_upwards with x rw [Real.rpow_two] exact sq_abs (g x) have hf_sqrt_le : (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) ≤ rf := by calc (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) = sqrt (∫ x, |f x| ^ (2 : ℝ) ∂μ) := by rw [Real.sqrt_eq_rpow] _ ≤ sqrt (rf ^ 2) := Real.sqrt_le_sqrt (by simpa [hf_sq_eq] using hsqf) _ = rf := Real.sqrt_sq hrf have hg_sqrt_le : (∫ x, |g x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) ≤ rg := by calc (∫ x, |g x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) = sqrt (∫ x, |g x| ^ (2 : ℝ) ∂μ) := by rw [Real.sqrt_eq_rpow] _ ≤ sqrt (rg ^ 2) := Real.sqrt_le_sqrt (by simpa [hg_sq_eq] using hsqg) _ = rg := Real.sqrt_sq hrg calc ∫ x, |f x| * |g x| ∂μ ≤ (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) * (∫ x, |g x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) := hholder _ ≤ rf * rg := mul_le_mul hf_sqrt_le hg_sqrt_le (Real.rpow_nonneg (by positivity) _) hrf
CausalSmith.Stat.PolicyRegretMarginOverlap.l2_abs_product_integral_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:99

Cauchy-Schwarz against an indicator. Under a probability measure, the integral of a function's absolute value over a measurable set is at most the square root of that set's probability times the function's root-mean-square bound. This is what converts an integral localized to a small region into a mass factor multiplied by a rate.

Formal statement
Ω :
S :
Set Ω
hS :
f :
Ω → ℝ
r :
hf :
MemLp f 2 μ
hsq :
∫ x, f x ^ 2 ∂μ ≤ r ^ 2
hr :
0 ≤ r
∫ x, S.indicator (fun _ => (1 : ℝ)) x * |f x| ∂μ ≤ sqrt (μ.real S) * r
Proof (Lean source)
lemma l2_set_abs_integral_le {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ] {S : Set Ω} (hS : MeasurableSet S) {f : Ω → ℝ} {r : ℝ} (hf : MemLp f 2 μ) (hsq : ∫ x, f x ^ 2 ∂μ ≤ r ^ 2) (hr : 0 ≤ r) : ∫ x, S.indicator (fun _ => (1 : ℝ)) x * |f x| ∂μ ≤ sqrt (μ.real S) * r := by let ind : Ω → ℝ := S.indicator (fun _ => (1 : ℝ)) have hind_meas : AEStronglyMeasurable ind μ := (measurable_const.indicator hS).aestronglyMeasurable have hind_int_sq : Integrable (fun x => ind x ^ 2) μ := by refine Integrable.of_bound (hind_meas.pow 2) 1 ?_ filter_upwards with x by_cases hx : x ∈ S <;> simp [ind, hx] have hind_L2 : MemLp ind (ofReal 2) μ := by simpa using (memLp_two_iff_integrable_sq hind_meas).2 hind_int_sq have hf_abs2 : MemLp (fun x => |f x|) (ofReal 2) μ := by simpa using (hf.norm : MemLp (fun x => ‖f x‖) 2 μ) have hind_nonneg : ∀ᵐ x ∂μ, 0 ≤ ind x := by filter_upwards with x by_cases hx : x ∈ S <;> simp [ind, hx] have hf_nonneg : ∀ᵐ x ∂μ, 0 ≤ |f x| := by filter_upwards with x exact abs_nonneg _ have hholder : ∫ x, ind x * |f x| ∂μ ≤ (∫ x, ind x ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) * (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) := integral_mul_le_Lp_mul_Lq_of_nonneg Real.HolderConjugate.two_two hind_nonneg hf_nonneg hind_L2 hf_abs2 have hind_sq_eq : (∫ x, ind x ^ (2 : ℝ) ∂μ) = μ.real S := by calc ∫ x, ind x ^ (2 : ℝ) ∂μ = ∫ x, ind x ∂μ := by apply integral_congr_ae filter_upwards with x by_cases hx : x ∈ S <;> simp [ind, hx] _ = μ.real S := by exact integral_indicator_one (μ := μ) hS have hf_sq_eq : (∫ x, |f x| ^ (2 : ℝ) ∂μ) = ∫ x, f x ^ 2 ∂μ := by apply integral_congr_ae filter_upwards with x rw [Real.rpow_two] exact sq_abs (f x) have hf_sqrt_le : (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) ≤ r := by calc (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) = sqrt (∫ x, |f x| ^ (2 : ℝ) ∂μ) := by rw [Real.sqrt_eq_rpow] _ ≤ sqrt (r ^ 2) := Real.sqrt_le_sqrt (by simpa [hf_sq_eq] using hsq) _ = r := Real.sqrt_sq hr calc ∫ x, S.indicator (fun _ => (1 : ℝ)) x * |f x| ∂μ = ∫ x, ind x * |f x| ∂μ := rfl _ ≤ (∫ x, ind x ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) * (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) := hholder _ = sqrt (μ.real S) * (∫ x, |f x| ^ (2 : ℝ) ∂μ) ^ (1 / (2 : ℝ)) := by rw [hind_sq_eq, Real.sqrt_eq_rpow] _ ≤ sqrt (μ.real S) * r := mul_le_mul_of_nonneg_left hf_sqrt_le (Real.sqrt_nonneg _)
CausalSmith.Stat.PolicyRegretMarginOverlap.l2_set_abs_integral_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:159
theorem clippedPropensity_lipschitz Lemma clippedPropensity_lipschitz in the paper ↗

Truncating a real number into the band between q and 1-q never pushes two inputs further apart than they already were: the operation is nonexpansive.

Formal statement
q y z :
|min (1 - q) (max q y) - min (1 - q) (max q z)| ≤ |y - z|
Proof (Lean source)
lemma clippedPropensity_lipschitz (q y z : ℝ) : |min (1 - q) (max q y) - min (1 - q) (max q z)| ≤ |y - z| := by have hmax : |max q y - max q z| ≤ |y - z| := by simpa [abs_sub_comm, max_comm] using (abs_max_sub_max_le_abs y z q) have hmin : |min (1 - q) (max q y) - min (1 - q) (max q z)| ≤ |max q y - max q z| := by simpa [min_comm] using (abs_inf_sub_inf_le_abs (max q y) (max q z) (1 - q)) exact le_trans hmin hmax
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPropensity_lipschitz · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:223
theorem clippedPropensity_error_le_error_plus_overlap_indicator

Pointwise error of the clipped propensity. For a clip level between zero and one half, the distance between the clipped estimated propensity and the true propensity is at most the raw estimation error plus the clip level itself, and that extra charge is incurred only at covariate values whose true overlap is at or below the clip level. Away from the clipped region, clipping costs nothing.

Formal statement
P :
q :
eHat :
𝒳 → ℝ
x :
𝒳
hwf :
hq :
0 < q
hq_half :
q ≤ 1 / 2
|clippedPropensity q eHat x - P.propensity x|
≤ |eHat x
- P.propensity x|
+ q * ({x | overlap P x ≤ q}.indicator (fun _ : 𝒳 => (1 : ℝ)) x)
Proof (Lean source)
lemma clippedPropensity_error_le_error_plus_overlap_indicator (P : ObservedLaw 𝒳) (q : ℝ) (eHat : 𝒳 → ℝ) (x : 𝒳) (hwf : WellFormedLaw P) (hq : 0 < q) (hq_half : q ≤ 1 / 2) : |clippedPropensity q eHat x - P.propensity x| ≤ |eHat x - P.propensity x| + q * ({x | overlap P x ≤ q}.indicator (fun _ : 𝒳 => (1 : ℝ)) x) := by classical have he01 : P.propensity x ∈ Icc (0 : ℝ) 1 := hwf.2.2.2.2.2.2.2.2.1 x have hlip : |clippedPropensity q eHat x - clippedPropensity q P.propensity x| ≤ |eHat x - P.propensity x| := by simpa [clippedPropensity] using clippedPropensity_lipschitz q (eHat x) (P.propensity x) have hself_le : |clippedPropensity q P.propensity x - P.propensity x| ≤ q * ({x | overlap P x ≤ q}.indicator (fun _ : 𝒳 => (1 : ℝ)) x) := by by_cases hxlow : overlap P x ≤ q · have hdist : |clippedPropensity q P.propensity x - P.propensity x| ≤ q := by unfold clippedPropensity by_cases he_low : P.propensity x < q · have hmax : max q (P.propensity x) = q := max_eq_left he_low.le have hmin : min (1 - q) q = q := by apply min_eq_right linarith rw [hmax, hmin] rw [abs_of_nonneg] · linarith [he01.1] · linarith · have hqe : q ≤ P.propensity x := le_of_not_gt he_low by_cases he_high : 1 - q < P.propensity x · have hmax : max q (P.propensity x) = P.propensity x := max_eq_right hqe have hmin : min (1 - q) (P.propensity x) = 1 - q := min_eq_left he_high.le rw [hmax, hmin] rw [abs_of_nonpos] · linarith [he01.2] · linarith · have heq : P.propensity x ≤ 1 - q := le_of_not_gt he_high have hmax : max q (P.propensity x) = P.propensity x := max_eq_right hqe have hmin : min (1 - q) (P.propensity x) = P.propensity x := min_eq_right heq rw [hmax, hmin] simp [hq.le] simpa [hxlow] using hdist · have hgt : q < overlap P x := lt_of_not_ge hxlow have hqe : q ≤ P.propensity x := by have hminle : overlap P x ≤ P.propensity x := by unfold overlap exact min_le_left _ _ linarith have heq : P.propensity x ≤ 1 - q := by have hminle : overlap P x ≤ 1 - P.propensity x := by unfold overlap exact min_le_right _ _ linarith have hmax : max q (P.propensity x) = P.propensity x := max_eq_right hqe have hmin : min (1 - q) (P.propensity x) = P.propensity x := min_eq_right heq have hzero : |clippedPropensity q P.propensity x - P.propensity x| = 0 := by simp [clippedPropensity, hmax, hmin] simp [hxlow, hzero] calc |clippedPropensity q eHat x - P.propensity x| = |(clippedPropensity q eHat x - clippedPropensity q P.propensity x) + (clippedPropensity q P.propensity x - P.propensity x)| := by ring_nf _ ≤ |clippedPropensity q eHat x - clippedPropensity q P.propensity x| + |clippedPropensity q P.propensity x - P.propensity x| := abs_add_le _ _ _ ≤ |eHat x - P.propensity x| + q * ({x | overlap P x ≤ q}.indicator (fun _ : 𝒳 => (1 : ℝ)) x) := add_le_add hlip hself_le
CausalSmith.Stat.PolicyRegretMarginOverlap.clippedPropensity_error_le_error_plus_overlap_indicator · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:235
theorem policy_overlap_indicator_mul_le_inter_indicator

The disagreement weight between two policies, restricted to a set, is dominated by the indicator of the intersection. The absolute difference of the two policies' treatment indicators is at most one and is zero wherever the policies agree, so multiplying it by the indicator of any set is bounded by the indicator of that set intersected with the region where the policies disagree.

Formal statement
π πstar :
Policy 𝒳
S :
Set 𝒳
x :
𝒳
|boolIndicator (π x) - boolIndicator (πstar x)| * (S.indicator (fun _ : 𝒳 => (1 : ℝ)) x)
≤ ((disagreementSet π πstar ∩ S).indicator (fun _ : 𝒳 => (1 : ℝ)) x)
Proof (Lean source)
lemma policy_overlap_indicator_mul_le_inter_indicator (π πstar : Policy 𝒳) (S : Set 𝒳) (x : 𝒳) : |boolIndicator (π x) - boolIndicator (πstar x)| * (S.indicator (fun _ : 𝒳 => (1 : ℝ)) x) ≤ ((disagreementSet π πstar ∩ S).indicator (fun _ : 𝒳 => (1 : ℝ)) x) := by classical have hdiff_le : |boolIndicator (π x) - boolIndicator (πstar x)| ≤ (1 : ℝ) := by cases π x <;> cases πstar x <;> simp [boolIndicator] have hdiff_zero : x ∉ disagreementSet π πstar → |boolIndicator (π x) - boolIndicator (πstar x)| = 0 := by intro hxD unfold disagreementSet at hxD have heq : π x = πstar x := not_not.mp hxD simp [heq] by_cases hxD : x ∈ disagreementSet π πstar · by_cases hxS : x ∈ S · simp [hxD, hxS] exact hdiff_le · simp [hxS] · have hz := hdiff_zero hxD by_cases hxS : x ∈ S <;> simp [hz, hxD, hxS]
CausalSmith.Stat.PolicyRegretMarginOverlap.policy_overlap_indicator_mul_le_inter_indicator · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:311
theorem policy_clipBias_abs_pointwise_le

Pointwise bound on the disagreement-weighted clipped-AIPW bias. At each covariate value, the product of the policy-disagreement weight and the clip bias is at most the propensity error times each of the two outcome-regression errors, divided by the clip level, plus each outcome-regression error restricted to the part of the disagreement region whose overlap is at or below the clip level. The first group is the familiar product-bias term; the second is the price of clipping, and it is charged only inside the clipped region.

Formal statement
P :
q :
muHat0 muHat1 eHat :
𝒳 → ℝ
π :
Policy 𝒳
x :
𝒳
hwf :
hq :
0 < q
hq_half :
q ≤ 1 / 2
|(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x|
≤ (|eHat x - P.propensity x| * |muHat1 x - P.mu1 x| + |eHat x - P.propensity x| * |muHat0 x - P.mu0 x|) / q
+ ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) * |muHat1 x
- P.mu1 x|
+ ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) * |muHat0 x
- P.mu0 x|
Proof (Lean source)
lemma policy_clipBias_abs_pointwise_le (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (π : Policy 𝒳) (x : 𝒳) (hwf : WellFormedLaw P) (hq : 0 < q) (hq_half : q ≤ 1 / 2) : |(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x| ≤ (|eHat x - P.propensity x| * |muHat1 x - P.mu1 x| + |eHat x - P.propensity x| * |muHat0 x - P.mu0 x|) / q + ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) * |muHat1 x - P.mu1 x| + ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) * |muHat0 x - P.mu0 x| := by classical have hq1 : q < 1 := by linarith let cp := clippedPropensity q eHat x let e := P.propensity x let de := |eHat x - e| let indO := ({x | overlap P x ≤ q}.indicator (fun _ : 𝒳 => (1 : ℝ)) x) let indT := ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) let d1 := |muHat1 x - P.mu1 x| let d0 := |muHat0 x - P.mu0 x| let ph := |boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)| have hcp_pos : 0 < cp := clippedPropensity_pos q eHat x hq hq1 have hden_pos : 0 < 1 - cp := one_sub_clippedPropensity_pos q eHat x hq have hcp_inv : cp⁻¹ ≤ q⁻¹ := by have hcp_lower : q ≤ cp := by have hmin := clippedPropensity_lower_min q eHat x have hmin_eq : min q (1 - q) = q := by apply min_eq_left linarith simpa [cp, hmin_eq] using hmin rw [inv_le_inv₀ hcp_pos hq] exact hcp_lower have hden_inv : (1 - cp)⁻¹ ≤ q⁻¹ := by have hden_lower : q ≤ 1 - cp := by have hle := clippedPropensity_le_one_sub q eHat x linarith [show cp = clippedPropensity q eHat x from rfl] rw [inv_le_inv₀ hden_pos hq] exact hden_lower have hcliperr : |cp - e| ≤ de + q * indO := by simpa [cp, e, de, indO] using clippedPropensity_error_le_error_plus_overlap_indicator P q eHat x hwf hq hq_half have hfrac1 : |(muHat1 x - P.mu1 x) / cp| ≤ d1 / q := by calc |(muHat1 x - P.mu1 x) / cp| = d1 * cp⁻¹ := by rw [abs_div, abs_of_pos hcp_pos, div_eq_mul_inv] _ ≤ d1 * q⁻¹ := by exact mul_le_mul_of_nonneg_left hcp_inv (abs_nonneg _) _ = d1 / q := by rw [div_eq_mul_inv] have hfrac0 : |(muHat0 x - P.mu0 x) / (1 - cp)| ≤ d0 / q := by calc |(muHat0 x - P.mu0 x) / (1 - cp)| = d0 * (1 - cp)⁻¹ := by rw [abs_div, abs_of_pos hden_pos, div_eq_mul_inv] _ ≤ d0 * q⁻¹ := by exact mul_le_mul_of_nonneg_left hden_inv (abs_nonneg _) _ = d0 / q := by rw [div_eq_mul_inv] have hnon_indO : 0 ≤ indO := by by_cases hx : overlap P x ≤ q <;> simp [indO, hx] have hcliperr_rhs_nonneg : 0 ≤ de + q * indO := add_nonneg (abs_nonneg _) (mul_nonneg hq.le hnon_indO) have hclipBias_abs : |clipBias P q muHat0 muHat1 eHat x| ≤ (de + q * indO) * (d1 / q + d0 / q) := by change |(cp - e) * ((muHat1 x - P.mu1 x) / cp + (muHat0 x - P.mu0 x) / (1 - cp))| ≤ (de + q * indO) * (d1 / q + d0 / q) calc |(cp - e) * ((muHat1 x - P.mu1 x) / cp + (muHat0 x - P.mu0 x) / (1 - cp))| = |cp - e| * |(muHat1 x - P.mu1 x) / cp + (muHat0 x - P.mu0 x) / (1 - cp)| := abs_mul _ _ _ ≤ |cp - e| * (|(muHat1 x - P.mu1 x) / cp| + |(muHat0 x - P.mu0 x) / (1 - cp)|) := by exact mul_le_mul_of_nonneg_left (abs_add_le _ _) (abs_nonneg _) _ ≤ (de + q * indO) * (d1 / q + d0 / q) := by exact mul_le_mul hcliperr (add_le_add hfrac1 hfrac0) (add_nonneg (abs_nonneg _) (abs_nonneg _)) hcliperr_rhs_nonneg have hph_le_one : ph ≤ 1 := by dsimp [ph] cases π x <;> cases lawOptimalPolicy P x <;> simp [boolIndicator] have hph_ind : ph * indO ≤ indT := by simpa [ph, indO, indT] using policy_overlap_indicator_mul_le_inter_indicator π (lawOptimalPolicy P) {x | overlap P x ≤ q} x have hnon_de : 0 ≤ de := abs_nonneg _ have hnon_d1 : 0 ≤ d1 := abs_nonneg _ have hnon_d0 : 0 ≤ d0 := abs_nonneg _ calc |(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x| = ph * |clipBias P q muHat0 muHat1 eHat x| := by rw [abs_mul] _ ≤ ph * ((de + q * indO) * (d1 / q + d0 / q)) := mul_le_mul_of_nonneg_left hclipBias_abs (abs_nonneg _) _ = ph * (de * d1 / q + de * d0 / q + indO * d1 + indO * d0) := by field_simp [hq.ne'] ring _ ≤ de * d1 / q + de * d0 / q + indT * d1 + indT * d0 := by have h1 : ph * (de * d1 / q) ≤ de * d1 / q := mul_le_of_le_one_left (div_nonneg (mul_nonneg hnon_de hnon_d1) hq.le) hph_le_one have h2 : ph * (de * d0 / q) ≤ de * d0 / q := mul_le_of_le_one_left (div_nonneg (mul_nonneg hnon_de hnon_d0) hq.le) hph_le_one have h3 : ph * (indO * d1) ≤ indT * d1 := by calc ph * (indO * d1) = (ph * indO) * d1 := by ring _ ≤ indT * d1 := mul_le_mul_of_nonneg_right hph_ind hnon_d1 have h4 : ph * (indO * d0) ≤ indT * d0 := by calc ph * (indO * d0) = (ph * indO) * d0 := by ring _ ≤ indT * d0 := mul_le_mul_of_nonneg_right hph_ind hnon_d0 nlinarith _ = (|eHat x - P.propensity x| * |muHat1 x - P.mu1 x| + |eHat x - P.propensity x| * |muHat0 x - P.mu0 x|) / q + ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) * |muHat1 x - P.mu1 x| + ((disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}).indicator (fun _ : 𝒳 => (1 : ℝ)) x) * |muHat0 x - P.mu0 x| := by simp [de, d1, d0, indT] ring
CausalSmith.Stat.PolicyRegretMarginOverlap.policy_clipBias_abs_pointwise_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:339
theorem clipBias_drift_l2_mass_bound

Integrated clip-bias drift bound in terms of the clipped-region mass. If the two outcome-regression errors have root-mean-square bound r_μ and the propensity error has root-mean-square bound r_e, then the policy-weighted population drift is at most twice the product rate divided by the clip level, plus twice r_μ times the square root of the probability that a covariate both lies in the disagreement region and has overlap at or below the clip level. Only that mass enters; bounding it is left to the localization step.

Formal statement
P :
q rMu rE :
muHat0 muHat1 eHat :
𝒳 → ℝ
hsq0 :
∫ x, (muHat0 x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hsq1 :
∫ x, (muHat1 x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hse :
∫ x, (eHat x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2
hμ0L2 :
MemLp (fun x => muHat0 x - P.mu0 x) 2 P.PX
hμ1L2 :
MemLp (fun x => muHat1 x - P.mu1 x) 2 P.PX
heL2 :
MemLp (fun x => eHat x - P.propensity x) 2 P.PX
hrMu_nonneg :
0 ≤ rMu
hrE_nonneg :
0 ≤ rE
hwf :
hq :
0 < q
hq_half :
q ≤ 1 / 2
π :
Policy 𝒳
:
|driftIntegral P q muHat0 muHat1 eHat π|
≤ 2 * (rMu * rE / q)
+ 2 * rMu * sqrt (P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}))
Proof (Lean source)
lemma clipBias_drift_l2_mass_bound (P : ObservedLaw 𝒳) (q rMu rE : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (hsq0 : ∫ x, (muHat0 x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hsq1 : ∫ x, (muHat1 x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hse : ∫ x, (eHat x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2) (hμ0L2 : MemLp (fun x => muHat0 x - P.mu0 x) 2 P.PX) (hμ1L2 : MemLp (fun x => muHat1 x - P.mu1 x) 2 P.PX) (heL2 : MemLp (fun x => eHat x - P.propensity x) 2 P.PX) (hrMu_nonneg : 0 ≤ rMu) (hrE_nonneg : 0 ≤ rE) (hwf : WellFormedLaw P) (hq : 0 < q) (hq_half : q ≤ 1 / 2) (π : Policy 𝒳) (hπ : Measurable π) : |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * (rMu * rE / q) + 2 * rMu * sqrt (P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q})) := by classical rcases hwf with ⟨hPprob, hPXprob, hmap, hτmeas, hpropmeas, hmu0meas, hmu1meas, hτdef, hprop01, hA, hAY, hCY⟩ let hwf' : WellFormedLaw P := ⟨hPprob, hPXprob, hmap, hτmeas, hpropmeas, hmu0meas, hmu1meas, hτdef, hprop01, hA, hAY, hCY⟩ letI : IsProbabilityMeasure P.PX := hPXprob let T : Set 𝒳 := disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q} let prod1 : 𝒳 → ℝ := fun x => |eHat x - P.propensity x| * |muHat1 x - P.mu1 x| let prod0 : 𝒳 → ℝ := fun x => |eHat x - P.propensity x| * |muHat0 x - P.mu0 x| let set1 : 𝒳 → ℝ := fun x => T.indicator (fun _ : 𝒳 => (1 : ℝ)) x * |muHat1 x - P.mu1 x| let set0 : 𝒳 → ℝ := fun x => T.indicator (fun _ : 𝒳 => (1 : ℝ)) x * |muHat0 x - P.mu0 x| let major : 𝒳 → ℝ := fun x => (prod1 x + prod0 x) / q + set1 x + set0 x have hoverlap_meas : Measurable fun x => overlap P x := by unfold overlap exact hpropmeas.min (measurable_const.sub hpropmeas) have hSmeas : MeasurableSet {x | overlap P x ≤ q} := measurableSet_le hoverlap_meas measurable_const have hDmeas : MeasurableSet (disagreementSet π (lawOptimalPolicy P)) := measurableSet_disagreementSet P π hτmeas hπ have hTmeas : MeasurableSet T := hDmeas.inter hSmeas have he_abs : MemLp (fun x => |eHat x - P.propensity x|) 2 P.PX := by simpa using heL2.norm have hμ1_abs : MemLp (fun x => |muHat1 x - P.mu1 x|) 2 P.PX := by simpa using hμ1L2.norm have hμ0_abs : MemLp (fun x => |muHat0 x - P.mu0 x|) 2 P.PX := by simpa using hμ0L2.norm have hprod1_int : Integrable prod1 P.PX := by exact he_abs.integrable_mul hμ1_abs have hprod0_int : Integrable prod0 P.PX := by exact he_abs.integrable_mul hμ0_abs have hset1_int : Integrable set1 P.PX := by let ind : 𝒳 → ℝ := T.indicator (fun _ : 𝒳 => (1 : ℝ)) have hind_meas : AEStronglyMeasurable ind P.PX := (measurable_const.indicator hTmeas).aestronglyMeasurable have hind_int_sq : Integrable (fun x => ind x ^ 2) P.PX := by refine Integrable.of_bound (hind_meas.pow 2) 1 ?_ filter_upwards with x by_cases hx : x ∈ T <;> simp [ind, hx] have hind_L2 : MemLp ind 2 P.PX := by simpa using (memLp_two_iff_integrable_sq hind_meas).2 hind_int_sq have hmul : Integrable (ind * fun x => |muHat1 x - P.mu1 x|) P.PX := hind_L2.integrable_mul hμ1_abs exact hmul have hset0_int : Integrable set0 P.PX := by let ind : 𝒳 → ℝ := T.indicator (fun _ : 𝒳 => (1 : ℝ)) have hind_meas : AEStronglyMeasurable ind P.PX := (measurable_const.indicator hTmeas).aestronglyMeasurable have hind_int_sq : Integrable (fun x => ind x ^ 2) P.PX := by refine Integrable.of_bound (hind_meas.pow 2) 1 ?_ filter_upwards with x by_cases hx : x ∈ T <;> simp [ind, hx] have hind_L2 : MemLp ind 2 P.PX := by simpa using (memLp_two_iff_integrable_sq hind_meas).2 hind_int_sq have hmul : Integrable (ind * fun x => |muHat0 x - P.mu0 x|) P.PX := hind_L2.integrable_mul hμ0_abs exact hmul have hprod_div_int : Integrable (fun x => (prod1 x + prod0 x) / q) P.PX := by simpa [div_eq_mul_inv, mul_comm] using (hprod1_int.add hprod0_int).const_mul q⁻¹ have hmajor_int : Integrable major P.PX := by exact (hprod_div_int.add hset1_int).add hset0_int have hpoint : ∀ x, |(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x| ≤ major x := by intro x simpa [major, prod1, prod0, set1, set0, T] using policy_clipBias_abs_pointwise_le P q muHat0 muHat1 eHat π x hwf' hq hq_half have hnonneg_abs : 0 ≤ᵐ[P.PX] fun x => |(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x| := by filter_upwards with x exact abs_nonneg _ have hmajor_le : ∫ x, |(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x| ∂P.PX ≤ ∫ x, major x ∂P.PX := integral_mono_of_nonneg hnonneg_abs hmajor_int (Filter.Eventually.of_forall hpoint) have hprod1_bound : ∫ x, prod1 x ∂P.PX ≤ rE * rMu := by simpa [prod1, mul_comm] using l2_abs_product_integral_le heL2 hμ1L2 hse hsq1 hrE_nonneg hrMu_nonneg have hprod0_bound : ∫ x, prod0 x ∂P.PX ≤ rE * rMu := by simpa [prod0, mul_comm] using l2_abs_product_integral_le heL2 hμ0L2 hse hsq0 hrE_nonneg hrMu_nonneg have hprod_div_bound : ∫ x, (prod1 x + prod0 x) / q ∂P.PX ≤ (rE * rMu + rE * rMu) / q := by calc ∫ x, (prod1 x + prod0 x) / q ∂P.PX = (∫ x, prod1 x + prod0 x ∂P.PX) / q := by simp [div_eq_mul_inv] rw [integral_mul_const] _ = (∫ x, prod1 x ∂P.PX + ∫ x, prod0 x ∂P.PX) / q := by rw [integral_add hprod1_int hprod0_int] _ ≤ (rE * rMu + rE * rMu) / q := div_le_div_of_nonneg_right (add_le_add hprod1_bound hprod0_bound) hq.le have hset1_bound : ∫ x, set1 x ∂P.PX ≤ sqrt (P.PX.real T) * rMu := by simpa [set1] using l2_set_abs_integral_le (μ := P.PX) hTmeas hμ1L2 hsq1 hrMu_nonneg have hset0_bound : ∫ x, set0 x ∂P.PX ≤ sqrt (P.PX.real T) * rMu := by simpa [set0] using l2_set_abs_integral_le (μ := P.PX) hTmeas hμ0L2 hsq0 hrMu_nonneg have hmajor_bound : ∫ x, major x ∂P.PX ≤ (rE * rMu + rE * rMu) / q + sqrt (P.PX.real T) * rMu + sqrt (P.PX.real T) * rMu := by have hprod_set1_int : Integrable (fun x => (prod1 x + prod0 x) / q + set1 x) P.PX := hprod_div_int.add hset1_int have hmajor_eq : ∫ x, major x ∂P.PX = ∫ x, (prod1 x + prod0 x) / q ∂P.PX + ∫ x, set1 x ∂P.PX + ∫ x, set0 x ∂P.PX := by rw [show (fun x => major x) = (fun x => ((prod1 x + prod0 x) / q + set1 x) + set0 x) by funext x rfl] rw [integral_add hprod_set1_int hset0_int] rw [integral_add hprod_div_int hset1_int] calc ∫ x, major x ∂P.PX = ∫ x, (prod1 x + prod0 x) / q ∂P.PX + ∫ x, set1 x ∂P.PX + ∫ x, set0 x ∂P.PX := hmajor_eq _ ≤ (rE * rMu + rE * rMu) / q + sqrt (P.PX.real T) * rMu + sqrt (P.PX.real T) * rMu := by nlinarith [hprod_div_bound, hset1_bound, hset0_bound] calc |driftIntegral P q muHat0 muHat1 eHat π| = |∫ x, (boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x ∂P.PX| := rfl _ ≤ ∫ x, |(boolIndicator (π x) - boolIndicator (lawOptimalPolicy P x)) * clipBias P q muHat0 muHat1 eHat x| ∂P.PX := abs_integral_le_integral_abs _ ≤ ∫ x, major x ∂P.PX := hmajor_le _ ≤ (rE * rMu + rE * rMu) / q + sqrt (P.PX.real T) * rMu + sqrt (P.PX.real T) * rMu := hmajor_bound _ = 2 * (rMu * rE / q) + 2 * rMu * sqrt (P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q})) := by simp [T] ring
CausalSmith.Stat.PolicyRegretMarginOverlap.clipBias_drift_l2_mass_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:469
theorem sqrt_add_le_sqrt_add_sqrt Lemma sqrt_add_le_sqrt_add_sqrt in the paper ↗

The square root is subadditive: the square root of a sum of two nonnegative numbers is at most the sum of their square roots.

Formal statement
a b :
ha :
0 ≤ a
hb :
0 ≤ b
sqrt (a + b) ≤ sqrt a + sqrt b
Proof (Lean source)
lemma sqrt_add_le_sqrt_add_sqrt {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) : sqrt (a + b) ≤ sqrt a + sqrt b := by rw [Real.sqrt_le_iff] constructor · positivity · calc a + b ≤ (sqrt a) ^ 2 + (sqrt b) ^ 2 + 2 * sqrt a * sqrt b := by rw [Real.sq_sqrt ha, Real.sq_sqrt hb] nlinarith [Real.sqrt_nonneg a, Real.sqrt_nonneg b] _ = (sqrt a + sqrt b) ^ 2 := by ring
CausalSmith.Stat.PolicyRegretMarginOverlap.sqrt_add_le_sqrt_add_sqrt · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:640
theorem sqrt_margin_overlap_product Lemma sqrt_margin_overlap_product in the paper ↗

Taking the square root of the localized-mass bound distributes across its three positive factors and halves each exponent: the square root of a constant times the margin window raised to α times the clip level raised to 1/γ equals the square root of the constant times the window raised to α/2 times the clip level raised to 1/(2γ).

Formal statement
Creg u q α γ :
hC :
0 < Creg
hu :
0 < u
hq :
0 < q
sqrt (Creg * u ^ α * q ^ (1 / γ))
= Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ))
Proof (Lean source)
lemma sqrt_margin_overlap_product {Creg u q α γ : ℝ} (hC : 0 < Creg) (hu : 0 < u) (hq : 0 < q) : sqrt (Creg * u ^ α * q ^ (1 / γ)) = Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) := by have hCnn : 0 ≤ Creg := hC.le have hunn : 0 ≤ u := hu.le have hqnn : 0 ≤ q := hq.le calc sqrt (Creg * u ^ α * q ^ (1 / γ)) = (Creg * u ^ α * q ^ (1 / γ)) ^ (1 / 2 : ℝ) := by rw [Real.sqrt_eq_rpow] _ = (Creg * u ^ α) ^ (1 / 2 : ℝ) * (q ^ (1 / γ)) ^ (1 / 2 : ℝ) := by rw [Real.mul_rpow (mul_nonneg hCnn (Real.rpow_nonneg hunn _)) (Real.rpow_nonneg hqnn _)] _ = Creg ^ (1 / 2 : ℝ) * (u ^ α) ^ (1 / 2 : ℝ) * (q ^ (1 / γ)) ^ (1 / 2 : ℝ) := by rw [Real.mul_rpow hCnn (Real.rpow_nonneg hunn _)] _ = Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) := by rw [← Real.rpow_mul hunn, ← Real.rpow_mul hqnn] ring_nf
CausalSmith.Stat.PolicyRegretMarginOverlap.sqrt_margin_overlap_product · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:655
theorem clipBias_drift_l2_localized_from_region

Drift bound from a supplied localization estimate. Given as an input a bound on the mass of the clipped disagreement region of the form C u^α q^{1/γ} + R_P(π)/u, the policy-weighted clip-bias drift is at most 4 times the sum of the product-rate term r_μ r_e / q, the clipped-region term r_μ C^{1/2} u^{α/2} q^{1/(2γ)} and the regret-localization term r_μ (R_P(π)/u)^{1/2}. At the strict-overlap endpoint, where the overlap exponent is zero and the clip level is fixed at no more than half the overlap floor, the drift instead collapses to max(1, 2/q) times the product rate r_μ r_e. This is the form that takes the localization estimate as a hypothesis; the companion result derives that estimate itself from overlap decay and zero-effect regularity.

Formal statement
P :
q rMu rE α γ underlineP :
muHat0 muHat1 eHat :
𝒳 → ℝ
hsq0 :
∫ x, (muHat0 x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hsq1 :
∫ x, (muHat1 x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hse :
∫ x, (eHat x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2
hμ0L2 :
MemLp (fun x => muHat0 x - P.mu0 x) 2 P.PX
hμ1L2 :
MemLp (fun x => muHat1 x - P.mu1 x) 2 P.PX
heL2 :
MemLp (fun x => eHat x - P.propensity x) 2 P.PX
hrMu_nonneg :
0 ≤ rMu
hrE_nonneg :
0 ≤ rE
hwf :
hbdd :
hstrict :
StrictOverlapEndpoint P γ underlineP
hq :
0 < q
hq_half :
q ≤ 1 / 2
(∃ C0 : ℝ, 0 < C0 ∧ C0 = 4 ∧ ∀ (Creg : ℝ), 0 < Creg → ∀ π : Policy 𝒳, Measurable π → ∀ u : ℝ, 0 < u → 0 < γ → P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) ≤ Creg * u ^ α * q ^ (1 / γ) + lawRegret P π / u → |driftIntegral P q muHat0 muHat1 eHat π| ≤ C0 * (rMu * rE / q + rMu * Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ))) ∧
(∃ C1 : ℝ, 0 < C1 ∧ C1 = max 1 (2 / q) ∧ (γ = 0 → q ≤ underlineP / 2 → ∀ π : Policy 𝒳, Measurable π → |driftIntegral P q muHat0 muHat1 eHat π| ≤ C1 * (rMu * rE)))
Proof (Lean source)
-- @node: lem:clip-bias-drift-l2-localized-from-region lemma clipBias_drift_l2_localized_from_region (P : ObservedLaw 𝒳) (q rMu rE α γ underlineP : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (hsq0 : ∫ x, (muHat0 x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hsq1 : ∫ x, (muHat1 x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hse : ∫ x, (eHat x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2) (hμ0L2 : MemLp (fun x => muHat0 x - P.mu0 x) 2 P.PX) (hμ1L2 : MemLp (fun x => muHat1 x - P.mu1 x) 2 P.PX) (heL2 : MemLp (fun x => eHat x - P.propensity x) 2 P.PX) (hrMu_nonneg : 0 ≤ rMu) (hrE_nonneg : 0 ≤ rE) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hstrict : StrictOverlapEndpoint P γ underlineP) (hq : 0 < q) (hq_half : q ≤ 1 / 2) : (∃ C0 : ℝ, 0 < C0 ∧ C0 = 4 ∧ ∀ (Creg : ℝ), 0 < Creg → ∀ π : Policy 𝒳, Measurable π → ∀ u : ℝ, 0 < u → 0 < γ → P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) ≤ Creg * u ^ α * q ^ (1 / γ) + lawRegret P π / u → |driftIntegral P q muHat0 muHat1 eHat π| ≤ C0 * (rMu * rE / q + rMu * Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ))) ∧ (∃ C1 : ℝ, 0 < C1 ∧ C1 = max 1 (2 / q) ∧ (γ = 0 → q ≤ underlineP / 2 → ∀ π : Policy 𝒳, Measurable π → |driftIntegral P q muHat0 muHat1 eHat π| ≤ C1 * (rMu * rE))) := by refine ⟨?_, ?_⟩ · refine ⟨4, by norm_num, rfl, ?_⟩ intro Creg hCreg π hπ u hu hγpos hmass let M : ℝ := P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) let A : ℝ := rMu * rE / q let B : ℝ := Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) let T : ℝ := (lawRegret P π / u) ^ (1 / 2 : ℝ) have hcore := clipBias_drift_l2_mass_bound P q rMu rE muHat0 muHat1 eHat hsq0 hsq1 hse hμ0L2 hμ1L2 heL2 hrMu_nonneg hrE_nonneg hwf hq hq_half π hπ have hR_nonneg : 0 ≤ lawRegret P π := lawRegret_nonneg P π hwf hbdd hπ have hA_nonneg : 0 ≤ A := by exact div_nonneg (mul_nonneg hrMu_nonneg hrE_nonneg) hq.le have hB_nonneg : 0 ≤ B := by exact mul_nonneg (mul_nonneg (Real.rpow_nonneg hCreg.le _) (Real.rpow_nonneg hu.le _)) (Real.rpow_nonneg hq.le _) have hT_nonneg : 0 ≤ T := by exact Real.rpow_nonneg (div_nonneg hR_nonneg hu.le) _ have hsmall_nonneg : 0 ≤ Creg * u ^ α * q ^ (1 / γ) := by exact mul_nonneg (mul_nonneg hCreg.le (Real.rpow_nonneg hu.le _)) (Real.rpow_nonneg hq.le _) have hbig_nonneg : 0 ≤ lawRegret P π / u := div_nonneg hR_nonneg hu.le have hsqrt_mass : sqrt M ≤ B + T := by calc sqrt M ≤ sqrt (Creg * u ^ α * q ^ (1 / γ) + lawRegret P π / u) := Real.sqrt_le_sqrt (by simpa [M] using hmass) _ ≤ sqrt (Creg * u ^ α * q ^ (1 / γ)) + sqrt (lawRegret P π / u) := sqrt_add_le_sqrt_add_sqrt hsmall_nonneg hbig_nonneg _ = B + T := by rw [sqrt_margin_overlap_product hCreg hu hq, Real.sqrt_eq_rpow] have hcoef_nonneg : 0 ≤ 2 * rMu := by nlinarith have hcore_to_BT : |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * A + 2 * rMu * (B + T) := by have hsqrt_term : 2 * rMu * sqrt M ≤ 2 * rMu * (B + T) := by exact mul_le_mul_of_nonneg_left hsqrt_mass hcoef_nonneg have hcore' : |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * A + 2 * rMu * sqrt M := by simpa [A, M] using hcore nlinarith calc |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * A + 2 * rMu * (B + T) := hcore_to_BT _ ≤ 4 * (A + rMu * B + rMu * T) := by nlinarith [hA_nonneg, hB_nonneg, hT_nonneg, hrMu_nonneg] _ = 4 * (rMu * rE / q + rMu * Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ)) := by rw [show A = rMu * rE / q from rfl, show B = Creg ^ (1 / 2 : ℝ) * u ^ (α / 2) * q ^ (1 / (2 * γ)) from rfl, show T = (lawRegret P π / u) ^ (1 / 2 : ℝ) from rfl] ring_nf · let C : ℝ := max 1 (2 / q) have hCpos : 0 < C := lt_of_lt_of_le zero_lt_one (le_max_left _ _) refine ⟨C, hCpos, rfl, ?_⟩ intro hγ0 hq_under π hπ let M : ℝ := P.PX.real (disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q}) have hcore := clipBias_drift_l2_mass_bound P q rMu rE muHat0 muHat1 eHat hsq0 hsq1 hse hμ0L2 hμ1L2 heL2 hrMu_nonneg hrE_nonneg hwf hq hq_half π hπ letI : IsProbabilityMeasure P.PX := hwf.2.1 rcases hstrict hγ0 with ⟨hunderline_pos, _hunderline_le, hunderline_ae⟩ let S : Set 𝒳 := disagreementSet π (lawOptimalPolicy P) ∩ {x | overlap P x ≤ q} have hS_zero : P.PX.real S = 0 := by apply (measureReal_eq_zero_iff (μ := P.PX) (s := S) (measure_ne_top P.PX S)).2 apply measure_eq_zero_iff_ae_notMem.2 filter_upwards [hunderline_ae] with x hx_under hxS rcases hxS with ⟨_hxD, hxlow⟩ have hxlow' : overlap P x ≤ q := hxlow have hq_lt_under : q < underlineP := by linarith linarith have hcore_zero : |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * (rMu * rE / q) := by have hcore' : |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * (rMu * rE / q) + 2 * rMu * sqrt (P.PX.real S) := by simpa [S] using hcore simpa [hS_zero] using hcore' have hprod_nonneg : 0 ≤ rMu * rE := mul_nonneg hrMu_nonneg hrE_nonneg have hCge : 2 / q ≤ C := by exact le_max_right _ _ calc |driftIntegral P q muHat0 muHat1 eHat π| ≤ 2 * (rMu * rE / q) := hcore_zero _ = (2 / q) * (rMu * rE) := by ring _ ≤ C * (rMu * rE) := mul_le_mul_of_nonneg_right hCge hprod_nonneg
CausalSmith.Stat.PolicyRegretMarginOverlap.clipBias_drift_l2_localized_from_region · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:682
theorem localized_clipped_drift_bound Lemma 7 in the paper ↗

Deterministic bound on the policy-weighted clip-bias drift — the population average of the clipped-AIPW conditional-mean error weighted by the disagreement between the candidate policy and the law-optimal policy — in BOTH overlap regimes.

Formal statement
P :
policySet :
Set (Policy 𝒳)
q rMu rE α γ Co co u0 underlineP :
muHat0 muHat1 eHat :
𝒳 → ℝ
hsq0 :
∫ x, (muHat0 x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hsq1 :
∫ x, (muHat1 x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hse :
∫ x, (eHat x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2
regularity: L² nuisance-error functions are genuine Bochner/MemLp inputs for the Cauchy-Schwarz step; this is intrinsic to the stated L² rates.
hμ0L2 :
MemLp (fun x => muHat0 x - P.mu0 x) 2 P.PX
hμ1L2 :
MemLp (fun x => muHat1 x - P.mu1 x) 2 P.PX
heL2 :
MemLp (fun x => eHat x - P.propensity x) 2 P.PX
regularity: nuisance rates are nonnegative radii (NuisanceRate / PolynomialNuisanceExponents bookkeeping in the note).
hrMu_nonneg :
0 ≤ rMu
hrE_nonneg :
0 ≤ rE
regularity: standing observed-law setup needed for welfare identity, strict-overlap projection, and measurable disagreement sets.
hwf :
regularity: policy measurability needed by `clipped_region_localization`.
hπmeas :
∀ π ∈ policySet, Measurable π
regularity: `q` is a clipping level, so denominators obey `q ≤ ē_q ≤ 1-q`; the note's selected clips satisfy this.
hq_half :
q ≤ 1 / 2
hod :
OverlapDecay P u0 Co co α γ
hze :
ZeroEffectRegular P policySet
hbdd :
hstrict :
StrictOverlapEndpoint P γ underlineP
hq :
0 < q
(∃ C0 : ℝ, 0 < C0 ∧ C0 = 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) ∧ (0 < γ → ∀ π ∈ policySet, ∀ u : ℝ, 0 < u → u ≤ u0 → q ≤ co * u ^ γ → |driftIntegral P q muHat0 muHat1 eHat π| ≤ C0 * (rMu * rE / q + rMu * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ)))) ∧
(∃ C1 : ℝ, 0 < C1 ∧ C1 = max 1 (2 / q) ∧ (γ = 0 → q ≤ underlineP / 2 → ∀ π ∈ policySet, |driftIntegral P q muHat0 muHat1 eHat π| ≤ C1 * (rMu * rE)))
Proof (Lean source)
lemma localized_clipped_drift_bound (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (q rMu rE α γ Co co u0 underlineP : ℝ) (muHat0 muHat1 eHat : 𝒳 → ℝ) (hsq0 : ∫ x, (muHat0 x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hsq1 : ∫ x, (muHat1 x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hse : ∫ x, (eHat x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2) -- regularity: L² nuisance-error functions are genuine Bochner/MemLp inputs -- for the Cauchy-Schwarz step; this is intrinsic to the stated L² rates. (hμ0L2 : MemLp (fun x => muHat0 x - P.mu0 x) 2 P.PX) (hμ1L2 : MemLp (fun x => muHat1 x - P.mu1 x) 2 P.PX) (heL2 : MemLp (fun x => eHat x - P.propensity x) 2 P.PX) -- regularity: nuisance rates are nonnegative radii (NuisanceRate / -- PolynomialNuisanceExponents bookkeeping in the note). (hrMu_nonneg : 0 ≤ rMu) (hrE_nonneg : 0 ≤ rE) -- regularity: standing observed-law setup needed for welfare identity, -- strict-overlap projection, and measurable disagreement sets. (hwf : WellFormedLaw P) -- regularity: policy measurability needed by `clipped_region_localization`. (hπmeas : ∀ π ∈ policySet, Measurable π) -- regularity: `q` is a clipping level, so denominators obey -- `q ≤ ē_q ≤ 1-q`; the note's selected clips satisfy this. (hq_half : q ≤ 1 / 2) (hod : OverlapDecay P u0 Co co α γ) (hze : ZeroEffectRegular P policySet) (hbdd : BoundedOutcome P) (hstrict : StrictOverlapEndpoint P γ underlineP) (hq : 0 < q) : (∃ C0 : ℝ, 0 < C0 ∧ C0 = 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) ∧ (0 < γ → ∀ π ∈ policySet, ∀ u : ℝ, 0 < u → u ≤ u0 → q ≤ co * u ^ γ → |driftIntegral P q muHat0 muHat1 eHat π| ≤ C0 * (rMu * rE / q + rMu * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ)))) ∧ (∃ C1 : ℝ, 0 < C1 ∧ C1 = max 1 (2 / q) ∧ (γ = 0 → q ≤ underlineP / 2 → ∀ π ∈ policySet, |driftIntegral P q muHat0 muHat1 eHat π| ≤ C1 * (rMu * rE))) := by rcases clipBias_drift_l2_localized_from_region P q rMu rE α γ underlineP muHat0 muHat1 eHat hsq0 hsq1 hse hμ0L2 hμ1L2 heL2 hrMu_nonneg hrE_nonneg hwf hbdd hstrict hq hq_half with ⟨⟨Cdrift, hCdrift, hCdrift_eq, hregionDrift⟩, ⟨Cstrict, hCstrict, hCstrict_eq, hstrictDrift⟩⟩ let Cpos : ℝ := 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) let S : ℝ := (max Co 1) ^ (1 / 2 : ℝ) have hCreg : 0 < max Co 1 := lt_of_lt_of_le zero_lt_one (le_max_right Co 1) have hS_nonneg : 0 ≤ S := Real.rpow_nonneg hCreg.le _ have hfactor_pos : 0 < 1 + S := by nlinarith have hCpos : 0 < Cpos := by dsimp [Cpos, S] nlinarith refine ⟨⟨Cpos, hCpos, rfl, ?_⟩, ⟨Cstrict, hCstrict, hCstrict_eq, ?_⟩⟩ · intro hγpos π hπmem u hu hu_le hq_le rcases clipped_region_localization P policySet Co co α γ u0 hod hze hbdd hwf hπmeas hγpos with ⟨_hCreg_loc, hloc⟩ have hπ : Measurable π := hπmeas π hπmem have hmass := hloc π hπmem u q hu hu_le hq hq_le have hbase := hregionDrift (max Co 1) hCreg π hπ u hu hγpos hmass let A : ℝ := rMu * rE / q let B : ℝ := u ^ (α / 2) * q ^ (1 / (2 * γ)) let T : ℝ := (lawRegret P π / u) ^ (1 / 2 : ℝ) have hA_nonneg : 0 ≤ A := by exact div_nonneg (mul_nonneg hrMu_nonneg hrE_nonneg) hq.le have hB_nonneg : 0 ≤ B := by exact mul_nonneg (Real.rpow_nonneg hu.le _) (Real.rpow_nonneg hq.le _) have hR_nonneg : 0 ≤ lawRegret P π := lawRegret_nonneg P π hwf hbdd hπ have hT_nonneg : 0 ≤ T := by exact Real.rpow_nonneg (div_nonneg hR_nonneg hu.le) _ have hY_nonneg : 0 ≤ rMu * B := mul_nonneg hrMu_nonneg hB_nonneg have hZ_nonneg : 0 ≤ rMu * T := mul_nonneg hrMu_nonneg hT_nonneg have hinside : A + rMu * S * B + rMu * T ≤ (1 + S) * (A + rMu * B + rMu * T) := by nlinarith [hA_nonneg, hY_nonneg, hZ_nonneg, hS_nonneg] calc |driftIntegral P q muHat0 muHat1 eHat π| ≤ 4 * (A + rMu * S * B + rMu * T) := by simpa [A, B, T, S, hCdrift_eq, mul_assoc, mul_left_comm, mul_comm] using hbase _ ≤ 4 * ((1 + S) * (A + rMu * B + rMu * T)) := mul_le_mul_of_nonneg_left hinside (by norm_num) _ = Cpos * (rMu * rE / q + rMu * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ)) := by simp [A, B, T, Cpos, S] ring · intro hγ0 hq_le π hπmem exact hstrictDrift hγ0 hq_le π (hπmeas π hπmem)
CausalSmith.Stat.PolicyRegretMarginOverlap.localized_clipped_drift_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/DriftBound.lean:811
Helpers.FeasibleERM 5 declarations Provides measurable evaluation and feasible ERM helper lemmas.

Provides measurable evaluation and feasible ERM helper lemmas.

theorem feasible_erm_basic_inequality Lemma 5 in the paper ↗

lem:feasible-erm-basic-inequality. The feasible ERM (enum-skeleton, foldwise cross-fit) is a MEASURABLE Π-valued estimator: it is Π-valued for every realized sample, the induced regret map sample ↦ R_P(π̂_n(sample)) is measurable (so the U_n/M_n integrals are well-defined), and against EVERY comparator π^b ∈ Π the 1/n basic inequality holds; under OptimalInClass it applies in particular to π^b = π_⋆. The comparator inequality over ALL of Π is load-bearing on enum being a POINTWISE-DENSE skeleton of Π (the countable Π₀ of ass:policy-class that def:feasible-erm fixes): hdense says every π ∈ Π is a pointwise limit of enum-indexed policies, which is what reduces sup_Π V̂ to sup_j V̂(enum j). Without it the bare henum : enum j ∈ Π would not license the Π-wide near-maximality.

Formal statement
n K :
P :
q :
enum :
ℕ → Policy 𝒳
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
dPi :
hvc :
PolicyClassVC policySet dPi
_hopt :
OptimalInClass P policySet
henum :
∀ j, enum j ∈ policySet
hdense :
∀ π ∈ policySet, ∃ seq : ℕ → ℕ, ∀ x, ∀ᶠ j in atTop, enum (seq j) x = π x
regularity: measurable foldwise plug-in estimators
hμ0meas :
∀ k : Fin K, Measurable (muHat0 k)
hμ1meas :
∀ k : Fin K, Measurable (muHat1 k)
hemeas :
∀ k : Fin K, Measurable (eHat k)
hn :
0 < n
Measurable (fun s : Fin n → Observation 𝒳 => lawRegret P (feasibleERM q enum muHat0 muHat1 eHat assign s)) ∧
∀ sample : Fin n → Observation 𝒳,
feasibleERM q enum muHat0 muHat1 eHat assign sample ∈ policySet ∧
∀ πb ∈ policySet,
empiricalWelfareScore q muHat0 muHat1 eHat assign sample πb
empiricalWelfareScore q muHat0 muHat1 eHat assign sample (feasibleERM q enum muHat0 muHat1 eHat assign sample)
+ (n : ℝ)⁻¹
Proof (Lean source)
lemma feasible_erm_basic_inequality {n K : ℕ} (P : ObservedLaw 𝒳) (q : ℝ) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (dPi : ℕ) (hvc : PolicyClassVC policySet dPi) (_hopt : OptimalInClass P policySet) (henum : ∀ j, enum j ∈ policySet) (hdense : ∀ π ∈ policySet, ∃ seq : ℕ → ℕ, ∀ x, ∀ᶠ j in atTop, enum (seq j) x = π x) -- regularity: measurable foldwise plug-in estimators (hμ0meas : ∀ k : Fin K, Measurable (muHat0 k)) (hμ1meas : ∀ k : Fin K, Measurable (muHat1 k)) (hemeas : ∀ k : Fin K, Measurable (eHat k)) (hn : 0 < n) : Measurable (fun s : Fin n → Observation 𝒳 => lawRegret P (feasibleERM q enum muHat0 muHat1 eHat assign s)) ∧ ∀ sample : Fin n → Observation 𝒳, feasibleERM q enum muHat0 muHat1 eHat assign sample ∈ policySet ∧ ∀ πb ∈ policySet, empiricalWelfareScore q muHat0 muHat1 eHat assign sample πb ≤ empiricalWelfareScore q muHat0 muHat1 eHat assign sample (feasibleERM q enum muHat0 muHat1 eHat assign sample) + (n : ℝ)⁻¹ := by classical have hπmeas : ∀ π ∈ policySet, Measurable π := hvc.1 let score : ℕ → (Fin n → Observation 𝒳) → ℝ := fun j sample => empiricalWelfareScore q muHat0 muHat1 eHat assign sample (enum j) let near : (Fin n → Observation 𝒳) → ℕ → Prop := fun sample j => ∀ j' : ℕ, score j' sample ≤ score j sample + (n : ℝ)⁻¹ let sel : (Fin n → Observation 𝒳) → ℕ := fun sample => sInf {j : ℕ | near sample j} have hscore_meas : ∀ j, Measurable (score j) := by intro j exact measurable_empiricalWelfareScore_sample q muHat0 muHat1 eHat assign hμ0meas hμ1meas hemeas (enum j) (hπmeas (enum j) (henum j)) have hnear_meas : ∀ j, MeasurableSet {sample : Fin n → Observation 𝒳 | near sample j} := by intro j have hInter : MeasurableSet (⋂ j' : ℕ, {sample : Fin n → Observation 𝒳 | score j' sample ≤ score j sample + (n : ℝ)⁻¹}) := by exact MeasurableSet.iInter (fun j' => measurableSet_le (hscore_meas j') ((hscore_meas j).add measurable_const)) simpa [near, Set.setOf_forall] using hInter have hsel_fiber : ∀ j, MeasurableSet {sample : Fin n → Observation 𝒳 | sel sample = j} := by intro j have hlower_meas : MeasurableSet {sample : Fin n → Observation 𝒳 | ∀ k : ℕ, k < j → ¬ near sample k} := by have hInter : MeasurableSet (⋂ k : ℕ, {sample : Fin n → Observation 𝒳 | k < j → ¬ near sample k}) := by exact MeasurableSet.iInter (fun k => by by_cases hk : k < j · have hc : MeasurableSet ({sample : Fin n → Observation 𝒳 | near sample k}ᶜ) := (hnear_meas k).compl simpa [hk, Set.compl_setOf] using hc · simp [hk]) simpa [Set.setOf_forall] using hInter have hchar : {sample : Fin n → Observation 𝒳 | sel sample = j} = {sample : Fin n → Observation 𝒳 | near sample j ∧ ∀ k : ℕ, k < j → ¬ near sample k} := by ext sample let A : Set ℕ := {m : ℕ | near sample m} have hAne : A.Nonempty := by simpa [A, near, score] using (feasibleERM_nearSet_nonempty q enum muHat0 muHat1 eHat assign sample hn) constructor · intro hsel_eq change sel sample = j at hsel_eq constructor · have hs : near sample (sel sample) := by simpa [sel, A] using (Nat.sInf_mem hAne) rw [hsel_eq] at hs exact hs · intro k hklt hknear have hle : sInf A ≤ k := Nat.sInf_le (by simpa [A] using hknear) have hjle : j ≤ k := by simpa [sel, A, hsel_eq] using hle exact (not_lt_of_ge hjle) hklt · intro h change near sample j ∧ (∀ k : ℕ, k < j → ¬ near sample k) at h rcases h with ⟨hjnear, hno⟩ change sInf A = j apply le_antisymm · exact Nat.sInf_le (by simpa [A] using hjnear) · apply le_of_not_gt intro hlt have hsinf_mem : sInf A ∈ A := Nat.sInf_mem hAne exact (hno (sInf A) hlt) (by simpa [A] using hsinf_mem) rw [hchar] exact (hnear_meas j).inter hlower_meas have hsel_meas : Measurable sel := measurable_to_countable' hsel_fiber have hreg_index : Measurable (fun j : ℕ => lawRegret P (enum j)) := measurable_of_countable (fun j : ℕ => lawRegret P (enum j)) constructor · exact hreg_index.comp hsel_meas · intro sample let nearSample : ℕ → Prop := fun j => ∀ j' : ℕ, empiricalWelfareScore q muHat0 muHat1 eHat assign sample (enum j') ≤ empiricalWelfareScore q muHat0 muHat1 eHat assign sample (enum j) + (n : ℝ)⁻¹ have hnear_nonempty : ({j : ℕ | nearSample j}).Nonempty := by simpa [nearSample] using (feasibleERM_nearSet_nonempty q enum muHat0 muHat1 eHat assign sample hn) have hselected_near : nearSample (sInf {j : ℕ | nearSample j}) := Nat.sInf_mem hnear_nonempty constructor · simpa [feasibleERM, nearSample] using henum (sInf {j : ℕ | nearSample j}) · intro πb hπb rcases hdense πb hπb with ⟨seq, hseq⟩ have htrace : ∀ᶠ t in atTop, ∀ i : Fin n, enum (seq t) (sample i).X = πb (sample i).X := by exact Filter.eventually_all.2 (fun i => hseq (sample i).X) rcases htrace.exists with ⟨t, ht⟩ have hscore_eq : empiricalWelfareScore q muHat0 muHat1 eHat assign sample (enum (seq t)) = empiricalWelfareScore q muHat0 muHat1 eHat assign sample πb := by simp [empiricalWelfareScore, ht] have hineq := hselected_near (seq t) rw [hscore_eq] at hineq simpa [feasibleERM, nearSample] using hineq
CausalSmith.Stat.PolicyRegretMarginOverlap.feasible_erm_basic_inequality · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/FeasibleERM.lean:123
theorem crude_clipped_score_envelope Lemma 6 in the paper ↗

lem:crude-clipped-score-envelope. Crude q^{-1} envelope of the clipped AIPW score from clipped denominators and bounded outcomes/nuisances.

Formal statement
P :
muHat0 muHat1 eHat :
𝒳 → ℝ
q :
hbdd :
hbn :
∀ x, muHat0 x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 x ∈ Icc (-1 : ℝ) 1
hq :
0 < q
hq1 :
q ≤ 1 / 2
∃ C : ℝ,
0 < C ∧
(∀ᵐ O ∂P.dataMeasure, |clippedAIPWScore q muHat0 muHat1 eHat O| ≤ C / q) ∧
(∀ᵐ O ∂P.dataMeasure, (clippedAIPWScore q muHat0 muHat1 eHat O) ^ 2 ≤ C / q ^ 2)
Proof (Lean source)
lemma crude_clipped_score_envelope (P : ObservedLaw 𝒳) (muHat0 muHat1 eHat : 𝒳 → ℝ) (q : ℝ) (hbdd : BoundedOutcome P) (hbn : ∀ x, muHat0 x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 x ∈ Icc (-1 : ℝ) 1) (hq : 0 < q) (hq1 : q ≤ 1 / 2) : ∃ C : ℝ, 0 < C ∧ (∀ᵐ O ∂P.dataMeasure, |clippedAIPWScore q muHat0 muHat1 eHat O| ≤ C / q) ∧ (∀ᵐ O ∂P.dataMeasure, (clippedAIPWScore q muHat0 muHat1 eHat O) ^ 2 ≤ C / q ^ 2) := by refine ⟨36, by norm_num, ?_, ?_⟩ · filter_upwards [hbdd.1] with O hY let cp := clippedPropensity q eHat O.X have hcp_bounds : q ≤ cp ∧ cp ≤ 1 - q := by unfold cp clippedPropensity constructor · apply le_min · nlinarith · exact le_max_left q (eHat O.X) · exact min_le_left (1 - q) (max q (eHat O.X)) have hcp_pos : 0 < cp := lt_of_lt_of_le hq hcp_bounds.1 have hcp2_pos : 0 < 1 - cp := by nlinarith [hq, hcp_bounds.2] have h_inv_cp : cp⁻¹ ≤ q⁻¹ := by rw [inv_le_inv₀ hcp_pos hq] exact hcp_bounds.1 have h_q_le_omcp : q ≤ 1 - cp := by nlinarith [hcp_bounds.2] have h_inv_omcp : (1 - cp)⁻¹ ≤ q⁻¹ := by rw [inv_le_inv₀ hcp2_pos hq] exact h_q_le_omcp have hbool_abs : |boolIndicator O.A| ≤ (1 : ℝ) := by cases O.A <;> simp [boolIndicator] have hone_minus_bool_abs : |1 - boolIndicator O.A| ≤ (1 : ℝ) := by cases O.A <;> simp [boolIndicator] have h_abs_of_Icc : ∀ z : ℝ, z ∈ Icc (-1 : ℝ) 1 → |z| ≤ (1 : ℝ) := by intro z hz exact abs_le.mpr ⟨hz.1, hz.2⟩ have hYabs : |O.Y| ≤ (1 : ℝ) := h_abs_of_Icc O.Y hY have hmu0abs : |muHat0 O.X| ≤ (1 : ℝ) := h_abs_of_Icc (muHat0 O.X) (hbn O.X).1 have hmu1abs : |muHat1 O.X| ≤ (1 : ℝ) := h_abs_of_Icc (muHat1 O.X) (hbn O.X).2 have hcontrast : |muHat1 O.X - muHat0 O.X| ≤ (2 : ℝ) := by calc |muHat1 O.X - muHat0 O.X| ≤ |muHat1 O.X| + |muHat0 O.X| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1abs hmu0abs _ = (2 : ℝ) := by norm_num have hdiff1 : |O.Y - muHat1 O.X| ≤ (2 : ℝ) := by calc |O.Y - muHat1 O.X| ≤ |O.Y| + |muHat1 O.X| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hYabs hmu1abs _ = (2 : ℝ) := by norm_num have hdiff0 : |O.Y - muHat0 O.X| ≤ (2 : ℝ) := by calc |O.Y - muHat0 O.X| ≤ |O.Y| + |muHat0 O.X| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hYabs hmu0abs _ = (2 : ℝ) := by norm_num have hterm1 : |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| ≤ 2 / q := by calc |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| = |boolIndicator O.A| * cp⁻¹ * |O.Y - muHat1 O.X| := by rw [abs_mul, abs_div, abs_of_pos hcp_pos, div_eq_mul_inv] _ ≤ 1 * q⁻¹ * 2 := by gcongr _ = 2 / q := by ring have hterm0 : |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ 2 / q := by calc |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| = |1 - boolIndicator O.A| * (1 - cp)⁻¹ * |O.Y - muHat0 O.X| := by rw [abs_mul, abs_div, abs_of_pos hcp2_pos, div_eq_mul_inv] _ ≤ 1 * q⁻¹ * 2 := by gcongr _ = 2 / q := by ring unfold clippedAIPWScore change |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ 36 / q have htri : |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ |muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := by calc |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := abs_sub _ _ _ ≤ (|muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)|) + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := by gcongr exact abs_add_le _ _ _ = |muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := by ring calc |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ |muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := htri _ ≤ 2 + 2 / q + 2 / q := by gcongr _ ≤ 36 / q := by have h2le : (2 : ℝ) ≤ 2 / q := by rw [le_div_iff₀ hq] nlinarith [hq1] calc 2 + 2 / q + 2 / q ≤ 2 / q + 2 / q + 2 / q := by linarith _ = 6 / q := by ring _ ≤ 36 / q := by gcongr; norm_num · filter_upwards [hbdd.1] with O hY have hscore : |clippedAIPWScore q muHat0 muHat1 eHat O| ≤ 6 / q := by let cp := clippedPropensity q eHat O.X have hcp_bounds : q ≤ cp ∧ cp ≤ 1 - q := by unfold cp clippedPropensity constructor · apply le_min · nlinarith · exact le_max_left q (eHat O.X) · exact min_le_left (1 - q) (max q (eHat O.X)) have hcp_pos : 0 < cp := lt_of_lt_of_le hq hcp_bounds.1 have hcp2_pos : 0 < 1 - cp := by nlinarith [hq, hcp_bounds.2] have h_inv_cp : cp⁻¹ ≤ q⁻¹ := by rw [inv_le_inv₀ hcp_pos hq] exact hcp_bounds.1 have h_q_le_omcp : q ≤ 1 - cp := by nlinarith [hcp_bounds.2] have h_inv_omcp : (1 - cp)⁻¹ ≤ q⁻¹ := by rw [inv_le_inv₀ hcp2_pos hq] exact h_q_le_omcp have hbool_abs : |boolIndicator O.A| ≤ (1 : ℝ) := by cases O.A <;> simp [boolIndicator] have hone_minus_bool_abs : |1 - boolIndicator O.A| ≤ (1 : ℝ) := by cases O.A <;> simp [boolIndicator] have h_abs_of_Icc : ∀ z : ℝ, z ∈ Icc (-1 : ℝ) 1 → |z| ≤ (1 : ℝ) := by intro z hz exact abs_le.mpr ⟨hz.1, hz.2⟩ have hYabs : |O.Y| ≤ (1 : ℝ) := h_abs_of_Icc O.Y hY have hmu0abs : |muHat0 O.X| ≤ (1 : ℝ) := h_abs_of_Icc (muHat0 O.X) (hbn O.X).1 have hmu1abs : |muHat1 O.X| ≤ (1 : ℝ) := h_abs_of_Icc (muHat1 O.X) (hbn O.X).2 have hcontrast : |muHat1 O.X - muHat0 O.X| ≤ (2 : ℝ) := by calc |muHat1 O.X - muHat0 O.X| ≤ |muHat1 O.X| + |muHat0 O.X| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1abs hmu0abs _ = (2 : ℝ) := by norm_num have hdiff1 : |O.Y - muHat1 O.X| ≤ (2 : ℝ) := by calc |O.Y - muHat1 O.X| ≤ |O.Y| + |muHat1 O.X| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hYabs hmu1abs _ = (2 : ℝ) := by norm_num have hdiff0 : |O.Y - muHat0 O.X| ≤ (2 : ℝ) := by calc |O.Y - muHat0 O.X| ≤ |O.Y| + |muHat0 O.X| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hYabs hmu0abs _ = (2 : ℝ) := by norm_num have hterm1 : |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| ≤ 2 / q := by calc |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| = |boolIndicator O.A| * cp⁻¹ * |O.Y - muHat1 O.X| := by rw [abs_mul, abs_div, abs_of_pos hcp_pos, div_eq_mul_inv] _ ≤ 1 * q⁻¹ * 2 := by gcongr _ = 2 / q := by ring have hterm0 : |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ 2 / q := by calc |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| = |1 - boolIndicator O.A| * (1 - cp)⁻¹ * |O.Y - muHat0 O.X| := by rw [abs_mul, abs_div, abs_of_pos hcp2_pos, div_eq_mul_inv] _ ≤ 1 * q⁻¹ * 2 := by gcongr _ = 2 / q := by ring unfold clippedAIPWScore change |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ 6 / q have htri : |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ |muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := by calc |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := abs_sub _ _ _ ≤ (|muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)|) + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := by gcongr exact abs_add_le _ _ _ = |muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := by ring calc |muHat1 O.X - muHat0 O.X + (boolIndicator O.A / cp) * (O.Y - muHat1 O.X) - ((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| ≤ |muHat1 O.X - muHat0 O.X| + |(boolIndicator O.A / cp) * (O.Y - muHat1 O.X)| + |((1 - boolIndicator O.A) / (1 - cp)) * (O.Y - muHat0 O.X)| := htri _ ≤ 2 + 2 / q + 2 / q := by gcongr _ ≤ 6 / q := by have h2le : (2 : ℝ) ≤ 2 / q := by rw [le_div_iff₀ hq] nlinarith [hq1] calc 2 + 2 / q + 2 / q ≤ 2 / q + 2 / q + 2 / q := by linarith _ = 6 / q := by ring have hnon : 0 ≤ 6 / q := div_nonneg (by norm_num) hq.le have hs : (clippedAIPWScore q muHat0 muHat1 eHat O) ^ 2 ≤ (6 / q) ^ 2 := by rw [← sq_abs (clippedAIPWScore q muHat0 muHat1 eHat O)] exact sq_le_sq.mpr (by simpa [abs_of_nonneg (abs_nonneg _), abs_of_nonneg hnon] using hscore) have hcalc : (6 / q) ^ 2 = (36 : ℝ) / q ^ 2 := by ring simpa [hcalc] using hs
CausalSmith.Stat.PolicyRegretMarginOverlap.crude_clipped_score_envelope · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/FeasibleERM.lean:261
theorem pooledOffsetSup_trunc_eq_original_ae_36

Truncating the clipped-AIPW score at level 36/q leaves the offset supremum of the pooled cross-fit process unchanged, almost surely under the sample's product law.

Formal statement
n K :
P :
q :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
hwf :
hbdd :
hbn :
∀ k : Fin K, ∀ x, muHat0 k x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 k x ∈ Icc (-1 : ℝ) 1
hq :
0 < q
hq1 :
q ≤ 1 / 2
(fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P (clippedPolicyIncrementTrunc P q ((36 : ℝ) / q) muHat0 muHat1 eHat) assign sample π| - lawRegret P π / 4)) '' policySet))
=ᵐ[Measure.pi (fun _ : Fin n => P.dataMeasure)] (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign sample π| - lawRegret P π / 4)) '' policySet))
Proof (Lean source)
lemma pooledOffsetSup_trunc_eq_original_ae_36 {n K : ℕ} (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hbn : ∀ k : Fin K, ∀ x, muHat0 k x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 k x ∈ Icc (-1 : ℝ) 1) (hq : 0 < q) (hq1 : q ≤ 1 / 2) : (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P (clippedPolicyIncrementTrunc P q ((36 : ℝ) / q) muHat0 muHat1 eHat) assign sample π| - lawRegret P π / 4)) '' policySet)) =ᵐ[Measure.pi (fun _ : Fin n => P.dataMeasure)] (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign sample π| - lawRegret P π / 4)) '' policySet)) := by classical letI : IsProbabilityMeasure P.dataMeasure := hwf.1 let B : ℝ := (36 : ℝ) / q let gT : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat let g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrement P q muHat0 muHat1 eHat let μn : Measure (Fin n → Observation 𝒳) := Measure.pi (fun _ : Fin n => P.dataMeasure) have hscore_ae : ∀ k : Fin K, ∀ᵐ O ∂P.dataMeasure, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O| ≤ B := by intro k simpa [B] using crude_clipped_score_abs_ae_36 P (muHat0 k) (muHat1 k) (eHat k) q hbdd (hbn k) hq hq1 have hcoord : ∀ (i : Fin n) (k : Fin K), ∀ᵐ sample ∂μn, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i)| ≤ B := by intro i k let S : Set (Observation 𝒳) := {O | ¬ |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O| ≤ B} have hS_zero : P.dataMeasure S = 0 := by apply measure_eq_zero_iff_ae_notMem.2 filter_upwards [hscore_ae k] with O hO simpa [S] using hO have hpre_zero : μn (Function.eval i ⁻¹' S) = 0 := by simpa [μn] using (Measure.pi_eval_preimage_null (μ := fun _ : Fin n => P.dataMeasure) (i := i) hS_zero) have hae_not : ∀ᵐ sample ∂μn, sample i ∉ S := measure_eq_zero_iff_ae_notMem.mp hpre_zero filter_upwards [hae_not] with sample hs simpa [S] using hs have hsample_good : ∀ᵐ sample ∂μn, ∀ i : Fin n, ∀ k : Fin K, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i)| ≤ B := Filter.eventually_all.2 (fun i => Filter.eventually_all.2 (fun k => hcoord i k)) have hmean_eq : ∀ (k : Fin K) (π : Policy 𝒳), ∫ O, gT k π O ∂P.dataMeasure = ∫ O, g k π O ∂P.dataMeasure := by intro k π apply integral_congr_ae filter_upwards [hscore_ae k] with O hO have hclip : clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O = clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O := by simpa [clippedScoreTrunc] using clipReal_eq_self_of_abs_le (B := B) (z := clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O) hO simp [gT, g, clippedPolicyIncrementTrunc, clippedPolicyIncrement, hclip] have hprocess_eq : ∀ sample : Fin n → Observation 𝒳, (∀ i : Fin n, ∀ k : Fin K, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i)| ≤ B) → ∀ π : Policy 𝒳, pooledCrossfitProcess P gT assign sample π = pooledCrossfitProcess P g assign sample π := by intro sample hgood π dsimp [pooledCrossfitProcess] congr 1 apply Finset.sum_congr rfl intro i _hi have hclip : clippedScoreTrunc q B (muHat0 (assign i)) (muHat1 (assign i)) (eHat (assign i)) (sample i) = clippedAIPWScore q (muHat0 (assign i)) (muHat1 (assign i)) (eHat (assign i)) (sample i) := by simpa [clippedScoreTrunc] using clipReal_eq_self_of_abs_le (B := B) (z := clippedAIPWScore q (muHat0 (assign i)) (muHat1 (assign i)) (eHat (assign i)) (sample i)) (hgood i (assign i)) have hterm : gT (assign i) π (sample i) = g (assign i) π (sample i) := by simp [gT, g, clippedPolicyIncrementTrunc, clippedPolicyIncrement, hclip] rw [hterm, hmean_eq (assign i) π] filter_upwards [hsample_good] with sample hgood have hproc := hprocess_eq sample hgood have hset : ((fun π => max 0 (2 * |pooledCrossfitProcess P gT assign sample π| - lawRegret P π / 4)) '' policySet) = ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet) := by ext y constructor · rintro ⟨π, hπ, rfl⟩ refine ⟨π, hπ, ?_⟩ change max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4) = max 0 (2 * |pooledCrossfitProcess P gT assign sample π| - lawRegret P π / 4) rw [← hproc π] · rintro ⟨π, hπ, rfl⟩ refine ⟨π, hπ, ?_⟩ change max 0 (2 * |pooledCrossfitProcess P gT assign sample π| - lawRegret P π / 4) = max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4) rw [hproc π] change sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P gT assign sample π| - lawRegret P π / 4)) '' policySet) = sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet) rw [hset]
CausalSmith.Stat.PolicyRegretMarginOverlap.pooledOffsetSup_trunc_eq_original_ae_36 · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/FeasibleERM.lean:607
theorem expectedPooledOffsetSup_trunc_eq_original_ae_36

The EXPECTED pooled cross-fit offset supremum is the same for the score truncated at level 36/q and for the untruncated score, under bounded outcomes and cross-fitted regressions valued in [-1,1] — the integrated form of the almost-sure agreement of the two suprema.

Formal statement
n K :
P :
q :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
hwf :
hbdd :
hbn :
∀ k : Fin K, ∀ x, muHat0 k x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 k x ∈ Icc (-1 : ℝ) 1
hq :
0 < q
hq1 :
q ≤ 1 / 2
expectedPooledOffsetSup P (clippedPolicyIncrementTrunc P q ((36 : ℝ) / q) muHat0 muHat1 eHat) assign policySet
= expectedPooledOffsetSup P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign policySet
Proof (Lean source)
lemma expectedPooledOffsetSup_trunc_eq_original_ae_36 {n K : ℕ} (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hbn : ∀ k : Fin K, ∀ x, muHat0 k x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 k x ∈ Icc (-1 : ℝ) 1) (hq : 0 < q) (hq1 : q ≤ 1 / 2) : expectedPooledOffsetSup P (clippedPolicyIncrementTrunc P q ((36 : ℝ) / q) muHat0 muHat1 eHat) assign policySet = expectedPooledOffsetSup P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign policySet := by apply integral_congr_ae exact pooledOffsetSup_trunc_eq_original_ae_36 P q muHat0 muHat1 eHat assign policySet hwf hbdd hbn hq hq1
CausalSmith.Stat.PolicyRegretMarginOverlap.expectedPooledOffsetSup_trunc_eq_original_ae_36 · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/FeasibleERM.lean:747
theorem foldOffsetSubSup_trunc_eq_original_ae_36

The same agreement holds fold by fold: on the product law over fold k's own observations, the offset supremum built from the score truncated at level 36/q equals almost surely the one built from the untruncated score.

Formal statement
n K :
P :
q :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
k :
Fin K
hwf :
hbdd :
hbn :
∀ k : Fin K, ∀ x, muHat0 k x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 k x ∈ Icc (-1 : ℝ) 1
hq :
0 < q
hq1 :
q ≤ 1 / 2
(fun sample : foldIndex assign k → Observation 𝒳 => foldOffsetSubSup P (clippedPolicyIncrementTrunc P q ((36 : ℝ) / q) muHat0 muHat1 eHat) assign policySet k sample)
=ᵐ[Measure.pi (fun _ : foldIndex assign k => P.dataMeasure)] (fun sample : foldIndex assign k → Observation 𝒳 => foldOffsetSubSup P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign policySet k sample)
Proof (Lean source)
lemma foldOffsetSubSup_trunc_eq_original_ae_36 {n K : ℕ} (P : ObservedLaw 𝒳) (q : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (k : Fin K) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hbn : ∀ k : Fin K, ∀ x, muHat0 k x ∈ Icc (-1 : ℝ) 1 ∧ muHat1 k x ∈ Icc (-1 : ℝ) 1) (hq : 0 < q) (hq1 : q ≤ 1 / 2) : (fun sample : foldIndex assign k → Observation 𝒳 => foldOffsetSubSup P (clippedPolicyIncrementTrunc P q ((36 : ℝ) / q) muHat0 muHat1 eHat) assign policySet k sample) =ᵐ[Measure.pi (fun _ : foldIndex assign k => P.dataMeasure)] (fun sample : foldIndex assign k → Observation 𝒳 => foldOffsetSubSup P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign policySet k sample) := by classical letI : IsProbabilityMeasure P.dataMeasure := hwf.1 let B : ℝ := (36 : ℝ) / q let gT : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrementTrunc P q B muHat0 muHat1 eHat let g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrement P q muHat0 muHat1 eHat let μk : Measure (foldIndex assign k → Observation 𝒳) := Measure.pi (fun _ : foldIndex assign k => P.dataMeasure) have hscore_ae : ∀ᵐ O ∂P.dataMeasure, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O| ≤ B := by simpa [B] using crude_clipped_score_abs_ae_36 P (muHat0 k) (muHat1 k) (eHat k) q hbdd (hbn k) hq hq1 have hcoord : ∀ i : foldIndex assign k, ∀ᵐ sample ∂μk, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i)| ≤ B := by intro i let S : Set (Observation 𝒳) := {O | ¬ |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O| ≤ B} have hS_zero : P.dataMeasure S = 0 := by apply measure_eq_zero_iff_ae_notMem.2 filter_upwards [hscore_ae] with O hO simpa [S] using hO have hpre_zero : μk (Function.eval i ⁻¹' S) = 0 := by simpa [μk] using (Measure.pi_eval_preimage_null (μ := fun _ : foldIndex assign k => P.dataMeasure) (i := i) hS_zero) have hae_not : ∀ᵐ sample ∂μk, sample i ∉ S := measure_eq_zero_iff_ae_notMem.mp hpre_zero filter_upwards [hae_not] with sample hs simpa [S] using hs have hsample_good : ∀ᵐ sample ∂μk, ∀ i : foldIndex assign k, |clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i)| ≤ B := Filter.eventually_all.2 hcoord have hmean_eq : ∀ π : Policy 𝒳, ∫ O, gT k π O ∂P.dataMeasure = ∫ O, g k π O ∂P.dataMeasure := by intro π apply integral_congr_ae filter_upwards [hscore_ae] with O hO have hclip : clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) O = clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O := by simpa [clippedScoreTrunc] using clipReal_eq_self_of_abs_le (B := B) (z := clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O) hO simp [gT, g, clippedPolicyIncrementTrunc, clippedPolicyIncrement, hclip] filter_upwards [hsample_good] with sample hgood have hfold_eq : ∀ π : Policy 𝒳, ((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure) = ((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure) := by intro π congr 1 apply Finset.sum_congr rfl intro i _hi have hclip : clippedScoreTrunc q B (muHat0 k) (muHat1 k) (eHat k) (sample i) = clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i) := by simpa [clippedScoreTrunc] using clipReal_eq_self_of_abs_le (B := B) (z := clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) (sample i)) (hgood i) have hterm : gT k π (sample i) = g k π (sample i) := by simp [gT, g, clippedPolicyIncrementTrunc, clippedPolicyIncrement, hclip] rw [hterm, hmean_eq π] have hset : ((fun π => max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure)| - lawRegret P π / 4)) '' policySet) = ((fun π => max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)| - lawRegret P π / 4)) '' policySet) := by ext y constructor · rintro ⟨π, hπ, rfl⟩ refine ⟨π, hπ, ?_⟩ change max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)| - lawRegret P π / 4) = max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure)| - lawRegret P π / 4) rw [← hfold_eq π] · rintro ⟨π, hπ, rfl⟩ refine ⟨π, hπ, ?_⟩ change max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure)| - lawRegret P π / 4) = max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)| - lawRegret P π / 4) rw [hfold_eq π] change sSup ((fun π => max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (gT k π (sample i) - ∫ O, gT k π O ∂P.dataMeasure)| - lawRegret P π / 4)) '' policySet) = sSup ((fun π => max 0 (2 * |((card (foldIndex assign k) : ℝ)⁻¹) * ∑ i : foldIndex assign k, (g k π (sample i) - ∫ O, g k π O ∂P.dataMeasure)| - lawRegret P π / 4)) '' policySet) rw [hset]
CausalSmith.Stat.PolicyRegretMarginOverlap.foldOffsetSubSup_trunc_eq_original_ae_36 · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/FeasibleERM.lean:771
Helpers.MasterBound 6 declarations Provides feasible ERM bridge and master-bound algebra helpers.

Provides feasible ERM bridge and master-bound algebra helpers.

theorem feasible_erm_welfare_bridge

lem:feasible-erm-welfare-bridge. Sample-wise welfare-identity selection inequality for the feasible clipped-AIPW 1/n-ERM. Writing π̂ = feasibleERM …, g = clippedPolicyIncrement P q η̂ (the contrast increment (π−π_⋆)·Γ_q), and w_k = |I_k|/n, the population welfare identity Ŝ_n(π) − Ŝ_n(π_⋆) = G_cf(π) − R_P(π) + Σ_k w_k drift_k(π) — obtained foldwise from clip_bias's conditional-mean drift decomposition applied to the bounded measurable test φ(x) = 1{π(x)} − 1{π_⋆(x)} — together with the 1/n empirical near-max inequality of feasible_erm_basic_inequality (applied at π_⋆ ∈ Π via OptimalInClass) yields the COEFFICIENT-ONE selection bound R_P(π̂) ≤ |G_cf(π̂)| + |Σ_k w_k drift_k(π̂)| + 1/n.

Formal statement
n K :
P :
q :
enum :
ℕ → Policy 𝒳
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
policySet :
Set (Policy 𝒳)
dPi :
hvc :
PolicyClassVC policySet dPi
hopt :
OptimalInClass P policySet
hskel :
DenseSkeleton enum policySet
hwf :
hbdd :
hpos :
hμ0meas :
∀ k : Fin K, Measurable (muHat0 k)
hμ1meas :
∀ k : Fin K, Measurable (muHat1 k)
hemeas :
∀ k : Fin K, Measurable (eHat k)
hμ0bdd :
∀ k : Fin K, ∃ M : ℝ, ∀ x, |muHat0 k x| ≤ M
hμ1bdd :
∀ k : Fin K, ∃ M : ℝ, ∀ x, |muHat1 k x| ≤ M
hq :
0 < q
hq1 :
q < 1
hn :
0 < n
sample :
Fin n → Observation 𝒳
lawRegret P (feasibleERM q enum muHat0 muHat1 eHat assign sample)
≤ |pooledCrossfitProcess P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign sample (feasibleERM q enum muHat0 muHat1 eHat assign sample)|
+ |∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) (feasibleERM q enum muHat0 muHat1 eHat assign sample)|
+ (n : ℝ)⁻¹
Proof (Lean source)
lemma feasible_erm_welfare_bridge {n K : ℕ} (P : ObservedLaw 𝒳) (q : ℝ) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (policySet : Set (Policy 𝒳)) (dPi : ℕ) (hvc : PolicyClassVC policySet dPi) (hopt : OptimalInClass P policySet) (hskel : DenseSkeleton enum policySet) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hpos : Positivity P) (hμ0meas : ∀ k : Fin K, Measurable (muHat0 k)) (hμ1meas : ∀ k : Fin K, Measurable (muHat1 k)) (hemeas : ∀ k : Fin K, Measurable (eHat k)) (hμ0bdd : ∀ k : Fin K, ∃ M : ℝ, ∀ x, |muHat0 k x| ≤ M) (hμ1bdd : ∀ k : Fin K, ∃ M : ℝ, ∀ x, |muHat1 k x| ≤ M) (hq : 0 < q) (hq1 : q < 1) (hn : 0 < n) (sample : Fin n → Observation 𝒳) : lawRegret P (feasibleERM q enum muHat0 muHat1 eHat assign sample) ≤ |pooledCrossfitProcess P (clippedPolicyIncrement P q muHat0 muHat1 eHat) assign sample (feasibleERM q enum muHat0 muHat1 eHat assign sample)| + |∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) (feasibleERM q enum muHat0 muHat1 eHat assign sample)| + (n : ℝ)⁻¹ := by classical let πhat : Policy 𝒳 := feasibleERM q enum muHat0 muHat1 eHat assign sample let πstar : Policy 𝒳 := lawOptimalPolicy P let g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrement P q muHat0 muHat1 eHat let S : Policy 𝒳 → ℝ := empiricalWelfareScore q muHat0 muHat1 eHat assign sample let G : Policy 𝒳 → ℝ := pooledCrossfitProcess P g assign sample let D : Policy 𝒳 → ℝ := fun π => ∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π have hbridge_identity : ∀ π ∈ policySet, lawRegret P π = G π + D π - (S π - S πstar) := by intro π hπmem have hπmeas : Measurable π := hvc.1 π hπmem have hstar_mem : πstar ∈ policySet := hopt have hstarmeas : Measurable πstar := hvc.1 πstar hstar_mem have hπind_meas : Measurable (fun x : 𝒳 => boolIndicator (π x)) := (measurable_of_finite (fun b : Bool => boolIndicator b)).comp hπmeas have hstarind_meas : Measurable (fun x : 𝒳 => boolIndicator (πstar x)) := (measurable_of_finite (fun b : Bool => boolIndicator b)).comp hstarmeas let φ : 𝒳 → ℝ := fun x => boolIndicator (π x) - boolIndicator (πstar x) have hφmeas : Measurable φ := hπind_meas.sub hstarind_meas have hφbdd : ∃ M : ℝ, ∀ x, |φ x| ≤ M := by refine ⟨2, ?_⟩ intro x dsimp [φ] cases π x <;> cases πstar x <;> norm_num [boolIndicator] have hτmeas : Measurable P.contrast := by rcases hwf with ⟨_, _, _, hτmeas, _⟩ exact hτmeas letI : IsProbabilityMeasure P.PX := by rcases hwf with ⟨_, hPXprob, _⟩ exact hPXprob have hπind_bdd : ∃ M : ℝ, ∀ x, |boolIndicator (π x)| ≤ M := by refine ⟨1, ?_⟩ intro x cases π x <;> simp [boolIndicator] have hstarind_bdd : ∃ M : ℝ, ∀ x, |boolIndicator (πstar x)| ≤ M := by refine ⟨1, ?_⟩ intro x cases πstar x <;> simp [boolIndicator] have hπterm_int : Integrable (fun x : 𝒳 => boolIndicator (π x) * P.contrast x) P.PX := integrable_of_measurable_bounded (hπind_meas.mul hτmeas) (bounded_mul hπind_bdd (bounded_law_contrast P hwf hbdd)) have hstarterm_int : Integrable (fun x : 𝒳 => boolIndicator (πstar x) * P.contrast x) P.PX := integrable_of_measurable_bounded (hstarind_meas.mul hτmeas) (bounded_mul hstarind_bdd (bounded_law_contrast P hwf hbdd)) have hcontrast : ∫ x, φ x * P.contrast x ∂P.PX = -lawRegret P π := by have hpoint : (fun x : 𝒳 => φ x * P.contrast x) = fun x => boolIndicator (π x) * P.contrast x - boolIndicator (πstar x) * P.contrast x := by funext x dsimp [φ] ring calc ∫ x, φ x * P.contrast x ∂P.PX = ∫ x, (boolIndicator (π x) * P.contrast x - boolIndicator (πstar x) * P.contrast x) ∂P.PX := by rw [hpoint] _ = ∫ x, boolIndicator (π x) * P.contrast x ∂P.PX - ∫ x, boolIndicator (πstar x) * P.contrast x ∂P.PX := by rw [integral_sub hπterm_int hstarterm_int] _ = -lawRegret P π := by dsimp [πstar] unfold lawRegret regret welfare lawOptimalPolicy norm_num have hscore_split : S π - S πstar = (n : ℝ)⁻¹ * ∑ i : Fin n, g (assign i) π (sample i) := by dsimp [S, g, πstar, empiricalWelfareScore, clippedPolicyIncrement] rw [← mul_sub, ← Finset.sum_sub_distrib] congr 1 apply Finset.sum_congr rfl intro i _hi ring have hdecomp : (n : ℝ)⁻¹ * ∑ i : Fin n, g (assign i) π (sample i) = G π + (n : ℝ)⁻¹ * ∑ i : Fin n, ∫ O, g (assign i) π O ∂P.dataMeasure := by dsimp [G, pooledCrossfitProcess] have hsum : (∑ i : Fin n, g (assign i) π (sample i)) = ∑ i : Fin n, ((g (assign i) π (sample i) - ∫ O, g (assign i) π O ∂P.dataMeasure) + ∫ O, g (assign i) π O ∂P.dataMeasure) := by apply Finset.sum_congr rfl intro i _hi ring rw [hsum, Finset.sum_add_distrib] ring have hmean_k : ∀ k : Fin K, ∫ O, g k π O ∂P.dataMeasure = -lawRegret P π + driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π := by intro k have hclip := (clip_bias P q (muHat0 k) (muHat1 k) (eHat k) hwf hbdd hpos (hμ0meas k) (hμ1meas k) (hemeas k) (hμ0bdd k) (hμ1bdd k) hq hq1 φ hφmeas hφbdd).1 calc ∫ O, g k π O ∂P.dataMeasure = ∫ O, φ O.X * clippedAIPWScore q (muHat0 k) (muHat1 k) (eHat k) O ∂P.dataMeasure := by simp [g, φ, clippedPolicyIncrement, πstar] _ = ∫ x, φ x * P.contrast x ∂P.PX + ∫ x, φ x * clipBias P q (muHat0 k) (muHat1 k) (eHat k) x ∂P.PX := by linarith [hclip] _ = -lawRegret P π + driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π := by simp [hcontrast, driftIntegral, φ, πstar] let H : Fin K → ℝ := fun k => driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π have hmean_sum : (n : ℝ)⁻¹ * ∑ i : Fin n, ∫ O, g (assign i) π O ∂P.dataMeasure = -lawRegret P π + D π := by have hreplace : (n : ℝ)⁻¹ * ∑ i : Fin n, ∫ O, g (assign i) π O ∂P.dataMeasure = (n : ℝ)⁻¹ * ∑ i : Fin n, (-lawRegret P π + H (assign i)) := by congr 1 apply Finset.sum_congr rfl intro i _hi simpa [H] using hmean_k (assign i) calc (n : ℝ)⁻¹ * ∑ i : Fin n, ∫ O, g (assign i) π O ∂P.dataMeasure = (n : ℝ)⁻¹ * ∑ i : Fin n, (-lawRegret P π + H (assign i)) := hreplace _ = -lawRegret P π + (n : ℝ)⁻¹ * ∑ i : Fin n, H (assign i) := by have hnR : (n : ℝ) ≠ 0 := by exact_mod_cast (ne_of_gt hn) rw [Finset.sum_add_distrib] have hconst : (∑ _i : Fin n, -lawRegret P π) = (n : ℝ) * (-lawRegret P π) := by simp rw [hconst] field_simp [hnR] _ = -lawRegret P π + D π := by rw [inv_card_sum_assign_eq_sum_foldWeights assign H hn] have hscore_bridge : S π - S πstar = G π - lawRegret P π + D π := by calc S π - S πstar = (n : ℝ)⁻¹ * ∑ i : Fin n, g (assign i) π (sample i) := hscore_split _ = G π + (n : ℝ)⁻¹ * ∑ i : Fin n, ∫ O, g (assign i) π O ∂P.dataMeasure := hdecomp _ = G π + (-lawRegret P π + D π) := by rw [hmean_sum] _ = G π - lawRegret P π + D π := by ring linarith [hscore_bridge] have hbasic := (feasible_erm_basic_inequality P q enum muHat0 muHat1 eHat assign policySet dPi hvc hopt hskel.1 hskel.2 hμ0meas hμ1meas hemeas hn).2 sample have hπhat_mem : πhat ∈ policySet := hbasic.1 have hstar_near : S πstar ≤ S πhat + (n : ℝ)⁻¹ := by exact hbasic.2 πstar hopt have hslack : -(S πhat - S πstar) ≤ (n : ℝ)⁻¹ := by linarith have hfinal : lawRegret P πhat ≤ |G πhat| + |D πhat| + (n : ℝ)⁻¹ := by calc lawRegret P πhat = G πhat + D πhat - (S πhat - S πstar) := hbridge_identity πhat hπhat_mem _ ≤ G πhat + D πhat + (n : ℝ)⁻¹ := by linarith _ ≤ |G πhat| + |D πhat| + (n : ℝ)⁻¹ := by have hGabs : G πhat ≤ |G πhat| := le_abs_self (G πhat) have hDabs : D πhat ≤ |D πhat| := le_abs_self (D πhat) linarith simpa [πhat, g, G, D] using hfinal
CausalSmith.Stat.PolicyRegretMarginOverlap.feasible_erm_welfare_bridge · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/MasterBound.lean:20

Young's inequality in the form used to absorb a regret-localization term. For nonnegative D, m and R and a positive window u, the product of D, m and the square root of R/u is at most half of R plus D²m²/(2u). Half the regret can therefore be moved to the other side of a self-bounding inequality, leaving a remainder that no longer involves the regret.

Formal statement
D m R u :
hD :
0 ≤ D
hm :
0 ≤ m
hR :
0 ≤ R
hu :
0 < u
D * m * (R / u) ^ (1 / 2 : ℝ) ≤ R / 2 + D ^ 2 * m ^ 2 / (2 * u)
Proof (Lean source)
lemma young_sqrt_absorb {D m R u : ℝ} (hD : 0 ≤ D) (hm : 0 ≤ m) (hR : 0 ≤ R) (hu : 0 < u) : D * m * (R / u) ^ (1 / 2 : ℝ) ≤ R / 2 + D ^ 2 * m ^ 2 / (2 * u) := by have hsqrt_u_pos : 0 < sqrt u := Real.sqrt_pos.2 hu have hsqrt_u_ne : sqrt u ≠ 0 := hsqrt_u_pos.ne' have hsqrt_div : (R / u) ^ (1 / 2 : ℝ) = sqrt R / sqrt u := by rw [Real.sqrt_eq_rpow, Real.sqrt_eq_rpow] rw [Real.div_rpow hR hu.le] have hsq : 0 ≤ (sqrt R - D * m / sqrt u) ^ 2 := sq_nonneg _ have hu_sqrt_sq : sqrt u ^ 2 = u := by rw [Real.sq_sqrt hu.le] have hR_sqrt_sq : sqrt R ^ 2 = R := by rw [Real.sq_sqrt hR] have hsq_core : 2 * sqrt R * sqrt u * (D * m) ≤ R * u + D ^ 2 * m ^ 2 := by field_simp [hsqrt_u_ne] at hsq nlinarith [hsq, hR_sqrt_sq, hu_sqrt_sq] have htarget : 2 * sqrt R * D * m * u ≤ sqrt u * (R * u + D ^ 2 * m ^ 2) := by have hmul := mul_le_mul_of_nonneg_left hsq_core hsqrt_u_pos.le calc 2 * sqrt R * D * m * u = 2 * sqrt R * D * m * (sqrt u) ^ 2 := by rw [hu_sqrt_sq] _ = sqrt u * (2 * sqrt R * sqrt u * (D * m)) := by ring _ ≤ sqrt u * (R * u + D ^ 2 * m ^ 2) := hmul rw [hsqrt_div] field_simp [hsqrt_u_ne, (by norm_num : (2 : ℝ) ≠ 0), hu.ne'] nlinarith [htarget]
CausalSmith.Stat.PolicyRegretMarginOverlap.young_sqrt_absorb · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/MasterBound.lean:319
theorem weighted_drift_sum_bound_pos

Cross-fitted drift bound in the decaying-overlap regime. When every fold's nuisance estimates share the same root-mean-square rates, the fold-size weighted average of the per-fold policy-weighted drifts obeys the same three-term bound as a single fold: an explicit constant, 4(1 + max(C_o,1)^{1/2}), times the sum of the product-rate term r_μ r_e / q, the clipped-region term r_μ u^{α/2} q^{1/(2γ)} and the regret-localization term r_μ (R_P(π)/u)^{1/2}. The fold weights are nonnegative and sum to one, so cross-fitting costs nothing here.

Formal statement
n K :
P :
policySet :
Set (Policy 𝒳)
q rMu rE α γ Co co u0 underlineP :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
hsq0 :
∀ k : Fin K, ∫ x, (muHat0 k x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hsq1 :
∀ k : Fin K, ∫ x, (muHat1 k x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hse :
∀ k : Fin K, ∫ x, (eHat k x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2
hμ0L2 :
∀ k : Fin K, MemLp (fun x => muHat0 k x - P.mu0 x) 2 P.PX
hμ1L2 :
∀ k : Fin K, MemLp (fun x => muHat1 k x - P.mu1 x) 2 P.PX
heL2 :
∀ k : Fin K, MemLp (fun x => eHat k x - P.propensity x) 2 P.PX
hrMu_nonneg :
0 ≤ rMu
hrE_nonneg :
0 ≤ rE
hwf :
hπmeas :
∀ π ∈ policySet, Measurable π
hq_half :
q ≤ 1 / 2
hod :
OverlapDecay P u0 Co co α γ
hze :
ZeroEffectRegular P policySet
hbdd :
hstrict :
StrictOverlapEndpoint P γ underlineP
hq :
0 < q
hn :
0 < n
hγpos :
0 < γ
π :
Policy 𝒳
hπmem :
π ∈ policySet
u :
hu :
0 < u
hu_le :
u ≤ u0
hq_le :
q ≤ co * u ^ γ
|∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π|
≤ 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) * (rMu * rE / q + rMu * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ))
Proof (Lean source)
lemma weighted_drift_sum_bound_pos {n K : ℕ} (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (q rMu rE α γ Co co u0 underlineP : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (hsq0 : ∀ k : Fin K, ∫ x, (muHat0 k x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hsq1 : ∀ k : Fin K, ∫ x, (muHat1 k x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hse : ∀ k : Fin K, ∫ x, (eHat k x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2) (hμ0L2 : ∀ k : Fin K, MemLp (fun x => muHat0 k x - P.mu0 x) 2 P.PX) (hμ1L2 : ∀ k : Fin K, MemLp (fun x => muHat1 k x - P.mu1 x) 2 P.PX) (heL2 : ∀ k : Fin K, MemLp (fun x => eHat k x - P.propensity x) 2 P.PX) (hrMu_nonneg : 0 ≤ rMu) (hrE_nonneg : 0 ≤ rE) (hwf : WellFormedLaw P) (hπmeas : ∀ π ∈ policySet, Measurable π) (hq_half : q ≤ 1 / 2) (hod : OverlapDecay P u0 Co co α γ) (hze : ZeroEffectRegular P policySet) (hbdd : BoundedOutcome P) (hstrict : StrictOverlapEndpoint P γ underlineP) (hq : 0 < q) (hn : 0 < n) (hγpos : 0 < γ) (π : Policy 𝒳) (hπmem : π ∈ policySet) (u : ℝ) (hu : 0 < u) (hu_le : u ≤ u0) (hq_le : q ≤ co * u ^ γ) : |∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| ≤ 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) * (rMu * rE / q + rMu * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ)) := by classical let Cd : ℝ := 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) let X : ℝ := rMu * rE / q + rMu * u ^ (α / 2) * q ^ (1 / (2 * γ)) + rMu * (lawRegret P π / u) ^ (1 / 2 : ℝ) let w : Fin K → ℝ := fun k => (card (foldIndex assign k) : ℝ) / (n : ℝ) have hw_nonneg : ∀ k, 0 ≤ w k := by intro k exact div_nonneg (by positivity) (by exact_mod_cast hn.le) have hw_sum : (∑ k : Fin K, w k) = 1 := sum_foldWeights_eq_one assign hn have hCd_nonneg : 0 ≤ Cd := by dsimp [Cd] positivity have hX_nonneg : 0 ≤ X := by have hπ : Measurable π := hπmeas π hπmem have hR_nonneg : 0 ≤ lawRegret P π := lawRegret_nonneg P π hwf hbdd hπ dsimp [X] positivity have hterm : ∀ k : Fin K, |driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| ≤ Cd * X := by intro k rcases localized_clipped_drift_bound P policySet q rMu rE α γ Co co u0 underlineP (muHat0 k) (muHat1 k) (eHat k) (hsq0 k) (hsq1 k) (hse k) (hμ0L2 k) (hμ1L2 k) (heL2 k) hrMu_nonneg hrE_nonneg hwf hπmeas hq_half hod hze hbdd hstrict hq with ⟨⟨C0, _hC0pos, hC0eq, hpos⟩, _⟩ have hk := hpos hγpos π hπmem u hu hu_le hq_le simpa [Cd, X, hC0eq] using hk calc |∑ k : Fin K, w k * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| ≤ ∑ k : Fin K, |w k * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| := Finset.abs_sum_le_sum_abs _ _ _ = ∑ k : Fin K, w k * |driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| := by apply Finset.sum_congr rfl intro k _ rw [abs_mul, abs_of_nonneg (hw_nonneg k)] _ ≤ ∑ k : Fin K, w k * (Cd * X) := by exact Finset.sum_le_sum (fun k _ => mul_le_mul_of_nonneg_left (hterm k) (hw_nonneg k)) _ = Cd * X := by rw [← Finset.sum_mul] rw [hw_sum] ring
CausalSmith.Stat.PolicyRegretMarginOverlap.weighted_drift_sum_bound_pos · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/MasterBound.lean:353
theorem weighted_drift_sum_bound_zero

Cross-fitted drift bound at the strict-overlap endpoint. When the overlap exponent is zero and the clip level is fixed at no more than half the overlap floor, the fold-size weighted average of the per-fold policy-weighted drifts is at most max(1, 2/q) times the product rate r_μ r_e: strict overlap removes the clipped-region and regret-localization terms, and averaging over folds with weights summing to one preserves the bound.

Formal statement
n K :
P :
policySet :
Set (Policy 𝒳)
q rMu rE α γ Co co u0 underlineP :
muHat0 muHat1 eHat :
Fin K → 𝒳 → ℝ
assign :
Fin n → Fin K
hsq0 :
∀ k : Fin K, ∫ x, (muHat0 k x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hsq1 :
∀ k : Fin K, ∫ x, (muHat1 k x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2
hse :
∀ k : Fin K, ∫ x, (eHat k x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2
hμ0L2 :
∀ k : Fin K, MemLp (fun x => muHat0 k x - P.mu0 x) 2 P.PX
hμ1L2 :
∀ k : Fin K, MemLp (fun x => muHat1 k x - P.mu1 x) 2 P.PX
heL2 :
∀ k : Fin K, MemLp (fun x => eHat k x - P.propensity x) 2 P.PX
hrMu_nonneg :
0 ≤ rMu
hrE_nonneg :
0 ≤ rE
hwf :
hπmeas :
∀ π ∈ policySet, Measurable π
hq_half :
q ≤ 1 / 2
hod :
OverlapDecay P u0 Co co α γ
hze :
ZeroEffectRegular P policySet
hbdd :
hstrict :
StrictOverlapEndpoint P γ underlineP
hq :
0 < q
hn :
0 < n
hγ0 :
γ = 0
hq_under :
q ≤ underlineP / 2
π :
Policy 𝒳
hπmem :
π ∈ policySet
|∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π|
max 1 (2 / q) * (rMu * rE)
Proof (Lean source)
lemma weighted_drift_sum_bound_zero {n K : ℕ} (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (q rMu rE α γ Co co u0 underlineP : ℝ) (muHat0 muHat1 eHat : Fin K → 𝒳 → ℝ) (assign : Fin n → Fin K) (hsq0 : ∀ k : Fin K, ∫ x, (muHat0 k x - P.mu0 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hsq1 : ∀ k : Fin K, ∫ x, (muHat1 k x - P.mu1 x) ^ 2 ∂P.PX ≤ rMu ^ 2) (hse : ∀ k : Fin K, ∫ x, (eHat k x - P.propensity x) ^ 2 ∂P.PX ≤ rE ^ 2) (hμ0L2 : ∀ k : Fin K, MemLp (fun x => muHat0 k x - P.mu0 x) 2 P.PX) (hμ1L2 : ∀ k : Fin K, MemLp (fun x => muHat1 k x - P.mu1 x) 2 P.PX) (heL2 : ∀ k : Fin K, MemLp (fun x => eHat k x - P.propensity x) 2 P.PX) (hrMu_nonneg : 0 ≤ rMu) (hrE_nonneg : 0 ≤ rE) (hwf : WellFormedLaw P) (hπmeas : ∀ π ∈ policySet, Measurable π) (hq_half : q ≤ 1 / 2) (hod : OverlapDecay P u0 Co co α γ) (hze : ZeroEffectRegular P policySet) (hbdd : BoundedOutcome P) (hstrict : StrictOverlapEndpoint P γ underlineP) (hq : 0 < q) (hn : 0 < n) (hγ0 : γ = 0) (hq_under : q ≤ underlineP / 2) (π : Policy 𝒳) (hπmem : π ∈ policySet) : |∑ k : Fin K, ((card (foldIndex assign k) : ℝ) / (n : ℝ)) * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| ≤ max 1 (2 / q) * (rMu * rE) := by classical let Cq : ℝ := max 1 (2 / q) let w : Fin K → ℝ := fun k => (card (foldIndex assign k) : ℝ) / (n : ℝ) have hw_nonneg : ∀ k, 0 ≤ w k := by intro k exact div_nonneg (by positivity) (by exact_mod_cast hn.le) have hw_sum : (∑ k : Fin K, w k) = 1 := sum_foldWeights_eq_one assign hn have hprod_nonneg : 0 ≤ rMu * rE := mul_nonneg hrMu_nonneg hrE_nonneg have hterm : ∀ k : Fin K, |driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| ≤ Cq * (rMu * rE) := by intro k rcases localized_clipped_drift_bound P policySet q rMu rE α γ Co co u0 underlineP (muHat0 k) (muHat1 k) (eHat k) (hsq0 k) (hsq1 k) (hse k) (hμ0L2 k) (hμ1L2 k) (heL2 k) hrMu_nonneg hrE_nonneg hwf hπmeas hq_half hod hze hbdd hstrict hq with ⟨_, ⟨C1, _hC1pos, hC1eq, hzero⟩⟩ have hk := hzero hγ0 hq_under π hπmem simpa [Cq, hC1eq] using hk calc |∑ k : Fin K, w k * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| ≤ ∑ k : Fin K, |w k * driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| := Finset.abs_sum_le_sum_abs _ _ _ = ∑ k : Fin K, w k * |driftIntegral P q (muHat0 k) (muHat1 k) (eHat k) π| := by apply Finset.sum_congr rfl intro k _ rw [abs_mul, abs_of_nonneg (hw_nonneg k)] _ ≤ ∑ k : Fin K, w k * (Cq * (rMu * rE)) := by exact Finset.sum_le_sum (fun k _ => mul_le_mul_of_nonneg_left (hterm k) (hw_nonneg k)) _ = Cq * (rMu * rE) := by rw [← Finset.sum_mul] rw [hw_sum] ring
CausalSmith.Stat.PolicyRegretMarginOverlap.weighted_drift_sum_bound_zero · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/MasterBound.lean:425
theorem crude_localized_master_bound Lemma 8 in the paper ↗

lem:crude-localized-master-bound. Pooled crude q^{-2}-envelope master bound for the cross-fit clipped-AIPW 1/n-ERM (ARBITRARY enum, foldwise nuisances, assign partition). BOTH overlap regimes: for γ>0 with q ≤ c_o u^γ it is the five-term bound; for γ=0 with fixed q ≤ underline_p/2 it collapses to C{n^{-A_α}+r_μ r_e}(log n)^p.

Formal statement
K :
policySet :
Set (Policy 𝒳)
α γ Cm u0 Co co underlineP a c CMu CProd :
dPi :
assign :
(m : ℕ) → Fin m → Fin K
qSeq uSeq rMu rE :
ℕ → ℝ
enum :
ℕ → Policy 𝒳
muHat0 muHat1 eHat :
ℕ → Fin K → 𝒳 → ℝ
hvc :
PolicyClassVC policySet dPi
henvU :
hoffU :
hskel :
DenseSkeleton enum policySet
hK :
hpoly :
PolynomialNuisanceExponents rMu rE a c CMu CProd
hq_pos :
∀ᶠ n : ℕ in atTop, 0 < qSeq n
regularity: the note's clips are in the genuine clipping interval, giving `q ≤ ē_q ≤ 1-q` for score envelopes and drift denominators.
hq_half :
∀ᶠ n : ℕ in atTop, qSeq n ≤ 1 / 2
schedule regularity: in the strict-overlap endpoint (`γ=0`) the feasible construction uses a fixed clip, so q-dependent constants are still hoistable above `∀ n`.
hq_zero_fixed :
γ = 0 → ∃ q0fix : ℝ, 0 < q0fix ∧ ∀ᶠ n : ℕ in atTop, qSeq n = q0fix
regularity: nuisance rates are nonnegative radii, intrinsic to `NuisanceRate` / `PolynomialNuisanceExponents` bookkeeping.
hrMu_nonneg :
∀ᶠ n : ℕ in atTop, 0 ≤ rMu n
hrE_nonneg :
∀ᶠ n : ℕ in atTop, 0 ≤ rE n
regularity: foldwise plug-in nuisances are measurable so `feasible_erm_basic_inequality`, `clip_bias`, and centered processes are genuine Bochner objects.
hμ0meas :
∀ n k, Measurable (muHat0 n k)
hμ1meas :
∀ n k, Measurable (muHat1 n k)
hemeas :
∀ n k, Measurable (eHat n k)
regularity: L² nuisance-error fields are MemLp inputs for Cauchy-Schwarz in the deterministic drift bound.
hμ0L2 :
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat0 n k x - P.mu0 x) 2 P.PX
hμ1L2 :
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat1 n k x - P.mu1 x) 2 P.PX
heL2 :
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => eHat n k x - P.propensity x) 2 P.PX
bounded cross-fit outcome regressions (A12): needed — together with the finite-VC dense skeleton (`hvc`) and the positive clip schedule — to DISCHARGE the Bochner side conditions internally via `bochner_discharge`, so they are no longer an assumed input.
hbn :
∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)
∃ C p : ℝ
if
0 < C ∧
0 ≤ p ∧
∀ᶠ n : ℕ in atTop,
∀ (P : ObservedLaw 𝒳), LawClass α γ Cm u0 Co co underlineP policySet P
and
OptimalInClass P policySet
and
(∀ k : Fin K, NuisanceRate P (fun m => muHat0 m k) (fun m => muHat1 m k) (fun m => eHat m k) rMu rE)
and
(∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k))
then
(0 < γ → 0 < uSeq n → uSeq n ≤ u0 → qSeq n ≤ co * (uSeq n) ^ γ → ∫ sample, lawRegret P (feasibleERM (qSeq n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ C * ((n : ℝ) ^ (-(rStar α γ)) + ((n : ℝ) * (qSeq n) ^ 2) ^ (-(Aalpha α)) + rMu n * rE n / qSeq n + rMu n * (uSeq n) ^ (α / 2) * (qSeq n) ^ (1 / (2 * γ)) + (rMu n) ^ 2 / uSeq n) * (log n) ^ p) ∧
(γ = 0 → qSeq n ≤ underlineP / 2 → ∫ sample, lawRegret P (feasibleERM (qSeq n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ C * ((n : ℝ) ^ (-(Aalpha α)) + rMu n * rE n) * (log n) ^ p)
Proof (Lean source)
lemma crude_localized_master_bound {K : ℕ} (policySet : Set (Policy 𝒳)) (α γ Cm u0 Co co underlineP a c CMu CProd : ℝ) (dPi : ℕ) (assign : (m : ℕ) → Fin m → Fin K) (qSeq uSeq rMu rE : ℕ → ℝ) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : ℕ → Fin K → 𝒳 → ℝ) (hvc : PolicyClassVC policySet dPi) (henvU : VCLocalizedEnvelopeUnif policySet α) (hoffU : VCLocalizedOffsetEnvelopeUnif policySet α) (hskel : DenseSkeleton enum policySet) (hK : FixedFoldCount K assign) (hpoly : PolynomialNuisanceExponents rMu rE a c CMu CProd) (hq_pos : ∀ᶠ n : ℕ in atTop, 0 < qSeq n) -- regularity: the note's clips are in the genuine clipping interval, giving -- `q ≤ ē_q ≤ 1-q` for score envelopes and drift denominators. (hq_half : ∀ᶠ n : ℕ in atTop, qSeq n ≤ 1 / 2) -- schedule regularity: in the strict-overlap endpoint (`γ=0`) the feasible -- construction uses a fixed clip, so q-dependent constants are still -- hoistable above `∀ n`. (hq_zero_fixed : γ = 0 → ∃ q0fix : ℝ, 0 < q0fix ∧ ∀ᶠ n : ℕ in atTop, qSeq n = q0fix) -- regularity: nuisance rates are nonnegative radii, intrinsic to -- `NuisanceRate` / `PolynomialNuisanceExponents` bookkeeping. (hrMu_nonneg : ∀ᶠ n : ℕ in atTop, 0 ≤ rMu n) (hrE_nonneg : ∀ᶠ n : ℕ in atTop, 0 ≤ rE n) -- regularity: foldwise plug-in nuisances are measurable so -- `feasible_erm_basic_inequality`, `clip_bias`, and centered processes are -- genuine Bochner objects. (hμ0meas : ∀ n k, Measurable (muHat0 n k)) (hμ1meas : ∀ n k, Measurable (muHat1 n k)) (hemeas : ∀ n k, Measurable (eHat n k)) -- regularity: L² nuisance-error fields are MemLp inputs for -- Cauchy-Schwarz in the deterministic drift bound. (hμ0L2 : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat0 n k x - P.mu0 x) 2 P.PX) (hμ1L2 : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat1 n k x - P.mu1 x) 2 P.PX) (heL2 : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => eHat n k x - P.propensity x) 2 P.PX) -- bounded cross-fit outcome regressions (A12): needed — together with the -- finite-VC dense skeleton (`hvc`) and the positive clip schedule — to DISCHARGE -- the Bochner side conditions internally via `bochner_discharge`, so they are no -- longer an assumed input. (hbn : ∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) : ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ᶠ n : ℕ in atTop, ∀ (P : ObservedLaw 𝒳), LawClass α γ Cm u0 Co co underlineP policySet P → OptimalInClass P policySet → IsIIDSample P → (∀ k : Fin K, NuisanceRate P (fun m => muHat0 m k) (fun m => muHat1 m k) (fun m => eHat m k) rMu rE) → (∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) → (0 < γ → 0 < uSeq n → uSeq n ≤ u0 → qSeq n ≤ co * (uSeq n) ^ γ → ∫ sample, lawRegret P (feasibleERM (qSeq n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ C * ((n : ℝ) ^ (-(rStar α γ)) + ((n : ℝ) * (qSeq n) ^ 2) ^ (-(Aalpha α)) + rMu n * rE n / qSeq n + rMu n * (uSeq n) ^ (α / 2) * (qSeq n) ^ (1 / (2 * γ)) + (rMu n) ^ 2 / uSeq n) * (log n) ^ p) ∧ (γ = 0 → qSeq n ≤ underlineP / 2 → ∫ sample, lawRegret P (feasibleERM (qSeq n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ C * ((n : ℝ) ^ (-(Aalpha α)) + rMu n * rE n) * (log n) ^ p) := by classical rcases crossfit_localized_offset_control policySet Cm α u0 dPi K assign hvc hK hoffU with ⟨Coff0, poff, hCoff0, hpoff, Hoff⟩ let Coff : ℝ := max Coff0 1 let Cd : ℝ := 4 * (1 + (max Co 1) ^ (1 / 2 : ℝ)) let q0fix : ℝ := if hγ0 : γ = 0 then choose (hq_zero_fixed hγ0) else 1 let Kpos : ℝ := ((36 : ℝ) ^ 2) ^ (Aalpha α) let Kzero : ℝ := (((36 : ℝ) / q0fix) ^ 2) ^ (Aalpha α) let Cq0 : ℝ := max 1 (2 / q0fix) let C : ℝ := 100 + 20 * (Coff * Kpos + Coff * Kzero + Cd + Cd ^ 2 + Cq0) have hCoff_pos : 0 < Coff := lt_of_lt_of_le zero_lt_one (le_max_right Coff0 1) have hCoff_ge0 : 0 ≤ Coff := hCoff_pos.le have hCoff_ge1 : 1 ≤ Coff := le_max_right Coff0 1 have hCd_nonneg : 0 ≤ Cd := by dsimp [Cd] positivity have hq0fix_pos : 0 < q0fix := by by_cases hγ0 : γ = 0 · have hspec := Classical.choose_spec (hq_zero_fixed hγ0) simpa [q0fix, hγ0] using hspec.1 · simp [q0fix, hγ0] have hKpos_nonneg : 0 ≤ Kpos := by dsimp [Kpos] exact Real.rpow_nonneg (sq_nonneg (36 : ℝ)) _ have hKzero_nonneg : 0 ≤ Kzero := by dsimp [Kzero] exact Real.rpow_nonneg (sq_nonneg ((36 : ℝ) / q0fix)) _ have hCq0_nonneg : 0 ≤ Cq0 := by dsimp [Cq0] exact le_trans zero_le_one (le_max_left _ _) have hCpos : 0 < C := by dsimp [C] nlinarith [hCoff_ge0, hKpos_nonneg, hKzero_nonneg, hCd_nonneg, sq_nonneg Cd, hCq0_nonneg] have hq_zero_event : ∀ᶠ n : ℕ in atTop, γ = 0 → qSeq n = q0fix := by by_cases hγ0 : γ = 0 · have hspec := Classical.choose_spec (hq_zero_fixed hγ0) filter_upwards [hspec.2] with n hn intro _h simpa [q0fix, hγ0] using hn · exact Filter.Eventually.of_forall (fun n h => elim (hγ0 h)) refine ⟨C, poff, hCpos, hpoff, ?_⟩ -- The Bochner integrability/BddAbove side conditions are now DISCHARGED internally -- from the primitive regularity data, rather than assumed (`bochner_integrability_gate`). have hBochner := bochner_discharge α γ Cm u0 Co co underlineP policySet dPi enum muHat0 muHat1 eHat assign qSeq hvc hskel hbn hμ0meas hμ1meas hemeas hq_pos hq_half filter_upwards [hq_pos, hq_half, hrMu_nonneg, hrE_nonneg, hμ0L2, hμ1L2, heL2, hBochner, hq_zero_event, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩, Filter.eventually_atTop.mpr ⟨Nat.ceil (exp 1), fun n hn => hn⟩] with n hqpos hqhalf hrMuN hrEN hμ0L2n hμ1L2n heL2n hBoN hqZeroN hn1 hnceil intro P hLaw hopt hiid hnuis hbnuis let q : ℝ := qSeq n let B : ℝ := (36 : ℝ) / q let g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrement P q (muHat0 n) (muHat1 n) (eHat n) let gT : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ := clippedPolicyIncrementTrunc P q B (muHat0 n) (muHat1 n) (eHat n) let πhat : (Fin n → Observation 𝒳) → Policy 𝒳 := fun sample => feasibleERM q enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample have hnpos : 0 < n := lt_of_lt_of_le (by norm_num : 0 < (1 : ℕ)) hn1 have hq : 0 < q := by simpa [q] using hqpos have hq_half_n : q ≤ 1 / 2 := by simpa [q] using hqhalf have hq_lt_one : q < 1 := by linarith have hB_nonneg : 0 ≤ B := by dsimp [B] exact div_nonneg (by norm_num) hq.le have hB_one : 1 ≤ B := by dsimp [B] rw [le_div_iff₀ hq] nlinarith [hq_half_n] have hnRpos : 0 < (n : ℝ) := by exact_mod_cast hnpos have hlog_one : 1 ≤ log (n : ℝ) := by have hexp_le_ceil : exp 1 ≤ (ceil (exp 1) : ℝ) := Nat.le_ceil _ have hceil_le_n : (ceil (exp 1) : ℝ) ≤ (n : ℝ) := by exact_mod_cast hnceil have hexp_le_n : exp 1 ≤ (n : ℝ) := le_trans hexp_le_ceil hceil_le_n exact (Real.le_log_iff_exp_le (lt_of_lt_of_le (Real.exp_pos 1) hexp_le_n)).2 hexp_le_n have hα_nonneg : 0 ≤ α := hLaw.margin.1 have hπmeas : ∀ π ∈ policySet, Measurable π := hvc.1 have hπhat_mem : ∀ sample, πhat sample ∈ policySet := by intro sample exact hskel.1 _ have hμ0bdd : ∀ k : Fin K, ∃ M : ℝ, ∀ x, |muHat0 n k x| ≤ M := by intro k refine ⟨1, ?_⟩ intro x exact abs_le.mpr ⟨(hbnuis k n x).1.1, (hbnuis k n x).1.2⟩ have hμ1bdd : ∀ k : Fin K, ∃ M : ℝ, ∀ x, |muHat1 n k x| ≤ M := by intro k refine ⟨1, ?_⟩ intro x exact abs_le.mpr ⟨(hbnuis k n x).2.1, (hbnuis k n x).2.2⟩ have hBo := hBoN P hLaw dsimp only at hBo rcases hBo with ⟨hInt_regret, hInt_offset, hbdd_offset, hInt_fold⟩ have hInt_pooledT : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P gT (assign n) sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure)) := by have hae := pooledOffsetSup_trunc_eq_original_ae_36 P q (muHat0 n) (muHat1 n) (eHat n) (assign n) policySet hLaw.wf hLaw.bdd (fun k x => hbnuis k n x) hq hq_half_n exact hInt_offset.congr hae.symm have hInt_foldT : ∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P gT (assign n) policySet k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure)) := by intro k have hae := foldOffsetSubSup_trunc_eq_original_ae_36 P q (muHat0 n) (muHat1 n) (eHat n) (assign n) policySet k hLaw.wf hLaw.bdd (fun k x => hbnuis k n x) hq hq_half_n exact (hInt_fold k).congr hae.symm have hoffT := Hoff P hLaw.margin hLaw.zero hiid hLaw.wf hLaw.bdd n B gT hnpos hB_nonneg (fun k => clippedPolicyIncrementTrunc_compatible P q B (muHat0 n) (muHat1 n) (eHat n) k) (fun k π hπmem => clippedPolicyIncrementTrunc_measurable P q B (muHat0 n) (muHat1 n) (eHat n) k π hLaw.wf (hπmeas π hπmem) (hμ0meas n k) (hμ1meas n k) (hemeas n k)) hInt_pooledT hInt_foldT (fun k π hπmem O => clippedPolicyIncrementTrunc_bound P q B (muHat0 n) (muHat1 n) (eHat n) k π O hB_nonneg) (fun k π hπmem => clippedPolicyIncrementTrunc_second_moment P q B (muHat0 n) (muHat1 n) (eHat n) k π hLaw.wf (hπmeas π hπmem) hB_nonneg) have hoffOrig : expectedPooledOffsetSup P g (assign n) policySet ≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ poff) := by have heq := expectedPooledOffsetSup_trunc_eq_original_ae_36 P q (muHat0 n) (muHat1 n) (eHat n) (assign n) policySet hLaw.wf hLaw.bdd (fun k x => hbnuis k n x) hq hq_half_n have hbase_nonneg : 0 ≤ (B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ poff := by positivity calc expectedPooledOffsetSup P g (assign n) policySet = expectedPooledOffsetSup P gT (assign n) policySet := by exact heq.symm _ ≤ Coff0 * (B ^ 2 / (n : ℝ)) ^ ((1 + α) / (2 + α)) * (log n) ^ poff := hoffT _ = Coff0 * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ poff) := by simp [Aalpha] ring _ ≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ poff) := mul_le_mul_of_nonneg_right (le_max_left Coff0 1) hbase_nonneg have hlarge : (n : ℝ)⁻¹ ≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ poff) := crude_self_large hn1 hα_nonneg hB_one hCoff_ge1 hpoff hlog_one constructor · intro hγpos hu_pos hu_le hq_adm let δ : ℝ := 2 * (Cd * (rMu n * rE n / q + rMu n * (uSeq n) ^ (α / 2) * q ^ (1 / (2 * γ))) + Cd ^ 2 * (rMu n) ^ 2 / (2 * uSeq n) + (n : ℝ)⁻¹) have hδ_nonneg : 0 ≤ δ := by dsimp [δ, Cd] positivity -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.crude_localized_master_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/MasterBound.lean:598
theorem clip_balance_exponent Lemma 9 in the paper ↗

lem:clip-balance-exponent. Optimization of the master-bound terms over the DETERMINISTIC def:feasible-rate schedule q_n = qSched, u_n = uSched (tied to s_feas, t_feas, not arbitrary) under the admissibility q_n ≤ c_o u_n^γ, to the solved exponent r_feas = rFeas α γ a c (the FeasibleRate.r accessor). BOTH regimes: for γ>0 the five master-bound terms; for γ=0 the fixed-clip n^{-A_α}+r_μ r_e terms.

Formal statement
α γ a c CMu CProd q0 uBar co :
rMu rE :
ℕ → ℝ
hpoly :
PolynomialNuisanceExponents rMu rE a c CMu CProd
hCMu :
0 ≤ CMu
hCProd :
0 ≤ CProd
hrMu_nonneg :
∀ᶠ n : ℕ in atTop, 0 ≤ rMu n
hq0 :
0 < q0
huBar :
0 < γ → 0 < uBar
hadm :
0 < γ → feasibleAdmissible α γ a c co q0 uBar
∃ C p : ℝ,
0 < C ∧
0 ≤ p ∧
(0 < γ → ∀ᶠ n : ℕ in atTop, (n : ℝ) ^ (-(rStar α γ)) + ((n : ℝ) * (qSched α γ a c q0 n) ^ 2) ^ (-(Aalpha α)) + rMu n * rE n / qSched α γ a c q0 n + rMu n * (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) + (rMu n) ^ 2 / uSched α γ a c uBar n ≤ C * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ p) ∧
(γ = 0 → ∀ᶠ n : ℕ in atTop, (n : ℝ) ^ (-(Aalpha α)) + rMu n * rE n ≤ C * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ p)
Proof (Lean source)
lemma clip_balance_exponent (α γ a c CMu CProd q0 uBar co : ℝ) (rMu rE : ℕ → ℝ) (hpoly : PolynomialNuisanceExponents rMu rE a c CMu CProd) (hCMu : 0 ≤ CMu) (hCProd : 0 ≤ CProd) (hrMu_nonneg : ∀ᶠ n : ℕ in atTop, 0 ≤ rMu n) (hq0 : 0 < q0) (huBar : 0 < γ → 0 < uBar) (hadm : 0 < γ → feasibleAdmissible α γ a c co q0 uBar) : ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ (0 < γ → ∀ᶠ n : ℕ in atTop, (n : ℝ) ^ (-(rStar α γ)) + ((n : ℝ) * (qSched α γ a c q0 n) ^ 2) ^ (-(Aalpha α)) + rMu n * rE n / qSched α γ a c q0 n + rMu n * (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) + (rMu n) ^ 2 / uSched α γ a c uBar n ≤ C * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ p) ∧ (γ = 0 → ∀ᶠ n : ℕ in atTop, (n : ℝ) ^ (-(Aalpha α)) + rMu n * rE n ≤ C * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ p) := by rcases hpoly with ⟨_ha, _hc, hpoly_eventual⟩ let Koff : ℝ := (q0 ^ 2) ^ (-(Aalpha α)) let Kprod : ℝ := CProd / q0 let Kmu : ℝ := CMu * |uBar| ^ (α / 2) * q0 ^ (1 / (2 * γ)) let Ksq : ℝ := CMu ^ 2 / |uBar| let C : ℝ := 2 + Koff + Kprod + Kmu + Ksq + CProd have hKoff_nonneg : 0 ≤ Koff := by dsimp [Koff] exact Real.rpow_nonneg (sq_nonneg q0) _ have hKprod_nonneg : 0 ≤ Kprod := by dsimp [Kprod] exact div_nonneg hCProd (le_of_lt hq0) have hKmu_nonneg : 0 ≤ Kmu := by dsimp [Kmu] exact mul_nonneg (mul_nonneg hCMu (Real.rpow_nonneg (abs_nonneg uBar) _)) (Real.rpow_nonneg (le_of_lt hq0) _) have hKsq_nonneg : 0 ≤ Ksq := by dsimp [Ksq] exact div_nonneg (sq_nonneg CMu) (abs_nonneg uBar) have hCpos : 0 < C := by dsimp [C] linarith refine ⟨C, 0, hCpos, by norm_num, ?_, ?_⟩ · intro hγ have hγne : γ ≠ 0 := ne_of_gt hγ have hr_def : rFeas α γ a c = min (rStar α γ) (gJoint α γ a c) := by simp [rFeas, hγne] have hr_le_star : rFeas α γ a c ≤ rStar α γ := by rw [hr_def] exact min_le_left _ _ have hr_le_gJoint : rFeas α γ a c ≤ gJoint α γ a c := by rw [hr_def] exact min_le_right _ _ have hvalue := feasibleMaximizer_value α γ a c hγ have hg_le_off : gJoint α γ a c ≤ Aalpha α * (1 - 2 * sFeas α γ a c) := by rw [← hvalue] calc feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) ≤ min (Aalpha α * (1 - 2 * sFeas α γ a c)) (c - sFeas α γ a c) := min_le_left _ _ _ ≤ Aalpha α * (1 - 2 * sFeas α γ a c) := min_le_left _ _ have hg_le_prod : gJoint α γ a c ≤ c - sFeas α γ a c := by rw [← hvalue] calc feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) ≤ min (Aalpha α * (1 - 2 * sFeas α γ a c)) (c - sFeas α γ a c) := min_le_left _ _ _ ≤ c - sFeas α γ a c := min_le_right _ _ have hg_le_mu : gJoint α γ a c ≤ a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2 := by rw [← hvalue] calc feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) ≤ min (a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2) (2 * a - tFeas α γ a c) := min_le_right _ _ _ ≤ a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2 := min_le_left _ _ have hg_le_sq : gJoint α γ a c ≤ 2 * a - tFeas α γ a c := by rw [← hvalue] calc feasiblePhi α γ a c (sFeas α γ a c) (tFeas α γ a c) ≤ min (a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2) (2 * a - tFeas α γ a c) := min_le_right _ _ _ ≤ 2 * a - tFeas α γ a c := min_le_right _ _ filter_upwards [hpoly_eventual, hrMu_nonneg, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hpoly_n hrMu0 hn1 have hnpos_nat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hnpos : 0 < (n : ℝ) := by exact_mod_cast hnpos_nat have hnnonneg : 0 ≤ (n : ℝ) := le_of_lt hnpos let base : ℝ := (n : ℝ) ^ (-(rFeas α γ a c)) have hbase_nonneg : 0 ≤ base := by dsimp [base] exact Real.rpow_nonneg hnnonneg _ have hterm_star : (n : ℝ) ^ (-(rStar α γ)) ≤ 1 * base := by dsimp [base] simpa using nat_rpow_neg_le_of_le hn1 hr_le_star have hterm_off_eq : ((n : ℝ) * (qSched α γ a c q0 n) ^ 2) ^ (-(Aalpha α)) = Koff * (n : ℝ) ^ (-(Aalpha α * (1 - 2 * sFeas α γ a c))) := by dsimp [Koff] rw [qSched, if_neg hγne] have hqpow_nonneg : 0 ≤ q0 * (n : ℝ) ^ (-(sFeas α γ a c)) := by positivity have hqpow_sq_nonneg : 0 ≤ (q0 * (n : ℝ) ^ (-(sFeas α γ a c))) ^ (2 : ℕ) := sq_nonneg _ rw [Real.mul_rpow hnnonneg hqpow_sq_nonneg] rw [← Real.rpow_natCast] rw [← Real.rpow_mul hqpow_nonneg] rw [Real.mul_rpow (le_of_lt hq0) (Real.rpow_nonneg hnnonneg _)] rw [Real.rpow_mul (le_of_lt hq0)] rw [← Real.rpow_mul hnnonneg] ring_nf conv_lhs => rw [mul_comm ((n : ℝ) ^ (-(Aalpha α))) ((q0 ^ 2) ^ (-(Aalpha α)))] rw [mul_assoc] rw [← Real.rpow_add hnpos] ring_nf rw [mul_comm] simp have hterm_off : ((n : ℝ) * (qSched α γ a c q0 n) ^ 2) ^ (-(Aalpha α)) ≤ Koff * base := by rw [hterm_off_eq] dsimp [base] exact mul_le_mul_of_nonneg_left (nat_rpow_neg_le_of_le hn1 (le_trans hr_le_gJoint hg_le_off)) hKoff_nonneg have hterm_prod_step : rMu n * rE n / qSched α γ a c q0 n ≤ Kprod * (n : ℝ) ^ (-(c - sFeas α γ a c)) := by have hq_pos : 0 < qSched α γ a c q0 n := by simp [qSched, hγne, hq0, Real.rpow_pos_of_pos hnpos] have hinv_nonneg : 0 ≤ (qSched α γ a c q0 n)⁻¹ := inv_nonneg.mpr (le_of_lt hq_pos) calc rMu n * rE n / qSched α γ a c q0 n = (rMu n * rE n) * (qSched α γ a c q0 n)⁻¹ := by rw [div_eq_mul_inv] _ ≤ (CProd * (n : ℝ) ^ (-c)) * (qSched α γ a c q0 n)⁻¹ := by exact mul_le_mul_of_nonneg_right hpoly_n.2 hinv_nonneg _ = Kprod * (n : ℝ) ^ (-(c - sFeas α γ a c)) := by dsimp [Kprod] rw [qSched, if_neg hγne, div_eq_mul_inv] rw [mul_inv] rw [Real.rpow_neg hnnonneg (sFeas α γ a c)] simp only [inv_inv] calc _ = CProd * q0⁻¹ * ((n : ℝ) ^ (-c) * (n : ℝ) ^ (sFeas α γ a c)) := by ring _ = CProd * q0⁻¹ * (n : ℝ) ^ (-c + sFeas α γ a c) := by rw [Real.rpow_add hnpos] _ = CProd * q0⁻¹ * (n : ℝ) ^ (-(c - sFeas α γ a c)) := by congr 2 ring have hterm_prod : rMu n * rE n / qSched α γ a c q0 n ≤ Kprod * base := by exact le_trans hterm_prod_step (mul_le_mul_of_nonneg_left (nat_rpow_neg_le_of_le hn1 (le_trans hr_le_gJoint hg_le_prod)) hKprod_nonneg) have hterm_mu_step : rMu n * (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) ≤ Kmu * (n : ℝ) ^ (-(a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2)) := by have hfactor_nonneg : 0 ≤ (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) := by have hu_sched_pos : 0 < uSched α γ a c uBar n := by simp [uSched, huBar hγ, Real.rpow_pos_of_pos hnpos] have hq_sched_pos : 0 < qSched α γ a c q0 n := by simp [qSched, hγne, hq0, Real.rpow_pos_of_pos hnpos] exact mul_nonneg (Real.rpow_nonneg (le_of_lt hu_sched_pos) _) (Real.rpow_nonneg (le_of_lt hq_sched_pos) _) calc rMu n * (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) = rMu n * ((uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ))) := by ring _ ≤ (CMu * (n : ℝ) ^ (-a)) * ((uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ))) := by exact mul_le_mul_of_nonneg_right hpoly_n.1 hfactor_nonneg _ = Kmu * (n : ℝ) ^ (-(a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2)) := by dsimp [Kmu] rw [abs_of_pos (huBar hγ)] rw [uSched, qSched, if_neg hγne] rw [Real.mul_rpow (le_of_lt (huBar hγ)) (Real.rpow_nonneg hnnonneg _)] rw [Real.mul_rpow (le_of_lt hq0) (Real.rpow_nonneg hnnonneg _)] rw [← Real.rpow_mul hnnonneg] rw [← Real.rpow_mul hnnonneg] calc _ = (CMu * uBar ^ (α / 2) * q0 ^ (1 / (2 * γ))) * ((n : ℝ) ^ (-a) * ((n : ℝ) ^ (-(tFeas α γ a c) * (α / 2)) * (n : ℝ) ^ (-(sFeas α γ a c) * (1 / (2 * γ))))) := by ring _ = (CMu * uBar ^ (α / 2) * q0 ^ (1 / (2 * γ))) * (n : ℝ) ^ (-(a + sFeas α γ a c / (2 * γ) + α * tFeas α γ a c / 2)) := by conv_lhs => rw [← Real.rpow_add hnpos] rw [← Real.rpow_add hnpos] congr 2 field_simp [hγne] ring have hterm_mu : rMu n * (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) ≤ Kmu * base := by exact le_trans hterm_mu_step (mul_le_mul_of_nonneg_left (nat_rpow_neg_le_of_le hn1 (le_trans hr_le_gJoint hg_le_mu)) hKmu_nonneg) have hterm_sq_step : (rMu n) ^ 2 / uSched α γ a c uBar n ≤ Ksq * (n : ℝ) ^ (-(2 * a - tFeas α γ a c)) := by have hsq : (rMu n) ^ 2 ≤ (CMu * (n : ℝ) ^ (-a)) ^ 2 := by have hrhs_nonneg : 0 ≤ CMu * (n : ℝ) ^ (-a) := mul_nonneg hCMu (Real.rpow_nonneg hnnonneg _) exact sq_le_sq' (by linarith) hpoly_n.1 have hu_pos : 0 < uSched α γ a c uBar n := by simp [uSched, huBar hγ, Real.rpow_pos_of_pos hnpos] have hinv_nonneg : 0 ≤ (uSched α γ a c uBar n)⁻¹ := inv_nonneg.mpr (le_of_lt hu_pos) calc (rMu n) ^ 2 / uSched α γ a c uBar n = (rMu n) ^ 2 * (uSched α γ a c uBar n)⁻¹ := by rw [div_eq_mul_inv] _ ≤ (CMu * (n : ℝ) ^ (-a)) ^ 2 * (uSched α γ a c uBar n)⁻¹ := by exact mul_le_mul_of_nonneg_right hsq hinv_nonneg _ = Ksq * (n : ℝ) ^ (-(2 * a - tFeas α γ a c)) := by -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.clip_balance_exponent · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/MasterBound.lean:1041
Helpers.OffsetControl 3 declarations Provides localized VC process and cross-fit offset-control helpers.

Provides localized VC process and cross-fit offset-control helpers.

theorem localized_vc_process_bound

lem:localized-vc-process-bound. Fixed-radius localized process bound: for an i.i.d. sample of size m, the EXPECTED localized supremum E_P Z_m(r) of the centered policy-indexed empirical process (P_m - P) g_π — with increment envelope B and conditional second moment ≤ C B² P_X(D_π) — is bounded by C B m^{-1/2} r^{α/(2+2α)}(log m)^p, combining margin_localization with the discharged finite-VC envelope.

Formal statement
P :
policySet :
Set (Policy 𝒳)
Cm α u0 :
dPi :
hpc :
PolicyClassVC policySet dPi
hmargin :
MarginTail P Cm α u0
hze :
ZeroEffectRegular P policySet
hwf :
hbdd :
`ass:vc-localized-envelope` (atomic empirical-process assumption), supplied from the `upperRisk` domain conjunct at the consumer; threaded, not discharged.
henv :
VCLocalizedEnvelope P policySet α
∃ C p : ℝ
if
0 < C ∧
0 ≤ p ∧
∀ (m : ℕ) (B r : ℝ) (g : Policy 𝒳 → Observation 𝒳 → ℝ), PolicyCompatible g
and
0 < m
and
0 ≤ B
and
0 ≤ r
and
(∀ π ∈ policySet, ∀ O, |g π O| ≤ B)
and
(∀ π ∈ policySet, ∫ O, (g π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P)))
then
expectedLocalizedSup (m := m) P g policySet r
≤ C * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log m) ^ p
Proof (Lean source)
lemma localized_vc_process_bound (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (Cm α u0 : ℝ) (dPi : ℕ) (hpc : PolicyClassVC policySet dPi) (hmargin : MarginTail P Cm α u0) (hze : ZeroEffectRegular P policySet) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) -- `ass:vc-localized-envelope` (atomic empirical-process assumption), supplied -- from the `upperRisk` domain conjunct at the consumer; threaded, not discharged. (henv : VCLocalizedEnvelope P policySet α) : ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ (m : ℕ) (B r : ℝ) (g : Policy 𝒳 → Observation 𝒳 → ℝ), PolicyCompatible g → 0 < m → 0 ≤ B → 0 ≤ r → (∀ π ∈ policySet, ∀ O, |g π O| ≤ B) → (∀ π ∈ policySet, ∫ O, (g π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → expectedLocalizedSup (m := m) P g policySet r ≤ C * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log m) ^ p := by simpa [VCLocalizedEnvelope, expectedLocalizedSup, centeredEmpProcess] using henv
CausalSmith.Stat.PolicyRegretMarginOverlap.localized_vc_process_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/OffsetControl.lean:19
theorem crossfit_localized_process_reduction

lem:crossfit-localized-process-reduction. Foldwise application plus balanced fixed-K collapse: conditioning on the training folds, each balanced evaluation fold is i.i.d., so localized_vc_process_bound applies foldwise. The conclusion records BOTH halves of the NL statement: (1) the CONDITIONAL-on-training-folds foldwise bound — each evaluation-fold centered increment process g k has expected localized supremum bounded at the same rate (this is the i.i.d.-per-fold deliverable that conditioning on the training fold supplies); and (2) HENCE the unconditional pooled bound — the pooled cross-fit centered process pooledCrossfitProcess (built from the foldwise increments g k via assign n) has expected localized supremum bounded by C B n^{-1/2} r^{α/(2+2α)}(log n)^p.

Formal statement
P :
policySet :
Set (Policy 𝒳)
Cm α u0 :
dPi K :
assign :
(n : ℕ) → Fin n → Fin K
hpc :
PolicyClassVC policySet dPi
hmargin :
MarginTail P Cm α u0
hze :
ZeroEffectRegular P policySet
hwf :
hbdd :
hK :
hiid :
`ass:vc-localized-envelope`, threaded from the `upperRisk` domain conjunct.
henv :
VCLocalizedEnvelope P policySet α
∃ C p : ℝ
if
0 < C ∧ 0 ≤ p ∧ ∀ (n : ℕ) (B r : ℝ) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ), 0 < n
and
0 ≤ B
and
0 ≤ r
and
(∀ k : Fin K, PolicyCompatible (g k))
and
(∀ (k : Fin K), ∀ π ∈ policySet, Measurable (g k π))
and
(hInt_pooledLocalized : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => |pooledCrossfitProcess P g (assign n) sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r})) (Measure.pi (fun _ : Fin n => P.dataMeasure)))
and
(hInt_foldLocalized : ∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldLocalizedSubSup P g (assign n) policySet r k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure)))
and
(∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B)
and
(∀ (k : Fin K), ∀ π ∈ policySet, ∫ O, (g k π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P)))
then
(∀ k : Fin K, expectedLocalizedSup (m := n) P (g k) policySet r ≤ C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p) ∧
expectedPooledLocalizedSup P g (assign n) policySet r
≤ C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p
Proof (Lean source)
lemma crossfit_localized_process_reduction (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (Cm α u0 : ℝ) (dPi K : ℕ) (assign : (n : ℕ) → Fin n → Fin K) (hpc : PolicyClassVC policySet dPi) (hmargin : MarginTail P Cm α u0) (hze : ZeroEffectRegular P policySet) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hK : FixedFoldCount K assign) (hiid : IsIIDSample P) -- `ass:vc-localized-envelope`, threaded from the `upperRisk` domain conjunct. (henv : VCLocalizedEnvelope P policySet α) : ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ (n : ℕ) (B r : ℝ) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ), 0 < n → 0 ≤ B → 0 ≤ r → -- The cross-fit increments factor through `π O.X` (note: `(π-π_⋆)·Γ`), so -- they are policy-compatible — the form the localized envelope applies to. (∀ k : Fin K, PolicyCompatible (g k)) → -- Increment measurability (note's increments are measurable): with the -- `PolicyClassVC` countable dense skeleton this makes the localized/offset -- `sSup` over `policySet` measurable+integrable (regularity-bookkeeping). (∀ (k : Fin K), ∀ π ∈ policySet, Measurable (g k π)) → -- regularity gate: empirical-process sSup measurability/integrability -- (vdV-Wellner; presupposed by the envelope; deferred Causalean infra, -- SUBSTRATE_DEBT). Pure Bochner regularity, no rate or bound content. (hInt_pooledLocalized : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => |pooledCrossfitProcess P g (assign n) sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r})) (Measure.pi (fun _ : Fin n => P.dataMeasure))) → (hInt_foldLocalized : ∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldLocalizedSubSup P g (assign n) policySet r k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure))) → (∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B) → (∀ (k : Fin K), ∀ π ∈ policySet, ∫ O, (g k π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → (∀ k : Fin K, expectedLocalizedSup (m := n) P (g k) policySet r ≤ C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p) ∧ expectedPooledLocalizedSup P g (assign n) policySet r ≤ C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p := by rcases henv with ⟨C0, p0, hC0, hp0, Henv⟩ let C : ℝ := C0 * (K : ℝ) have hKpos : 0 < K := hK.1 have hKposR : 0 < (K : ℝ) := by exact_mod_cast hKpos have hC : 0 < C := mul_pos hC0 hKposR refine ⟨C, p0, hC, hp0, ?_⟩ intro n B r g hn hB hr hcompat hmeas hInt_pooledLocalized hInt_foldLocalized hbound hsecond letI : IsProbabilityMeasure P.dataMeasure := hiid.1 have hC0_le_C : C0 ≤ C := by dsimp [C] have hKge1R : (1 : ℝ) ≤ (K : ℝ) := by exact_mod_cast Nat.succ_le_of_lt hKpos nlinarith [hC0, hKge1R] have hrate_nonneg : 0 ≤ B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p0 := by have hnR : 0 < (n : ℝ) := by exact_mod_cast hn have hlog : 0 ≤ log (n : ℝ) := Real.log_nonneg (by exact_mod_cast Nat.succ_le_of_lt hn) positivity constructor · intro k have hk := Henv n B r (g k) (hcompat k) hn hB hr (hbound k) (hsecond k) calc expectedLocalizedSup (m := n) P (g k) policySet r ≤ C0 * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p0 := by simpa [expectedLocalizedSup, centeredEmpProcess] using hk _ ≤ C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p0 := by simpa [mul_assoc] using mul_le_mul_of_nonneg_right hC0_le_C hrate_nonneg · classical let μn : Measure (Fin n → Observation 𝒳) := Measure.pi (fun _ : Fin n => P.dataMeasure) let w : Fin K → ℝ := fun k => (card (foldIndex (assign n) k) : ℝ) / (n : ℝ) let pooled : (Fin n → Observation 𝒳) → ℝ := fun sample => sSup ((fun π => |pooledCrossfitProcess P g (assign n) sample π|) '' {π | π ∈ policySet ∧ lawRegret P π ≤ r}) let folded : Fin K → (Fin n → Observation 𝒳) → ℝ := fun k sample => foldLocalizedSup P g (assign n) policySet r k sample have hw_nonneg : ∀ k, 0 ≤ w k := by intro k exact div_nonneg (by positivity) (by exact_mod_cast hn.le) have hInt_fold_full : ∀ k : Fin K, Integrable (folded k) μn := by intro k have hproj := measurePreserving_foldProjection P (assign n) k have hcomp := hproj.integrable_comp_of_integrable (g := fun sample : foldIndex (assign n) k → Observation 𝒳 => foldLocalizedSubSup P g (assign n) policySet r k sample) (hInt_foldLocalized k) simpa [folded, foldLocalizedSup, foldLocalizedSubSup, foldCenteredProcess, foldProjection, Function.comp_def] using hcomp have hInt_rhs : Integrable (fun sample : Fin n → Observation 𝒳 => ∑ k : Fin K, w k * folded k sample) μn := by simpa using (integrable_finset_sum (s := univ) (f := fun k sample => w k * folded k sample) (fun k _ => (hInt_fold_full k).const_mul (w k))) have hpoint : ∀ sample : Fin n → Observation 𝒳, pooled sample ≤ ∑ k : Fin K, w k * folded k sample := by intro sample simpa [pooled, folded, w] using pooledLocalizedSup_pointwise_le_sum_fold P g (assign n) policySet r B sample hn hB hbound have hmono : ∫ sample, pooled sample ∂μn ≤ ∫ sample, (∑ k : Fin K, w k * folded k sample) ∂μn := integral_mono hInt_pooledLocalized hInt_rhs hpoint let radiusRate : ℝ := r ^ (α / (2 + 2 * α)) let base : ℝ := C0 * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * radiusRate * (log (n : ℝ)) ^ p0 have hbase_nonneg : 0 ≤ base := by have hnR : 0 < (n : ℝ) := by exact_mod_cast hn have hlog : 0 ≤ log (n : ℝ) := Real.log_nonneg (by exact_mod_cast Nat.succ_le_of_lt hn) positivity have hfold_term_le : ∀ k : Fin K, w k * (∫ sample, folded k sample ∂μn) ≤ base := by intro k let m := card (foldIndex (assign n) k) by_cases hm0 : m = 0 · have hwzero : w k = 0 := by simp [w, m, hm0] simp [hwzero, hbase_nonneg] · have hmpos : 0 < m := Nat.pos_of_ne_zero hm0 have hmn : m ≤ n := by simpa [m] using foldIndex_card_le (assign n) k have heq : ∫ sample, folded k sample ∂μn = expectedLocalizedSup (m := m) P (g k) policySet r := by simpa [folded, μn, m] using integral_foldLocalizedSup_eq_expected P g (assign n) policySet r k hmpos (hInt_foldLocalized k) have henvk := Henv m B r (g k) (hcompat k) hmpos hB hr (hbound k) (hsecond k) have hfold_le : ∫ sample, folded k sample ∂μn ≤ C0 * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * radiusRate * (log (m : ℝ)) ^ p0 := by rw [heq] simpa [expectedLocalizedSup, centeredEmpProcess, radiusRate, m] using henvk have hmul_le : w k * (∫ sample, folded k sample ∂μn) ≤ w k * (C0 * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * radiusRate * (log (m : ℝ)) ^ p0) := mul_le_mul_of_nonneg_left hfold_le (hw_nonneg k) have hweight := fold_weight_mul_inv_sqrt_le hmpos hmn have hlog := log_nat_rpow_le hmpos hmn hp0 have hweight_nonneg : 0 ≤ ((m : ℝ) / (n : ℝ)) * (m : ℝ) ^ (-(1 / 2 : ℝ)) := by positivity have hlogm_nonneg : 0 ≤ (log (m : ℝ)) ^ p0 := Real.rpow_nonneg (Real.log_nonneg (by exact_mod_cast Nat.succ_le_of_lt hmpos)) p0 have hn_half_nonneg : 0 ≤ (n : ℝ) ^ (-(1 / 2 : ℝ)) := by positivity have hsize_core : (((m : ℝ) / (n : ℝ)) * (m : ℝ) ^ (-(1 / 2 : ℝ))) * (log (m : ℝ)) ^ p0 ≤ (n : ℝ) ^ (-(1 / 2 : ℝ)) * (log (n : ℝ)) ^ p0 := mul_le_mul hweight hlog hlogm_nonneg hn_half_nonneg have hconst_nonneg : 0 ≤ C0 * B * radiusRate := by positivity have hsize : w k * (C0 * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * radiusRate * (log (m : ℝ)) ^ p0) ≤ base := by calc w k * (C0 * B * (m : ℝ) ^ (-(1 / 2 : ℝ)) * radiusRate * (log (m : ℝ)) ^ p0) = (C0 * B * radiusRate) * ((((m : ℝ) / (n : ℝ)) * (m : ℝ) ^ (-(1 / 2 : ℝ))) * (log (m : ℝ)) ^ p0) := by simp [w, m] ring _ ≤ (C0 * B * radiusRate) * ((n : ℝ) ^ (-(1 / 2 : ℝ)) * (log (n : ℝ)) ^ p0) := mul_le_mul_of_nonneg_left hsize_core hconst_nonneg _ = base := by simp [base, radiusRate] ring exact hmul_le.trans hsize calc expectedPooledLocalizedSup P g (assign n) policySet r = ∫ sample, pooled sample ∂μn := by rfl _ ≤ ∫ sample, (∑ k : Fin K, w k * folded k sample) ∂μn := hmono _ = ∑ k : Fin K, ∫ sample, w k * folded k sample ∂μn := by simpa using (integral_finset_sum (s := univ) (f := fun k sample => w k * folded k sample) (fun k _ => (hInt_fold_full k).const_mul (w k))) _ = ∑ k : Fin K, w k * ∫ sample, folded k sample ∂μn := by simp [integral_const_mul] _ ≤ ∑ _k : Fin K, base := by exact Finset.sum_le_sum (fun k _ => hfold_term_le k) _ = C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * radiusRate * (log (n : ℝ)) ^ p0 := by simp [base, C] ring _ = C * B * (n : ℝ) ^ (-(1 / 2 : ℝ)) * r ^ (α / (2 + 2 * α)) * (log n) ^ p0 := by simp [radiusRate]
CausalSmith.Stat.PolicyRegretMarginOverlap.crossfit_localized_process_reduction · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/OffsetControl.lean:48
theorem crossfit_localized_offset_control Lemma 11 in the paper ↗

lem:crossfit-localized-offset-control. Pooled offset positive-part control: conditioning on training folds and applying the discharged offset envelope foldwise, the EXPECTED pooled cross-fit offset supremum E_P sup_π {2|G_cf(π)| - R_P(π)/4}_+ is bounded by C (B²/n)^{A_α}(log n)^p, A_α=(1+α)/(2+α). Stochastic input to localized_vc_self_bound; must not depend on it.

Formal statement
policySet :
Set (Policy 𝒳)
Cm α u0 :
dPi K :
assign :
(n : ℕ) → Fin n → Fin K
hpc :
PolicyClassVC policySet dPi
hK :
`ass:vc-localized-offset-envelope`, in its uniform class-level form.
hoffU :
∃ C p : ℝ,
0 < C ∧
0 ≤ p ∧
∀ (P : ObservedLaw 𝒳),
MarginTail P Cm α u0 → ZeroEffectRegular P policySet → IsIIDSample P → WellFormedLaw P → BoundedOutcome P → ∀ (n : ℕ) (B : ℝ) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ), 0 < n → 0
≤ B → (∀ k : Fin K, PolicyCompatible (g k)) → (∀ (k : Fin K), ∀ π ∈ policySet, Measurable (g k π)) → (hInt_pooledOffset : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure))) → (hInt_foldOffset : ∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P g (assign n) policySet k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure))) → (∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B) → (∀ (k : Fin K), ∀ π ∈ policySet, ∫ O, (g k π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → expectedPooledOffsetSup P g (assign n) policySet ≤ C * (B ^ 2 / (n : ℝ)) ^ ((1 + α) / (2 + α)) * (log n) ^ p
Proof (Lean source)
lemma crossfit_localized_offset_control (policySet : Set (Policy 𝒳)) (Cm α u0 : ℝ) (dPi K : ℕ) (assign : (n : ℕ) → Fin n → Fin K) (hpc : PolicyClassVC policySet dPi) (hK : FixedFoldCount K assign) -- `ass:vc-localized-offset-envelope`, in its uniform class-level form. (hoffU : VCLocalizedOffsetEnvelopeUnif policySet α) : ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ (P : ObservedLaw 𝒳), MarginTail P Cm α u0 → ZeroEffectRegular P policySet → IsIIDSample P → WellFormedLaw P → BoundedOutcome P → ∀ (n : ℕ) (B : ℝ) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ), 0 < n → 0 ≤ B → -- The cross-fit increments factor through `π O.X` (note: `(π-π_⋆)·Γ`), so -- they are policy-compatible — the form the localized offset envelope applies to. (∀ k : Fin K, PolicyCompatible (g k)) → -- Increment measurability (note's increments are measurable): with the -- `PolicyClassVC` countable dense skeleton this makes the localized/offset -- `sSup` over `policySet` measurable+integrable (regularity-bookkeeping). (∀ (k : Fin K), ∀ π ∈ policySet, Measurable (g k π)) → -- regularity gate: empirical-process sSup measurability/integrability -- (vdV-Wellner; presupposed by the envelope; deferred Causalean infra, -- SUBSTRATE_DEBT). Pure Bochner regularity, no rate or bound content. (hInt_pooledOffset : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure))) → (hInt_foldOffset : ∀ k : Fin K, Integrable (fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P g (assign n) policySet k sample) (Measure.pi (fun _ : foldIndex (assign n) k => P.dataMeasure))) → (∀ (k : Fin K), ∀ π ∈ policySet, ∀ O, |g k π O| ≤ B) → (∀ (k : Fin K), ∀ π ∈ policySet, ∫ O, (g k π O) ^ 2 ∂P.dataMeasure ≤ B ^ 2 * P.PX.real (disagreementSet π (lawOptimalPolicy P))) → expectedPooledOffsetSup P g (assign n) policySet ≤ C * (B ^ 2 / (n : ℝ)) ^ ((1 + α) / (2 + α)) * (log n) ^ p := by rcases hoffU with ⟨C0, p0, hC0, hp0, Hoff⟩ let C : ℝ := C0 * (K : ℝ) have hKpos : 0 < K := hK.1 have hKposR : 0 < (K : ℝ) := by exact_mod_cast hKpos have hC : 0 < C := mul_pos hC0 hKposR refine ⟨C, p0, hC, hp0, ?_⟩ intro P hmargin _hze hiid hwf hbdd n B g hn hB hcompat hmeas hInt_pooledOffset hInt_foldOffset hbound hsecond classical letI : IsProbabilityMeasure P.dataMeasure := hiid.1 let μn : Measure (Fin n → Observation 𝒳) := Measure.pi (fun _ : Fin n => P.dataMeasure) let A : ℝ := (1 + α) / (2 + α) let w : Fin K → ℝ := fun k => (card (foldIndex (assign n) k) : ℝ) / (n : ℝ) let pooled : (Fin n → Observation 𝒳) → ℝ := fun sample => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g (assign n) sample π| - lawRegret P π / 4)) '' policySet) let folded : Fin K → (Fin n → Observation 𝒳) → ℝ := fun k sample => foldOffsetSup P g (assign n) policySet k sample have hα_nonneg : 0 ≤ α := hmargin.1 have hdenpos : 0 < 2 + α := by linarith have hA1 : A ≤ 1 := by dsimp [A] exact div_le_one_of_le₀ (by linarith) hdenpos.le have hw_nonneg : ∀ k, 0 ≤ w k := by intro k exact div_nonneg (by positivity) (by exact_mod_cast hn.le) have hInt_fold_full : ∀ k : Fin K, Integrable (folded k) μn := by intro k have hproj := measurePreserving_foldProjection P (assign n) k have hcomp := hproj.integrable_comp_of_integrable (g := fun sample : foldIndex (assign n) k → Observation 𝒳 => foldOffsetSubSup P g (assign n) policySet k sample) (hInt_foldOffset k) simpa [folded, foldOffsetSup, foldOffsetSubSup, foldCenteredProcess, foldProjection, Function.comp_def] using hcomp have hInt_rhs : Integrable (fun sample : Fin n → Observation 𝒳 => ∑ k : Fin K, w k * folded k sample) μn := by simpa using (integrable_finset_sum (s := univ) (f := fun k sample => w k * folded k sample) (fun k _ => (hInt_fold_full k).const_mul (w k))) have hpoint : ∀ sample : Fin n → Observation 𝒳, pooled sample ≤ ∑ k : Fin K, w k * folded k sample := by intro sample simpa [pooled, folded, w] using pooledOffsetSup_pointwise_le_sum_fold P g (assign n) policySet B sample hpc hwf hbdd hn hB hbound have hmono : ∫ sample, pooled sample ∂μn ≤ ∫ sample, (∑ k : Fin K, w k * folded k sample) ∂μn := integral_mono hInt_pooledOffset hInt_rhs hpoint let base : ℝ := C0 * (B ^ 2 / (n : ℝ)) ^ A * (log (n : ℝ)) ^ p0 have hbase_nonneg : 0 ≤ base := by have hnR : 0 < (n : ℝ) := by exact_mod_cast hn have hlog : 0 ≤ log (n : ℝ) := Real.log_nonneg (by exact_mod_cast Nat.succ_le_of_lt hn) positivity have hfold_term_le : ∀ k : Fin K, w k * (∫ sample, folded k sample ∂μn) ≤ base := by intro k let m := card (foldIndex (assign n) k) by_cases hm0 : m = 0 · have hwzero : w k = 0 := by simp [w, m, hm0] simp [hwzero, hbase_nonneg] · have hmpos : 0 < m := Nat.pos_of_ne_zero hm0 have hmn : m ≤ n := by simpa [m] using foldIndex_card_le (assign n) k have heq : ∫ sample, folded k sample ∂μn = ∫ sample, sSup ((fun π => max 0 (2 * |centeredEmpProcess P (g k) sample π| - lawRegret P π / 4)) '' policySet) ∂(Measure.pi (fun _ : Fin m => P.dataMeasure)) := by simpa [folded, μn, m] using integral_foldOffsetSup_eq_expected P g (assign n) policySet k hmpos (hInt_foldOffset k) have hoffk := Hoff P m B (g k) (hcompat k) hmpos hB (hbound k) (hsecond k) have hfold_le : ∫ sample, folded k sample ∂μn ≤ C0 * (B ^ 2 / (m : ℝ)) ^ A * (log (m : ℝ)) ^ p0 := by rw [heq] simpa [centeredEmpProcess, A, m] using hoffk have hmul_le : w k * (∫ sample, folded k sample ∂μn) ≤ w k * (C0 * (B ^ 2 / (m : ℝ)) ^ A * (log (m : ℝ)) ^ p0) := mul_le_mul_of_nonneg_left hfold_le (hw_nonneg k) have hweight := fold_weight_mul_offset_rpow_le (B := B) (A := A) hmpos hmn hA1 have hlog := log_nat_rpow_le hmpos hmn hp0 have hweight_nonneg : 0 ≤ ((m : ℝ) / (n : ℝ)) * (B ^ 2 / (m : ℝ)) ^ A := by positivity have hlogm_nonneg : 0 ≤ (log (m : ℝ)) ^ p0 := Real.rpow_nonneg (Real.log_nonneg (by exact_mod_cast Nat.succ_le_of_lt hmpos)) p0 have hbase_factor_nonneg : 0 ≤ (B ^ 2 / (n : ℝ)) ^ A := by positivity have hsize_core : (((m : ℝ) / (n : ℝ)) * (B ^ 2 / (m : ℝ)) ^ A) * (log (m : ℝ)) ^ p0 ≤ (B ^ 2 / (n : ℝ)) ^ A * (log (n : ℝ)) ^ p0 := mul_le_mul hweight hlog hlogm_nonneg hbase_factor_nonneg have hsize : w k * (C0 * (B ^ 2 / (m : ℝ)) ^ A * (log (m : ℝ)) ^ p0) ≤ base := by calc w k * (C0 * (B ^ 2 / (m : ℝ)) ^ A * (log (m : ℝ)) ^ p0) = C0 * ((((m : ℝ) / (n : ℝ)) * (B ^ 2 / (m : ℝ)) ^ A) * (log (m : ℝ)) ^ p0) := by simp [w, m] ring _ ≤ C0 * ((B ^ 2 / (n : ℝ)) ^ A * (log (n : ℝ)) ^ p0) := mul_le_mul_of_nonneg_left hsize_core hC0.le _ = base := by simp [base] ring exact hmul_le.trans hsize calc expectedPooledOffsetSup P g (assign n) policySet = ∫ sample, pooled sample ∂μn := by rfl _ ≤ ∫ sample, (∑ k : Fin K, w k * folded k sample) ∂μn := hmono _ = ∑ k : Fin K, ∫ sample, w k * folded k sample ∂μn := by simpa using (integral_finset_sum (s := univ) (f := fun k sample => w k * folded k sample) (fun k _ => (hInt_fold_full k).const_mul (w k))) _ = ∑ k : Fin K, w k * ∫ sample, folded k sample ∂μn := by simp [integral_const_mul] _ ≤ ∑ _k : Fin K, base := by exact Finset.sum_le_sum (fun k _ => hfold_term_le k) _ = C * (B ^ 2 / (n : ℝ)) ^ A * (log (n : ℝ)) ^ p0 := by simp [base, C] ring _ = C * (B ^ 2 / (n : ℝ)) ^ ((1 + α) / (2 + α)) * (log n) ^ p0 := by simp [A]
CausalSmith.Stat.PolicyRegretMarginOverlap.crossfit_localized_offset_control · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/OffsetControl.lean:278
Helpers.SelfBound 1 declarations Provides the localized VC self-bound helper.

Provides the localized VC self-bound helper.

theorem localized_vc_self_bound Lemma 10 in the paper ↗

lem:localized-vc-self-bound. EXPECTED-risk self-localized selection bound from the offset-control node. With ρ_n = (B²/n)^{A_α}(log n)^p, B ≥ 1, the EXPECTED pooled offset positive-part supremum controlled by ρ_n (the bound supplied by crossfit_localized_offset_control, hoff), and any data-dependent Π-valued selector π̃ satisfying the SAMPLE-WISE selection inequality R_P(π̃(sample)) ≤ 2|G_cf(sample, π̃(sample))| + δ, the EXPECTED regret obeys E_P R_P(π̃) ≤ C{ρ_n + δ}, and if δ ≤ 1/n the δ term is absorbed into C ρ_n.

Formal statement
n K :
P :
policySet :
Set (Policy 𝒳)
α B δ Coff p :
g :
Fin K → Policy 𝒳 → Observation 𝒳 → ℝ
assign :
Fin n → Fin K
πt :
(Fin n → Observation 𝒳) → Policy 𝒳
hprob :
IsProbabilityMeasure P.dataMeasure
hB :
1 ≤ B
hn :
0 < n
hp :
0 ≤ p
hδ_nonneg :
0 ≤ δ
hmem :
∀ sample, πt sample ∈ policySet
hoff :
expectedPooledOffsetSup P g assign policySet
≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p)
hlarge :
(n : ℝ)⁻¹ ≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p)
hInt_regret :
Integrable (fun sample : Fin n → Observation 𝒳 => lawRegret P (πt sample)) (Measure.pi (fun _ : Fin n => P.dataMeasure))
hInt_offset :
Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure))
hbdd_offset :
∀ sample : Fin n → Observation 𝒳,
BddAbove ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet)
hsel :
∀ sample,
lawRegret P (πt sample) ≤ 2 * |pooledCrossfitProcess P g assign sample (πt sample)| + δ
0 < (8 / 3 : ℝ) ∧
∫ sample, lawRegret P (πt sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure))
≤ (8 / 3 : ℝ) * (Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p) + δ) ∧
(δ ≤ (n : ℝ)⁻¹ → ∫ sample, lawRegret P (πt sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ (8 / 3 : ℝ) * (Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p)))
Proof (Lean source)
lemma localized_vc_self_bound {n K : ℕ} (P : ObservedLaw 𝒳) (policySet : Set (Policy 𝒳)) (α B δ Coff p : ℝ) (g : Fin K → Policy 𝒳 → Observation 𝒳 → ℝ) (assign : Fin n → Fin K) (πt : (Fin n → Observation 𝒳) → Policy 𝒳) (hprob : IsProbabilityMeasure P.dataMeasure) (hB : 1 ≤ B) (hn : 0 < n) (hp : 0 ≤ p) (hδ_nonneg : 0 ≤ δ) (hmem : ∀ sample, πt sample ∈ policySet) (hoff : expectedPooledOffsetSup P g assign policySet ≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p)) (hlarge : (n : ℝ)⁻¹ ≤ Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p)) (hInt_regret : Integrable (fun sample : Fin n → Observation 𝒳 => lawRegret P (πt sample)) (Measure.pi (fun _ : Fin n => P.dataMeasure))) (hInt_offset : Integrable (fun sample : Fin n → Observation 𝒳 => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet)) (Measure.pi (fun _ : Fin n => P.dataMeasure))) (hbdd_offset : ∀ sample : Fin n → Observation 𝒳, BddAbove ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet)) (hsel : ∀ sample, lawRegret P (πt sample) ≤ 2 * |pooledCrossfitProcess P g assign sample (πt sample)| + δ) : 0 < (8 / 3 : ℝ) ∧ ∫ sample, lawRegret P (πt sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ (8 / 3 : ℝ) * (Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p) + δ) ∧ (δ ≤ (n : ℝ)⁻¹ → ∫ sample, lawRegret P (πt sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) ≤ (8 / 3 : ℝ) * (Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p))) := by classical letI : IsProbabilityMeasure P.dataMeasure := hprob let μn : Measure (Fin n → Observation 𝒳) := Measure.pi (fun _ : Fin n => P.dataMeasure) let ρ : ℝ := Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p) let offset : (Fin n → Observation 𝒳) → ℝ := fun sample => sSup ((fun π => max 0 (2 * |pooledCrossfitProcess P g assign sample π| - lawRegret P π / 4)) '' policySet) have hnR : 0 < (n : ℝ) := by exact_mod_cast hn have hρ_pos : 0 < ρ := lt_of_lt_of_le (inv_pos.mpr hnR) (by simpa [ρ] using hlarge) have hρ_nonneg : 0 ≤ ρ := hρ_pos.le have hselected_le_offset : ∀ sample : Fin n → Observation 𝒳, max 0 (2 * |pooledCrossfitProcess P g assign sample (πt sample)| - lawRegret P (πt sample) / 4) ≤ offset sample := by intro sample dsimp [offset] exact le_csSup (hbdd_offset sample) ⟨πt sample, hmem sample, rfl⟩ have hpoint : ∀ sample : Fin n → Observation 𝒳, lawRegret P (πt sample) ≤ (4 / 3 : ℝ) * offset sample + (4 / 3 : ℝ) * δ := by intro sample let R : ℝ := lawRegret P (πt sample) let z : ℝ := pooledCrossfitProcess P g assign sample (πt sample) let a : ℝ := 2 * |z| - R / 4 have hsel' : R ≤ 2 * |z| + δ := by simpa [R, z] using hsel sample have hthree_quarters : (3 / 4 : ℝ) * R ≤ a + δ := by dsimp [a] nlinarith have hcore : R ≤ (4 / 3 : ℝ) * max 0 a + (4 / 3 : ℝ) * δ := by by_cases ha : 0 ≤ a · have hmax : max 0 a = a := max_eq_right ha calc R = (4 / 3 : ℝ) * ((3 / 4 : ℝ) * R) := by ring _ ≤ (4 / 3 : ℝ) * (a + δ) := by nlinarith _ = (4 / 3 : ℝ) * max 0 a + (4 / 3 : ℝ) * δ := by rw [hmax] ring · have ha_lt : a < 0 := lt_of_not_ge ha have hmax : max 0 a = 0 := max_eq_left (le_of_lt ha_lt) have hthree_quarters_delta : (3 / 4 : ℝ) * R ≤ δ := by nlinarith calc R = (4 / 3 : ℝ) * ((3 / 4 : ℝ) * R) := by ring _ ≤ (4 / 3 : ℝ) * δ := by nlinarith _ = (4 / 3 : ℝ) * max 0 a + (4 / 3 : ℝ) * δ := by rw [hmax] ring have hoff_le := hselected_le_offset sample calc lawRegret P (πt sample) = R := rfl _ ≤ (4 / 3 : ℝ) * max 0 a + (4 / 3 : ℝ) * δ := hcore _ ≤ (4 / 3 : ℝ) * offset sample + (4 / 3 : ℝ) * δ := by nlinarith have hInt_rhs : Integrable (fun sample : Fin n → Observation 𝒳 => (4 / 3 : ℝ) * offset sample + (4 / 3 : ℝ) * δ) μn := by exact (hInt_offset.const_mul (4 / 3 : ℝ)).add (integrable_const ((4 / 3 : ℝ) * δ)) have hmono : ∫ sample, lawRegret P (πt sample) ∂μn ≤ ∫ sample, ((4 / 3 : ℝ) * offset sample + (4 / 3 : ℝ) * δ) ∂μn := integral_mono (by simpa [μn] using hInt_regret) hInt_rhs hpoint have hoffρ : ∫ sample, offset sample ∂μn ≤ ρ := by simpa [expectedPooledOffsetSup, offset, μn, ρ] using hoff have hrhs_eval : ∫ sample, ((4 / 3 : ℝ) * offset sample + (4 / 3 : ℝ) * δ) ∂μn = (4 / 3 : ℝ) * ∫ sample, offset sample ∂μn + (4 / 3 : ℝ) * δ := by rw [integral_add] · rw [integral_const_mul] simp [μn, offset] · exact hInt_offset.const_mul (4 / 3 : ℝ) · exact integrable_const ((4 / 3 : ℝ) * δ) have hmain : ∫ sample, lawRegret P (πt sample) ∂μn ≤ (4 / 3 : ℝ) * ρ + (4 / 3 : ℝ) * δ := by calc ∫ sample, lawRegret P (πt sample) ∂μn ≤ ∫ sample, ((4 / 3 : ℝ) * offset sample + (4 / 3 : ℝ) * δ) ∂μn := hmono _ = (4 / 3 : ℝ) * ∫ sample, offset sample ∂μn + (4 / 3 : ℝ) * δ := hrhs_eval _ ≤ (4 / 3 : ℝ) * ρ + (4 / 3 : ℝ) * δ := by nlinarith refine ⟨by norm_num, ?_, ?_⟩ · calc ∫ sample, lawRegret P (πt sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) = ∫ sample, lawRegret P (πt sample) ∂μn := rfl _ ≤ (4 / 3 : ℝ) * ρ + (4 / 3 : ℝ) * δ := hmain _ = (4 / 3 : ℝ) * (ρ + δ) := by ring _ ≤ (8 / 3 : ℝ) * (ρ + δ) := by have hρδ : 0 ≤ ρ + δ := add_nonneg hρ_nonneg hδ_nonneg nlinarith _ = (8 / 3 : ℝ) * (Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p) + δ) := by simp [ρ] · intro hδ_le calc ∫ sample, lawRegret P (πt sample) ∂(Measure.pi (fun _ : Fin n => P.dataMeasure)) = ∫ sample, lawRegret P (πt sample) ∂μn := rfl _ ≤ (4 / 3 : ℝ) * ρ + (4 / 3 : ℝ) * δ := hmain _ ≤ (4 / 3 : ℝ) * ρ + (4 / 3 : ℝ) * (n : ℝ)⁻¹ := by nlinarith _ ≤ (4 / 3 : ℝ) * ρ + (4 / 3 : ℝ) * ρ := by have hlarge' : (n : ℝ)⁻¹ ≤ ρ := by simpa [ρ] using hlarge nlinarith _ = (8 / 3 : ℝ) * ρ := by ring _ = (8 / 3 : ℝ) * (Coff * ((B ^ 2 / (n : ℝ)) ^ (Aalpha α) * (log n) ^ p)) := by simp [ρ, mul_assoc]
CausalSmith.Stat.PolicyRegretMarginOverlap.localized_vc_self_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/Helpers/SelfBound.lean:19
T_feasible_tight 1 declarations
def FeasibleTightQuestion Definition 12 in the paper ↗

oeq:feasible-tight (OPEN research question — STATED, not proven).

Definition (Lean source)
def FeasibleTightQuestion {𝒳 : Type*} [MeasurableSpace 𝒳] {K : ℕ} (α γ Cm u0 Co co underlineP a c CMu CProd q0 : ℝ) (dPi : ℕ) (policySet : Set (Policy 𝒳)) (enum : ℕ → Policy 𝒳) (assign : (m : ℕ) → Fin m → Fin K) (rMu rE : ℕ → ℝ) : Prop := -- The achievability predicate: SOME genuinely feasible cross-fitted-nuisance estimator -- attains the converse exponent `r_⋆` over a GENUINELY INHABITED feasible side-condition -- domain. SCAFFOLD REDIRECT: the `∃ P …` guard must witness the SAME bundled domain that -- `upperRisk` takes its `sSup` over (`def:upper-risk`), otherwise an EMPTY `upperRisk` -- domain (`sSup ∅ = 0`) would satisfy `Attains` vacuously. So the guard pins ALL the -- `upperRisk` side conditions: `IsIIDSample` (`ass:iid`), `NuisanceRate` (`ass:nuisance-rate`), -- `PolicyClassVC` (`ass:policy-class`), the two localized VC envelopes -- (`ass:vc-localized-envelope`, `ass:vc-localized-offset-envelope`), `FixedFoldCount` -- (`ass:fixed-crossfit-fold-count`), and `DenseSkeleton` (the dense-`Π₀` enumeration), in -- addition to the `BoundedCrossfitNuisances`/`PolynomialNuisanceExponents` conjuncts already -- carried in the outer existential — exactly the genuinely feasible domain of `def:upper-risk`. let Attains : Prop := (∃ muHat0 muHat1 eHat : ℕ → Fin K → 𝒳 → ℝ, (∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) ∧ PolynomialNuisanceExponents rMu rE a c CMu CProd ∧ (∃ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P ∧ OptimalInClass P policySet ∧ IsIIDSample P ∧ (∀ k : Fin K, NuisanceRate P (fun m => muHat0 m k) (fun m => muHat1 m k) (fun m => eHat m k) rMu rE) ∧ PolicyClassVC policySet dPi ∧ VCLocalizedEnvelope P policySet α ∧ VCLocalizedOffsetEnvelope P policySet α ∧ FixedFoldCount K assign ∧ DenseSkeleton enum policySet) ∧ ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ᶠ n : ℕ in atTop, upperRisk (n := n) α γ Cm u0 Co co underlineP a c CMu CProd q0 dPi policySet enum muHat0 muHat1 eHat assign rMu rE ≤ C * (n : ℝ) ^ (-(rStar α γ)) * (log n) ^ p) -- The SUBSTANTIVE slower-exponent alternative: weak-arm nuisance learning genuinely -- IMPOSES the slower conditional exponent `g_joint` — over an inhabited feasible domain, -- EVERY feasible cross-fitted-nuisance estimator has worst-case risk `U_n` bounded BELOW -- by `c' n^{-g_joint}` (so NO feasible estimator attains `r_⋆`; the feasible rate is -- exactly `g_joint`, matching the proven `U_n ≤ C n^{-g_joint}` upper bound). This is the -- `∀`-over-estimators DETERMINATION the NL asks for — not the trivial `¬ Attains` -- (a classical tautology) nor a single failing-config existential. -- UNIFORM CONVERSE-FLOOR CONSTANT (scaffold redirect): the floor constant `c'` is -- quantified ABOVE the `∀`-over-estimators, so a SINGLE `c' > 0` (depending only on the -- regime/class, not on the particular feasible estimator) certifies the `g_joint` floor -- uniformly over the whole feasible-estimator class — the "feasible rate is exactly -- `g_joint`" determination, with the converse constant chosen BEFORE fixing the estimator -- (mirroring the uniform `c(C_χ)` of `lem:le-cam-two-point-chisq`), not after. let SlowerImposed : Prop := (∃ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P ∧ OptimalInClass P policySet) ∧ (∃ c' : ℝ, 0 < c' ∧ ∀ muHat0 muHat1 eHat : ℕ → Fin K → 𝒳 → ℝ, (∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) → PolynomialNuisanceExponents rMu rE a c CMu CProd → ∀ᶠ n : ℕ in atTop, c' * (n : ℝ) ^ (-(gJoint α γ a c)) ≤ upperRisk (n := n) α γ Cm u0 Co co underlineP a c CMu CProd q0 dPi policySet enum muHat0 muHat1 eHat assign rMu rE) -- The OPEN DICHOTOMY (STATED, not resolved): for the genuine pointwise-dense-skeleton -- ERM (`DenseSkeleton enum policySet`, the note's dense-`Π₀` enumeration condition on -- `enum`), in the strict-gap branch, EITHER some feasible estimator attains `r_⋆` -- (`Attains`) OR the slower exponent `g_joint` is genuinely imposed for every feasible -- estimator (`SlowerImposed`). DenseSkeleton enum policySet → gJoint α γ a c < rStar α γ → (Attains ∨ SlowerImposed)
CausalSmith.Stat.PolicyRegretMarginOverlap.FeasibleTightQuestion · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_feasible_tight.lean:24
T_feasible_upper 1 declarations
theorem feasible_upper Theorem 4 in the paper ↗

oeq:feasible-upper (CONDITIONAL achievability). The regime-indexed conditional upper risk U_n = upperRisk … — whose estimator IS the cross-fit clipped-AIPW 1/n-ERM feasibleERM run with the SELECTED schedule clip q_n = qSched α γ a c q0 n, supremized over the bundled def:law-class/optimal/finite-VC/foldwise nuisance-rate side-condition domain at the fixed regime (a,c,C_μ,C_prod) — achieves the UNIFORM EVENTUAL rate bound U_n ≤ C n^{-r_feas}(log n)^p (r_feas = (feasibleRate …).r, the solved exponent of the certified def:feasible-rate object built from hinputs), using only the crude q^{-2} score envelope, the uniform class-level localized finite-VC envelopes, and the deterministic clip-bias controls. CRUCIALLY the constants C, p are chosen BEFORE n (quantified outside the ∀ᶠ n in atTop), so this encodes the paper's uniform eventual conditional rate bound over n — a single pair (C,p) controlling U_n for ALL large n — not a per-n bound with constants chosen after n (which would be vacuous). The def:feasible-rate INPUT-domain restrictions — ū ∈ (0,u₀], q₀ ∈ (0, min{1/2, c_o ū^γ}] for γ>0 and the strict-overlap endpoint clip q₀ ∈ (0, underline_p/2] for γ=0 — are carried as hinputs (FeasibleRateInputs); the schedule admissibility q_n ≤ c_o u_n^γ is now BUNDLED INTO the certified feasibleRate … hinputs object (its admissible field, derived from hinputs) rather than carried as a separate hypothesis.

Formal statement
K :
α γ Cm u0 Co co underlineP a c CMu CProd q0 uBar :
dPi :
assign :
(m : ℕ) → Fin m → Fin K
policySet :
Set (Policy 𝒳)
enum :
ℕ → Policy 𝒳
muHat0 muHat1 eHat :
ℕ → Fin K → 𝒳 → ℝ
rMu rE :
ℕ → ℝ
:
0 ≤ γ
hpoly :
PolynomialNuisanceExponents rMu rE a c CMu CProd
hCMu :
0 ≤ CMu
hCProd :
0 ≤ CProd
hrMu_nonneg :
∀ᶠ n : ℕ in atTop, 0 ≤ rMu n
hrE_nonneg :
∀ᶠ n : ℕ in atTop, 0 ≤ rE n
hμ0meas :
∀ n k, Measurable (muHat0 n k)
hμ1meas :
∀ n k, Measurable (muHat1 n k)
hemeas :
∀ n k, Measurable (eHat n k)
hμ0L2 :
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat0 n k x - P.mu0 x) 2 P.PX
hμ1L2 :
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat1 n k x - P.mu1 x) 2 P.PX
heL2 :
∀ᶠ n : ℕ in atTop,
∀ P : ObservedLaw 𝒳,
LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => eHat n k x - P.propensity x) 2 P.PX
hvc :
PolicyClassVC policySet dPi
henvU :
hoffU :
hK :
hbn :
∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)
hskel :
DenseSkeleton enum policySet
hinputs :
FeasibleRateInputs γ co underlineP u0 q0 uBar
∃ C p : ℝ,
0 < C ∧
0 ≤ p ∧
∀ᶠ n : ℕ in atTop,
upperRisk (n := n) α γ Cm u0 Co co underlineP a c CMu CProd q0 dPi policySet enum muHat0 muHat1 eHat assign rMu rE
≤ C * (n : ℝ) ^ (-(feasibleRate α γ a c co underlineP u0 q0 uBar hinputs).r) * (log n) ^ p
Proof (Lean source)
theorem feasible_upper {K : ℕ} (α γ Cm u0 Co co underlineP a c CMu CProd q0 uBar : ℝ) (dPi : ℕ) (assign : (m : ℕ) → Fin m → Fin K) (policySet : Set (Policy 𝒳)) (enum : ℕ → Policy 𝒳) (muHat0 muHat1 eHat : ℕ → Fin K → 𝒳 → ℝ) (rMu rE : ℕ → ℝ) (hγ : 0 ≤ γ) (hpoly : PolynomialNuisanceExponents rMu rE a c CMu CProd) (hCMu : 0 ≤ CMu) (hCProd : 0 ≤ CProd) (hrMu_nonneg : ∀ᶠ n : ℕ in atTop, 0 ≤ rMu n) (hrE_nonneg : ∀ᶠ n : ℕ in atTop, 0 ≤ rE n) (hμ0meas : ∀ n k, Measurable (muHat0 n k)) (hμ1meas : ∀ n k, Measurable (muHat1 n k)) (hemeas : ∀ n k, Measurable (eHat n k)) (hμ0L2 : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat0 n k x - P.mu0 x) 2 P.PX) (hμ1L2 : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => muHat1 n k x - P.mu1 x) 2 P.PX) (heL2 : ∀ᶠ n : ℕ in atTop, ∀ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P → ∀ k : Fin K, MemLp (fun x => eHat n k x - P.propensity x) 2 P.PX) (hvc : PolicyClassVC policySet dPi) (henvU : VCLocalizedEnvelopeUnif policySet α) (hoffU : VCLocalizedOffsetEnvelopeUnif policySet α) (hK : FixedFoldCount K assign) (hbn : ∀ k : Fin K, BoundedCrossfitNuisances (fun m => muHat0 m k) (fun m => muHat1 m k)) (hskel : DenseSkeleton enum policySet) (hinputs : FeasibleRateInputs γ co underlineP u0 q0 uBar) : ∃ C p : ℝ, 0 < C ∧ 0 ≤ p ∧ ∀ᶠ n : ℕ in atTop, upperRisk (n := n) α γ Cm u0 Co co underlineP a c CMu CProd q0 dPi policySet enum muHat0 muHat1 eHat assign rMu rE ≤ C * (n : ℝ) ^ (-(feasibleRate α γ a c co underlineP u0 q0 uBar hinputs).r) * (log n) ^ p := by classical have hq0 : 0 < q0 := by by_cases hγ0 : γ = 0 · exact (hinputs.2 hγ0).1 · have hγpos : 0 < γ := lt_of_le_of_ne hγ (Ne.symm hγ0) exact (hinputs.1 hγpos).2.2.1 have huBar : 0 < γ → 0 < uBar := fun hγpos => (hinputs.1 hγpos).1 have hadm : 0 < γ → feasibleAdmissible α γ a c co q0 uBar := fun hγpos => (feasibleRate α γ a c co underlineP u0 q0 uBar hinputs).admissible hγpos have hq_sched_pos : ∀ᶠ n : ℕ in atTop, 0 < qSched α γ a c q0 n := by by_cases hγ0 : γ = 0 · rw [Filter.eventually_atTop] exact ⟨0, fun _n _hn => by simpa [qSched, hγ0] using hq0⟩ · filter_upwards [Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hn have hnpos : 0 < (n : ℝ) := by exact_mod_cast (lt_of_lt_of_le (by norm_num : 0 < (1 : ℕ)) hn) simp [qSched, hγ0, hq0, Real.rpow_pos_of_pos hnpos] by_cases hempty_zero : γ = 0 ∧ ¬ ∃ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P · refine ⟨1, 0, by norm_num, by norm_num, ?_⟩ filter_upwards [Filter.eventually_atTop.mpr ⟨2, fun n hn => hn⟩] with n hn2 have hnposNat : 0 < n := lt_of_lt_of_le (by norm_num : 0 < (2 : ℕ)) hn2 have hnpos : 0 < (n : ℝ) := by exact_mod_cast hnposNat have hbound_nonneg : 0 ≤ (1 : ℝ) * (n : ℝ) ^ (-(feasibleRate α γ a c co underlineP u0 q0 uBar hinputs).r) * (log n) ^ (0 : ℝ) := by positivity apply Real.sSup_le ?_ hbound_nonneg rintro y ⟨P, hP, rfl⟩ exact elim (hempty_zero.2 ⟨P, hP.1⟩) have hq_half : ∀ᶠ n : ℕ in atTop, qSched α γ a c q0 n ≤ 1 / 2 := by by_cases hγ0 : γ = 0 · have hnonempty : ∃ P : ObservedLaw 𝒳, LawClass α γ Cm u0 Co co underlineP policySet P := by by_contra hnone exact hempty_zero ⟨hγ0, hnone⟩ rcases hnonempty with ⟨P0, hLaw0⟩ have hunder_half : underlineP ≤ 1 / 2 := (hLaw0.strict hγ0).2.1 have hq0_le_under : q0 ≤ underlineP / 2 := (hinputs.2 hγ0).2 have hq0_le_half : q0 ≤ 1 / 2 := by nlinarith rw [Filter.eventually_atTop] exact ⟨0, fun _n _hn => by simpa [qSched, hγ0] using hq0_le_half⟩ · have hγpos : 0 < γ := lt_of_le_of_ne hγ (Ne.symm hγ0) rcases feasibleMaximizer_mem α γ a c hγpos with ⟨hs0, _hs1, _ht0, _ht1⟩ have hq0_le_half : q0 ≤ 1 / 2 := le_trans (hinputs.1 hγpos).2.2.2 (min_le_left _ _) filter_upwards [Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hn have hn1 : (1 : ℝ) ≤ (n : ℝ) := by exact_mod_cast hn have hp_le_one : (n : ℝ) ^ (-(sFeas α γ a c)) ≤ 1 := by exact Real.rpow_le_one_of_one_le_of_nonpos hn1 (by linarith) calc qSched α γ a c q0 n = q0 * (n : ℝ) ^ (-(sFeas α γ a c)) := by simp [qSched, hγ0] _ ≤ q0 * 1 := by exact mul_le_mul_of_nonneg_left hp_le_one hq0.le _ = q0 := by ring _ ≤ 1 / 2 := hq0_le_half have hq_zero_fixed : γ = 0 → ∃ q0fix : ℝ, 0 < q0fix ∧ ∀ᶠ n : ℕ in atTop, qSched α γ a c q0 n = q0fix := by intro hγ0 exact ⟨q0, hq0, Filter.Eventually.of_forall (fun n => by simp [qSched, hγ0])⟩ rcases crude_localized_master_bound (𝒳 := 𝒳) policySet α γ Cm u0 Co co underlineP a c CMu CProd dPi assign (qSched α γ a c q0) (uSched α γ a c uBar) rMu rE enum muHat0 muHat1 eHat hvc henvU hoffU hskel hK hpoly hq_sched_pos hq_half hq_zero_fixed hrMu_nonneg hrE_nonneg hμ0meas hμ1meas hemeas hμ0L2 hμ1L2 heL2 hbn with ⟨Cmaster, pmaster, hCmaster, hpmaster, hmaster_event⟩ rcases clip_balance_exponent α γ a c CMu CProd q0 uBar co rMu rE hpoly hCMu hCProd hrMu_nonneg hq0 huBar hadm with ⟨Cbal, pbal, hCbal, hpbal, hbal_pos, hbal_zero⟩ refine ⟨Cmaster * Cbal, pmaster + pbal, mul_pos hCmaster hCbal, add_nonneg hpmaster hpbal, ?_⟩ by_cases hγ0 : γ = 0 · have hbal_event := hbal_zero hγ0 filter_upwards [hmaster_event, hbal_event, Filter.eventually_atTop.mpr ⟨2, fun n hn => hn⟩] with n hmaster_n hbal_n hn2 have hnposNat : 0 < n := lt_of_lt_of_le (by norm_num : 0 < (2 : ℕ)) hn2 have hnpos : 0 < (n : ℝ) := by exact_mod_cast hnposNat have hlog_pos : 0 < log (n : ℝ) := by apply Real.log_pos exact_mod_cast (lt_of_lt_of_le (by norm_num : 1 < (2 : ℕ)) hn2) have hbound_nonneg : 0 ≤ Cmaster * Cbal * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ (pmaster + pbal) := by positivity apply Real.sSup_le ?_ hbound_nonneg rintro y ⟨P, hP, rfl⟩ rcases hP with ⟨hlaw, hopt, hiid, hnr, hbn, _hpoly_dom, _hvc_dom, _henv_dom, _hoff_dom, _hK_dom, _hskel_dom⟩ have hq_le : qSched α γ a c q0 n ≤ underlineP / 2 := by simpa [qSched, hγ0] using (hinputs.2 hγ0).2 have hmasterP := (hmaster_n P hlaw hopt hiid hnr hbn).2 hγ0 hq_le calc ∫ sample, lawRegret P (feasibleERM (qSched α γ a c q0 n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂Measure.pi (fun _ : Fin n => P.dataMeasure) ≤ Cmaster * ((n : ℝ) ^ (-(Aalpha α)) + rMu n * rE n) * (log n) ^ pmaster := hmasterP _ ≤ Cmaster * (Cbal * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ pbal) * (log n) ^ pmaster := by nlinarith [mul_le_mul_of_nonneg_left hbal_n hCmaster.le, Real.rpow_nonneg hlog_pos.le pmaster] _ = Cmaster * Cbal * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ (pmaster + pbal) := by rw [Real.rpow_add hlog_pos] ring _ = Cmaster * Cbal * (n : ℝ) ^ (-(feasibleRate α γ a c co underlineP u0 q0 uBar hinputs).r) * (log n) ^ (pmaster + pbal) := by simp [feasibleRate, rFeas] · have hγpos : 0 < γ := lt_of_le_of_ne hγ (Ne.symm hγ0) have hbal_event := hbal_pos hγpos have hadm_event := hadm hγpos filter_upwards [hmaster_event, hbal_event, hadm_event, Filter.eventually_atTop.mpr ⟨2, fun n hn => hn⟩] with n hmaster_n hbal_n hadm_n hn2 have hnposNat : 0 < n := lt_of_lt_of_le (by norm_num : 0 < (2 : ℕ)) hn2 have hnpos : 0 < (n : ℝ) := by exact_mod_cast hnposNat have hn1R : (1 : ℝ) ≤ (n : ℝ) := by exact_mod_cast (le_trans (by norm_num : 1 ≤ (2 : ℕ)) hn2) have hlog_pos : 0 < log (n : ℝ) := by apply Real.log_pos exact_mod_cast (lt_of_lt_of_le (by norm_num : 1 < (2 : ℕ)) hn2) have hu_pos : 0 < uSched α γ a c uBar n := by simp [uSched, huBar hγpos, Real.rpow_pos_of_pos hnpos] have hu_le : uSched α γ a c uBar n ≤ u0 := by rcases feasibleMaximizer_mem α γ a c hγpos with ⟨_hs0, _hs1, ht0, _ht1⟩ have hp_le_one : (n : ℝ) ^ (-(tFeas α γ a c)) ≤ 1 := by exact Real.rpow_le_one_of_one_le_of_nonpos hn1R (by linarith) have huBar_le : uBar ≤ u0 := (hinputs.1 hγpos).2.1 calc uSched α γ a c uBar n = uBar * (n : ℝ) ^ (-(tFeas α γ a c)) := rfl _ ≤ uBar * 1 := by exact mul_le_mul_of_nonneg_left hp_le_one (le_of_lt (huBar hγpos)) _ = uBar := by ring _ ≤ u0 := huBar_le have hbound_nonneg : 0 ≤ Cmaster * Cbal * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ (pmaster + pbal) := by positivity apply Real.sSup_le ?_ hbound_nonneg rintro y ⟨P, hP, rfl⟩ rcases hP with ⟨hlaw, hopt, hiid, hnr, hbn, _hpoly_dom, _hvc_dom, _henv_dom, _hoff_dom, _hK_dom, _hskel_dom⟩ have hmasterP := (hmaster_n P hlaw hopt hiid hnr hbn).1 hγpos hu_pos hu_le hadm_n calc ∫ sample, lawRegret P (feasibleERM (qSched α γ a c q0 n) enum (muHat0 n) (muHat1 n) (eHat n) (assign n) sample) ∂Measure.pi (fun _ : Fin n => P.dataMeasure) ≤ Cmaster * ((n : ℝ) ^ (-(rStar α γ)) + ((n : ℝ) * (qSched α γ a c q0 n) ^ 2) ^ (-(Aalpha α)) + rMu n * rE n / qSched α γ a c q0 n + rMu n * (uSched α γ a c uBar n) ^ (α / 2) * (qSched α γ a c q0 n) ^ (1 / (2 * γ)) + (rMu n) ^ 2 / uSched α γ a c uBar n) * (log n) ^ pmaster := hmasterP _ ≤ Cmaster * (Cbal * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ pbal) * (log n) ^ pmaster := by nlinarith [mul_le_mul_of_nonneg_left hbal_n hCmaster.le, Real.rpow_nonneg hlog_pos.le pmaster] _ = Cmaster * Cbal * (n : ℝ) ^ (-(rFeas α γ a c)) * (log n) ^ (pmaster + pbal) := by -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.feasible_upper · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_feasible_upper.lean:25
T_minimax_lower 48 declarations
def bernoulliBool

{0,1}-supported Bernoulli observation-treatment measure on the treatment space Bool (true ↦ 1) with P(A=1)=p.

Definition (Lean source)
noncomputable abbrev bernoulliBool (p : ℝ) : Measure Bool := bernoulliBool p
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliBool · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:31
def bernoulliPM

{-1,1}-supported outcome measure with mean m (P(Y=1)=(1+m)/2).

Definition (Lean source)
noncomputable abbrev bernoulliPM (m : ℝ) : Measure ℝ := twoPointMean 1 m
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliPM · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:39
theorem measurable_bernoulliBool

The Bernoulli treatment law depends measurably on its success probability. This is what makes the witness's covariate-dependent treatment kernel a genuine measurable kernel.

Formal statement
Measurable bernoulliBool
Proof (Lean source)
@[fun_prop] lemma measurable_bernoulliBool : Measurable bernoulliBool := measurable_bernoulliBool
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_bernoulliBool · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:46
theorem measurable_bernoulliPM

The two-point outcome law on {-1, +1} depends measurably on its mean parameter — what makes the witness's covariate-dependent outcome kernel a genuine measurable kernel.

Formal statement
Proof (Lean source)
@[fun_prop] lemma measurable_bernoulliPM : Measurable bernoulliPM := measurable_twoPointMean 1
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_bernoulliPM · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:51
theorem bernoulliBool_isProbabilityMeasure

The Bernoulli treatment law with success probability p is a probability measure whenever p lies in [0,1].

Formal statement
p :
hp0 :
0 ≤ p
hp1 :
p ≤ 1
IsProbabilityMeasure (bernoulliBool p)
Proof (Lean source)
lemma bernoulliBool_isProbabilityMeasure {p : ℝ} (hp0 : 0 ≤ p) (hp1 : p ≤ 1) : IsProbabilityMeasure (bernoulliBool p) := bernoulliBool_isProbabilityMeasure hp0 hp1
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliBool_isProbabilityMeasure · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:56
theorem bernoulliPM_isProbabilityMeasure

The two-point outcome law on {-1, +1} with mean m is a probability measure whenever m lies in [-1,1].

Formal statement
m :
hm_lo :
-1 ≤ m
hm_hi :
m ≤ 1
Proof (Lean source)
lemma bernoulliPM_isProbabilityMeasure {m : ℝ} (hm_lo : -1 ≤ m) (hm_hi : m ≤ 1) : IsProbabilityMeasure (bernoulliPM m) := twoPointMean_isProbabilityMeasure one_pos (abs_le.mpr ⟨hm_lo, hm_hi⟩)
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliPM_isProbabilityMeasure · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:62
theorem bernoulliBool_integral

Integrating a function of the treatment arm against the Bernoulli treatment law with success probability p in [0,1] gives the weighted average of its treated and untreated values, with weights p and 1-p.

Formal statement
p :
hp0 :
0 ≤ p
hp1 :
p ≤ 1
f :
Bool → ℝ
∫ a, f a ∂bernoulliBool p = p * f true + (1 - p) * f false
Proof (Lean source)
lemma bernoulliBool_integral {p : ℝ} (hp0 : 0 ≤ p) (hp1 : p ≤ 1) (f : Bool → ℝ) : ∫ a, f a ∂bernoulliBool p = p * f true + (1 - p) * f false := bernoulliBool_integral hp0 hp1 f
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliBool_integral · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:69
theorem bernoulliPM_integral

Integrating a function of the outcome against the two-point law with mean m in [-1,1] gives the weighted average of its values at +1 and -1, with weights (1+m)/2 and (1-m)/2.

Formal statement
m :
hm_lo :
-1 ≤ m
hm_hi :
m ≤ 1
f :
ℝ → ℝ
∫ y, f y ∂bernoulliPM m = ((1 + m) / 2) * f 1 + ((1 - m) / 2) * f (-1)
Proof (Lean source)
lemma bernoulliPM_integral {m : ℝ} (hm_lo : -1 ≤ m) (hm_hi : m ≤ 1) (f : ℝ → ℝ) : ∫ y, f y ∂bernoulliPM m = ((1 + m) / 2) * f 1 + ((1 - m) / 2) * f (-1) := by simpa using twoPointMean_integral one_pos (abs_le.mpr ⟨hm_lo, hm_hi⟩) f
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliPM_integral · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:77
theorem bernoulliPM_mean

The two-point outcome law with parameter m in [-1,1] has mean exactly m. This is what makes it the outcome channel realizing a prescribed conditional-mean value while keeping outcomes in [-1,1].

Formal statement
m :
hm_lo :
-1 ≤ m
hm_hi :
m ≤ 1
∫ y, y ∂bernoulliPM m = m
Proof (Lean source)
lemma bernoulliPM_mean {m : ℝ} (hm_lo : -1 ≤ m) (hm_hi : m ≤ 1) : ∫ y, y ∂bernoulliPM m = m := twoPointMean_mean one_pos (abs_le.mpr ⟨hm_lo, hm_hi⟩)
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliPM_mean · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:87
theorem bernoulliPM_bad_support_zero

The two-point outcome law puts no mass outside [-1,1], for any parameter m: it is carried by the two points -1 and +1. This delivers the bounded-outcome requirement for the witness laws.

Formal statement
m :
(bernoulliPM m) {y | y ∉ Icc (-1 : ℝ) 1} = 0
Proof (Lean source)
lemma bernoulliPM_bad_support_zero (m : ℝ) : (bernoulliPM m) {y | y ∉ Icc (-1 : ℝ) 1} = 0 := twoPointMean_bad_support_zero (ofReal ((1 + m / 1) / 2)) (ofReal ((1 - m / 1) / 2)) (by norm_num)
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliPM_bad_support_zero · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:94
theorem bernoulliBool_bind

Mixing a family of measures indexed by the treatment arm over the Bernoulli treatment law with success probability p yields the convex combination of the treated and untreated members with weights p and 1-p.

Formal statement
β :
p :
K :
BoolMeasure β
(bernoulliBool p).bind K = ofReal p • K true + ofReal (1 - p) • K false
Proof (Lean source)
lemma bernoulliBool_bind {β : Type*} [MeasurableSpace β] (p : ℝ) (K : BoolMeasure β) : (bernoulliBool p).bind K = ofReal p • K true + ofReal (1 - p) • K false := bernoulliBool_bind p K
CausalSmith.Stat.PolicyRegretMarginOverlap.bernoulliBool_bind · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:102
theorem measurable_observation_tuple_real

Sending a real-covariate observation to its coordinate triple (covariate, treatment arm, outcome) is measurable.

Formal statement
Measurable (fun O : Observation ℝ => (O.X, O.A, O.Y))
Proof (Lean source)
lemma measurable_observation_tuple_real : Measurable (fun O : Observation ℝ => (O.X, O.A, O.Y)) := Measurable.of_comap_le le_rfl
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_observation_tuple_real · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:132
instance instMeasurableSingletonClassObservationReal

Every single real-covariate observation forms a measurable set, so the observation space has measurable points. This is needed for the cell-by-cell likelihood-ratio computation behind the two-point chi-squared bound.

Definition (Lean source)
instance instMeasurableSingletonClassObservationReal : MeasurableSingletonClass (Observation ℝ) := by refine ⟨?_⟩ intro O have hset : MeasurableSet ((fun O' : Observation ℝ => (O'.X, O'.A, O'.Y)) ⁻¹' ({(O.X, O.A, O.Y)} : Set (ℝ × Bool × ℝ))) := measurable_observation_tuple_real (measurableSet_singleton _) convert hset using 1 ext O' cases O cases O' simp
CausalSmith.Stat.PolicyRegretMarginOverlap.instMeasurableSingletonClassObservationReal · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:138
theorem measurable_observation_mk

Assembling an observation from a FIXED covariate value and treatment arm is a measurable function of the outcome value.

Formal statement
x :
a :
Measurable (fun y : ℝ => Observation.mk x a y)
Proof (Lean source)
@[fun_prop] lemma measurable_observation_mk (x : ℝ) (a : Bool) : Measurable (fun y : ℝ => Observation.mk x a y) := by rw [measurable_comap_iff] fun_prop
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_observation_mk · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:154
theorem measurable_observation_mk_X

Assembling an observation from a FIXED treatment arm and outcome value is a measurable function of the covariate.

Formal statement
a :
y :
Measurable (fun x : ℝ => Observation.mk x a y)
Proof (Lean source)
@[fun_prop] lemma measurable_observation_mk_X (a : Bool) (y : ℝ) : Measurable (fun x : ℝ => Observation.mk x a y) := by rw [measurable_comap_iff] fun_prop
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_observation_mk_X · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:161
theorem measurable_smul_measure_variable

Scaling a measurably varying family of measures by a measurably varying nonnegative extended-real coefficient again gives a measurably varying family of measures.

Formal statement
ι β :
hc :
:
Measurable fun x => c x • μ x
Proof (Lean source)
lemma measurable_smul_measure_variable {ι β : Type*} [MeasurableSpace ι] [MeasurableSpace β] {c : ι → ENNReal} {μ : ι → Measure β} (hc : Measurable c) (hμ : Measurable μ) : Measurable fun x => c x • μ x := by refine Measure.measurable_of_measurable_coe _ fun s hs => ?_ simp only [Measure.smul_apply, smul_eq_mul] exact hc.mul ((Measure.measurable_coe hs).comp hμ)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_smul_measure_variable · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:168
theorem measurable_map_observation_dirac

Fix a treatment arm and a deterministic outcome value. The observation law obtained by pushing the point mass at that outcome through 'assemble the observation at covariate x' varies measurably in the covariate x. This covers the witness's control cell inside the active block, where the outcome is deterministically zero.

Formal statement
a :
y0 :
Measurable fun x : ℝ => Measure.map (Observation.mk x a) (Measure.dirac y0 : Measure ℝ)
Proof (Lean source)
lemma measurable_map_observation_dirac (a : Bool) (y0 : ℝ) : Measurable fun x : ℝ => Measure.map (Observation.mk x a) (Measure.dirac y0 : Measure ℝ) := by rw [show (fun x : ℝ => Measure.map (Observation.mk x a) (Measure.dirac y0 : Measure ℝ)) = fun x => Measure.dirac (Observation.mk x a y0) by funext x rw [Measure.map_dirac]] exact Measure.measurable_dirac.comp (measurable_observation_mk_X a y0)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_map_observation_dirac · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:177
theorem measurable_map_observation_bernoulliPM

Fix a treatment arm and a mean m. The observation law obtained by drawing the outcome from the two-point {-1,+1} law with mean m and pushing it through 'assemble the observation at covariate x' varies measurably in the covariate x.

Formal statement
a :
m :
Measurable fun x : ℝ => Measure.map (Observation.mk x a) (bernoulliPM m)
Proof (Lean source)
lemma measurable_map_observation_bernoulliPM (a : Bool) (m : ℝ) : Measurable fun x : ℝ => Measure.map (Observation.mk x a) (bernoulliPM m) := by rw [show (fun x : ℝ => Measure.map (Observation.mk x a) (bernoulliPM m)) = fun x => ofReal ((1 + m) / 2) • Measure.dirac (Observation.mk x a (1 : ℝ)) + ofReal ((1 - m) / 2) • Measure.dirac (Observation.mk x a (-1 : ℝ)) by funext x unfold bernoulliPM twoPointMean rw [Measure.map_add _ _ (measurable_observation_mk x a)] rw [Measure.map_smul, Measure.map_smul] rw [Measure.map_dirac, Measure.map_dirac] norm_num] have hdir1 : Measurable fun x : ℝ => Measure.dirac (Observation.mk x a (1 : ℝ)) := Measure.measurable_dirac.comp (measurable_observation_mk_X a 1) have hdirNeg : Measurable fun x : ℝ => Measure.dirac (Observation.mk x a (-1 : ℝ)) := Measure.measurable_dirac.comp (measurable_observation_mk_X a (-1)) exact (measurable_smul_measure_variable measurable_const hdir1).add (measurable_smul_measure_variable measurable_const hdirNeg)
CausalSmith.Stat.PolicyRegretMarginOverlap.measurable_map_observation_bernoulliPM · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:191
theorem twoPointWitness_expanded_kernel_measurable

The two-point witness's per-covariate observation law, written out explicitly as the treated cell weighted by the covariate-dependent propensity plus the untreated cell weighted by its complement — each cell carrying the inside-block or outside-block outcome law — varies measurably in the covariate.

Formal statement
α cB σ h q τ0 :
Measurable fun x : ℝ
=> ofReal (if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2) • Measure.map (Observation.mk x true) (if 0 ≤ x ∧ x ≤ cB * h ^ α then bernoulliPM (σ * h) else bernoulliPM (τ0 / 2))
+ ofReal (1 - if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2) • Measure.map (Observation.mk x false) (if 0 ≤ x ∧ x ≤ cB * h ^ α then Measure.dirac 0 else bernoulliPM (-τ0 / 2))
Proof (Lean source)
lemma twoPointWitness_expanded_kernel_measurable (α cB σ h q τ0 : ℝ) : Measurable fun x : ℝ => ofReal (if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2) • Measure.map (Observation.mk x true) (if 0 ≤ x ∧ x ≤ cB * h ^ α then bernoulliPM (σ * h) else bernoulliPM (τ0 / 2)) + ofReal (1 - if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2) • Measure.map (Observation.mk x false) (if 0 ≤ x ∧ x ≤ cB * h ^ α then Measure.dirac 0 else bernoulliPM (-τ0 / 2)) := by have hB : MeasurableSet {x : ℝ | 0 ≤ x ∧ x ≤ cB * h ^ α} := measurableSet_Icc have hbase : Measurable fun x : ℝ => if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2 := by exact Measurable.ite hB measurable_const measurable_const have hcoefT : Measurable fun x : ℝ => ofReal (if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2) := by fun_prop have hcoefF : Measurable fun x : ℝ => ofReal (1 - if 0 ≤ x ∧ x ≤ cB * h ^ α then q else 1 / 2) := by fun_prop have houtT : Measurable fun x : ℝ => if 0 ≤ x ∧ x ≤ cB * h ^ α then bernoulliPM (σ * h) else bernoulliPM (τ0 / 2) := by exact Measurable.ite hB measurable_const measurable_const have houtF : Measurable fun x : ℝ => if 0 ≤ x ∧ x ≤ cB * h ^ α then (Measure.dirac 0 : Measure ℝ) else bernoulliPM (-τ0 / 2) := by exact Measurable.ite hB measurable_const measurable_const have hmapT : Measurable fun x : ℝ => Measure.map (Observation.mk x true) (if 0 ≤ x ∧ x ≤ cB * h ^ α then bernoulliPM (σ * h) else bernoulliPM (τ0 / 2)) := by rw [show (fun x : ℝ => Measure.map (Observation.mk x true) (if 0 ≤ x ∧ x ≤ cB * h ^ α then bernoulliPM (σ * h) else bernoulliPM (τ0 / 2))) = (fun x : ℝ => if 0 ≤ x ∧ x ≤ cB * h ^ α then Measure.map (Observation.mk x true) (bernoulliPM (σ * h)) else Measure.map (Observation.mk x true) (bernoulliPM (τ0 / 2))) by funext x by_cases hx : 0 ≤ x ∧ x ≤ cB * h ^ α <;> simp [hx]] exact Measurable.ite hB (measurable_map_observation_bernoulliPM true (σ * h)) (measurable_map_observation_bernoulliPM true (τ0 / 2)) have hmapF : Measurable fun x : ℝ => Measure.map (Observation.mk x false) (if 0 ≤ x ∧ x ≤ cB * h ^ α then Measure.dirac 0 else bernoulliPM (-τ0 / 2)) := by rw [show (fun x : ℝ => Measure.map (Observation.mk x false) (if 0 ≤ x ∧ x ≤ cB * h ^ α then Measure.dirac 0 else bernoulliPM (-τ0 / 2))) = (fun x : ℝ => if 0 ≤ x ∧ x ≤ cB * h ^ α then Measure.map (Observation.mk x false) (Measure.dirac 0) else Measure.map (Observation.mk x false) (bernoulliPM (-τ0 / 2))) by funext x by_cases hx : 0 ≤ x ∧ x ≤ cB * h ^ α <;> simp [hx]] exact Measurable.ite hB (measurable_map_observation_dirac false 0) (measurable_map_observation_bernoulliPM false (-τ0 / 2)) exact (measurable_smul_measure_variable hcoefT hmapT).add (measurable_smul_measure_variable hcoefF hmapF)
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_expanded_kernel_measurable · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:213
theorem restricted_volume_Icc01_isProbabilityMeasure

Lebesgue measure restricted to the unit interval is a probability measure — the covariate marginal used by the two-point witness.

Formal statement
IsProbabilityMeasure (volume.restrict (Icc (0 : ℝ) 1))
Proof (Lean source)
lemma restricted_volume_Icc01_isProbabilityMeasure : IsProbabilityMeasure (volume.restrict (Icc (0 : ℝ) 1)) := by rw [isProbabilityMeasure_iff] rw [Measure.restrict_apply MeasurableSet.univ] simp
CausalSmith.Stat.PolicyRegretMarginOverlap.restricted_volume_Icc01_isProbabilityMeasure · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:285
theorem restricted_volume_real_Icc_zero_le

Under the uniform covariate law on the unit interval, the interval from zero to any nonnegative a carries probability at most a. This is the bound used for the covariate mass of the witness's active block.

Formal statement
a :
ha0 :
0 ≤ a
(volume.restrict (Icc (0 : ℝ) 1)).real (Icc (0 : ℝ) a) ≤ a
Proof (Lean source)
lemma restricted_volume_real_Icc_zero_le {a : ℝ} (ha0 : 0 ≤ a) : (volume.restrict (Icc (0 : ℝ) 1)).real (Icc (0 : ℝ) a) ≤ a := by by_cases ha1 : a ≤ 1 · rw [measureReal_def, Measure.restrict_apply measurableSet_Icc] have hinter : Icc (0 : ℝ) a ∩ Icc (0 : ℝ) 1 = Icc (0 : ℝ) a := by ext x constructor · intro hx exact hx.1 · intro hx exact ⟨hx, ⟨hx.1, le_trans hx.2 ha1⟩⟩ rw [hinter] have hvol : volume.real (Icc (0 : ℝ) a) = a := by simpa using (Real.volume_real_Icc_of_le ha0 : volume.real (Icc (0 : ℝ) a) = a - 0) simpa [measureReal_def] using le_of_eq hvol · have hprob : IsProbabilityMeasure (volume.restrict (Icc (0 : ℝ) 1)) := restricted_volume_Icc01_isProbabilityMeasure letI : IsProbabilityMeasure (volume.restrict (Icc (0 : ℝ) 1)) := hprob have hle_one : (volume.restrict (Icc (0 : ℝ) 1)).real (Icc (0 : ℝ) a) ≤ 1 := measureReal_le_one have hone_le : (1 : ℝ) ≤ a := le_of_not_ge ha1 exact hle_one.trans hone_le
CausalSmith.Stat.PolicyRegretMarginOverlap.restricted_volume_real_Icc_zero_le · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:293
theorem betaAG_nonneg_of_nonneg

The admissible weak-arm exponent β_{α,γ} is nonnegative whenever the margin exponent α and the overlap-decay exponent γ are.

Formal statement
α γ :
:
0 ≤ α
:
0 ≤ γ
0 ≤ betaAG α γ
Proof (Lean source)
lemma betaAG_nonneg_of_nonneg (α γ : ℝ) (hα : 0 ≤ α) (hγ : 0 ≤ γ) : 0 ≤ betaAG α γ := by unfold betaAG by_cases hγ0 : γ = 0 · simp [hγ0] · have hγpos : 0 < γ := lt_of_le_of_ne hγ (Ne.symm hγ0) have hdenpos : 0 < α + 1 := by linarith simp [hγ0, div_nonneg (mul_nonneg hα hγpos.le) hdenpos.le]
CausalSmith.Stat.PolicyRegretMarginOverlap.betaAG_nonneg_of_nonneg · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:324
theorem Dag_pos_of_nonneg

The converse denominator D_{α,γ} = 2 + α + β_{α,γ} is strictly positive whenever the margin and overlap-decay exponents are nonnegative. So the information exponent r_⋆ = (1+α)/D_{α,γ} and the contrast height h_n = n^{-1/D_{α,γ}} are well defined.

Formal statement
α γ :
:
0 ≤ α
:
0 ≤ γ
0 < Dag α γ
Proof (Lean source)
lemma Dag_pos_of_nonneg (α γ : ℝ) (hα : 0 ≤ α) (hγ : 0 ≤ γ) : 0 < Dag α γ := by have hb : 0 ≤ betaAG α γ := betaAG_nonneg_of_nonneg α γ hα hγ unfold Dag linarith
CausalSmith.Stat.PolicyRegretMarginOverlap.Dag_pos_of_nonneg · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:335
theorem hLower_pos_of_pos_nat

The lower-bound contrast height h_n = n^{-1/D_{α,γ}} is strictly positive at every positive sample size.

Formal statement
α γ :
n :
hn :
0 < n
0 < hLower α γ n
Proof (Lean source)
lemma hLower_pos_of_pos_nat (α γ : ℝ) {n : ℕ} (hn : 0 < n) : 0 < hLower α γ n := by unfold hLower exact Real.rpow_pos_of_pos (by exact_mod_cast hn) _
CausalSmith.Stat.PolicyRegretMarginOverlap.hLower_pos_of_pos_nat · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:344
theorem hLower_le_one_of_one_le_nat

The lower-bound contrast height is at most one at every sample size of at least one, when the margin and overlap-decay exponents are nonnegative.

Formal statement
α γ :
:
0 ≤ α
:
0 ≤ γ
n :
hn :
1 ≤ n
hLower α γ n ≤ 1
Proof (Lean source)
lemma hLower_le_one_of_one_le_nat (α γ : ℝ) (hα : 0 ≤ α) (hγ : 0 ≤ γ) {n : ℕ} (hn : 1 ≤ n) : hLower α γ n ≤ 1 := by have hD : 0 < Dag α γ := Dag_pos_of_nonneg α γ hα hγ unfold hLower have hdiv_nonneg : 0 ≤ 1 / Dag α γ := by positivity exact Real.rpow_le_one_of_one_le_of_nonpos (by exact_mod_cast hn) (by linarith)
CausalSmith.Stat.PolicyRegretMarginOverlap.hLower_le_one_of_one_le_nat · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:351
theorem eventually_hLower_le_half

The lower-bound contrast height drops below one half for all large enough sample sizes, since it decays to zero as the sample size grows. This is the smallness the witness construction needs to keep its outcome regressions inside [-1,1].

Formal statement
α γ :
:
0 ≤ α
:
0 ≤ γ
∀ᶠ n : ℕ in atTop, hLower α γ n ≤ (1 / 2 : ℝ)
Proof (Lean source)
lemma eventually_hLower_le_half (α γ : ℝ) (hα : 0 ≤ α) (hγ : 0 ≤ γ) : ∀ᶠ n : ℕ in atTop, hLower α γ n ≤ (1 / 2 : ℝ) := by have hD : 0 < Dag α γ := Dag_pos_of_nonneg α γ hα hγ have htend : Tendsto (fun n : ℕ => hLower α γ n) atTop (𝓝 (0 : ℝ)) := by unfold hLower exact (tendsto_rpow_neg_atTop (by positivity : 0 < 1 / Dag α γ)).comp tendsto_natCast_atTop_atTop exact htend.eventually (Iic_mem_nhds (by norm_num : (0 : ℝ) < 1 / 2))
CausalSmith.Stat.PolicyRegretMarginOverlap.eventually_hLower_le_half · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:361
theorem eventually_qLower_pos_le_half

The lower-bound weak-arm scale q_n lies in the interval from zero (exclusive) to one half for all large enough sample sizes — the range that makes it a valid treatment probability for the witness's active block.

Formal statement
α γ :
:
0 ≤ α
:
0 ≤ γ
∀ᶠ n : ℕ in atTop, 0 < qLower α γ n ∧ qLower α γ n ≤ (1 / 2 : ℝ)
Proof (Lean source)
lemma eventually_qLower_pos_le_half (α γ : ℝ) (hα : 0 ≤ α) (hγ : 0 ≤ γ) : ∀ᶠ n : ℕ in atTop, 0 < qLower α γ n ∧ qLower α γ n ≤ (1 / 2 : ℝ) := by have hb_nonneg : 0 ≤ betaAG α γ := betaAG_nonneg_of_nonneg α γ hα hγ have hD : 0 < Dag α γ := Dag_pos_of_nonneg α γ hα hγ by_cases hb0 : betaAG α γ = 0 · filter_upwards with n constructor · simp [qLower, hb0] · simp [qLower, hb0] norm_num · have hbpos : 0 < betaAG α γ := lt_of_le_of_ne hb_nonneg (Ne.symm hb0) have hrate_pos : 0 < betaAG α γ / Dag α γ := div_pos hbpos hD have htend : Tendsto (fun n : ℕ => (n : ℝ) ^ (-(betaAG α γ / Dag α γ))) atTop (𝓝 (0 : ℝ)) := by exact (tendsto_rpow_neg_atTop hrate_pos).comp tendsto_natCast_atTop_atTop have hsmall : ∀ᶠ n : ℕ in atTop, (n : ℝ) ^ (-(betaAG α γ / Dag α γ)) ≤ (1 / 2 : ℝ) := htend.eventually (Iic_mem_nhds (by norm_num : (0 : ℝ) < 1 / 2)) filter_upwards [hsmall, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hsmalln hn1 have hnpos : 0 < (n : ℝ) := by exact_mod_cast (lt_of_lt_of_le (by norm_num) hn1) have hnnon : 0 ≤ (n : ℝ) := le_of_lt hnpos have hpoweq : ((n : ℝ) ^ (-(1 / Dag α γ))) ^ betaAG α γ = (n : ℝ) ^ (-(betaAG α γ / Dag α γ)) := by rw [← Real.rpow_mul hnnon] congr 1 ring constructor · unfold qLower hLower rw [if_neg hb0, hpoweq] exact Real.rpow_pos_of_pos hnpos _ · unfold qLower hLower rw [if_neg hb0, hpoweq] exact hsmalln
CausalSmith.Stat.PolicyRegretMarginOverlap.eventually_qLower_pos_le_half · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:374
theorem activeBlock_overlap_bound_gpos

Active-block admissibility check for the overlap-decay envelope in the decaying-overlap regime (positive γ).

Formal statement
α γ cB Co co h u v :
hαpos :
0 < α
hγpos :
0 < γ
hCo :
0 < Co
hco :
0 < co
hcB :
cB ≤ Co * co ^ (-(α / γ))
hh0 :
0 < h
hu0 :
0 < u
hv0 :
0 < v
hqv :
h ^ betaAG α γ ≤ v
hvle :
v ≤ co * u ^ γ
cB * h ^ α ≤ Co * u ^ α * v ^ (1 / γ)
Proof (Lean source)
lemma activeBlock_overlap_bound_gpos {α γ cB Co co h u v : ℝ} (hαpos : 0 < α) (hγpos : 0 < γ) (hCo : 0 < Co) (hco : 0 < co) (hcB : cB ≤ Co * co ^ (-(α / γ))) (hh0 : 0 < h) (hu0 : 0 < u) (hv0 : 0 < v) (hqv : h ^ betaAG α γ ≤ v) (hvle : v ≤ co * u ^ γ) : cB * h ^ α ≤ Co * u ^ α * v ^ (1 / γ) := by have hβeq : betaAG α γ = α * γ / (α + 1) := by unfold betaAG simp [ne_of_gt hγpos] have hγ_nonneg : 0 ≤ γ := le_of_lt hγpos have hα_nonneg : 0 ≤ α := le_of_lt hαpos have hβ_nonneg : 0 ≤ betaAG α γ := betaAG_nonneg_of_nonneg α γ hα_nonneg hγ_nonneg have hq_pos : 0 < h ^ betaAG α γ := Real.rpow_pos_of_pos hh0 _ have hq_nonneg : 0 ≤ h ^ betaAG α γ := le_of_lt hq_pos have hvpow_nonneg : 0 ≤ v ^ (1 / γ) := Real.rpow_nonneg hv0.le _ have hpart1 : (h ^ betaAG α γ) ^ (1 / γ) ≤ v ^ (1 / γ) := by exact Real.rpow_le_rpow hq_nonneg hqv (by positivity : 0 ≤ 1 / γ) have hpart2a : (h ^ betaAG α γ) ^ (α / γ) ≤ v ^ (α / γ) := by exact Real.rpow_le_rpow hq_nonneg hqv (by positivity : 0 ≤ α / γ) have hcou_split : (co * u ^ γ) ^ (α / γ) = co ^ (α / γ) * u ^ α := by have huγ_nonneg : 0 ≤ u ^ γ := Real.rpow_nonneg hu0.le _ rw [Real.mul_rpow hco.le huγ_nonneg] rw [← Real.rpow_mul hu0.le] congr 1 field_simp [hγpos.ne'] have hpart2b : v ^ (α / γ) ≤ co ^ (α / γ) * u ^ α := by calc v ^ (α / γ) ≤ (co * u ^ γ) ^ (α / γ) := by exact Real.rpow_le_rpow hv0.le hvle (by positivity : 0 ≤ α / γ) _ = co ^ (α / γ) * u ^ α := hcou_split have hpart2 : (h ^ betaAG α γ) ^ (α / γ) ≤ co ^ (α / γ) * u ^ α := hpart2a.trans hpart2b have hpow_bound : h ^ α ≤ v ^ (1 / γ) * (co ^ (α / γ) * u ^ α) := by have hsplit : (h ^ betaAG α γ) ^ ((α + 1) / γ) = h ^ α := by rw [← Real.rpow_mul hh0.le] congr 1 rw [hβeq] have hden_ne : α + 1 ≠ 0 := by linarith field_simp [hγpos.ne', hden_ne] calc h ^ α = (h ^ betaAG α γ) ^ ((α + 1) / γ) := hsplit.symm _ = (h ^ betaAG α γ) ^ (1 / γ + α / γ) := by congr 1 ring _ = (h ^ betaAG α γ) ^ (1 / γ) * (h ^ betaAG α γ) ^ (α / γ) := by rw [Real.rpow_add hq_pos] _ ≤ v ^ (1 / γ) * (co ^ (α / γ) * u ^ α) := by exact mul_le_mul hpart1 hpart2 (Real.rpow_nonneg hq_nonneg _) hvpow_nonneg have hmul1 : cB * h ^ α ≤ (Co * co ^ (-(α / γ))) * h ^ α := by exact mul_le_mul_of_nonneg_right hcB (Real.rpow_nonneg hh0.le _) have hmul2 : (Co * co ^ (-(α / γ))) * h ^ α ≤ (Co * co ^ (-(α / γ))) * (v ^ (1 / γ) * (co ^ (α / γ) * u ^ α)) := by have hcoef_nonneg : 0 ≤ Co * co ^ (-(α / γ)) := by positivity exact mul_le_mul_of_nonneg_left hpow_bound hcoef_nonneg have hcancel : co ^ (-(α / γ)) * co ^ (α / γ) = 1 := by rw [← Real.rpow_add hco] have : -(α / γ) + α / γ = (0 : ℝ) := by ring rw [this] simp calc cB * h ^ α ≤ (Co * co ^ (-(α / γ))) * h ^ α := hmul1 _ ≤ (Co * co ^ (-(α / γ))) * (v ^ (1 / γ) * (co ^ (α / γ) * u ^ α)) := hmul2 _ = Co * u ^ α * v ^ (1 / γ) := by rw [show (Co * co ^ (-(α / γ))) * (v ^ (1 / γ) * (co ^ (α / γ) * u ^ α)) = Co * (co ^ (-(α / γ)) * co ^ (α / γ)) * (u ^ α * v ^ (1 / γ)) by ring] rw [hcancel] ring
CausalSmith.Stat.PolicyRegretMarginOverlap.activeBlock_overlap_bound_gpos · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:417
theorem activeBlock_overlap_bound_gzero

Active-block admissibility check for the overlap-decay envelope in the degenerate branch where the weak-arm exponent β_{α,γ} vanishes, so the witness's active block carries the FIXED treatment probability one quarter rather than a decaying power of the contrast height.

Formal statement
γ cB Co v :
hγpos :
0 < γ
hCo :
0 < Co
hcB :
cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))
hv :
(1 / 4 : ℝ) ≤ v
cB ≤ Co * v ^ (1 / γ)
Proof (Lean source)
lemma activeBlock_overlap_bound_gzero {γ cB Co v : ℝ} (hγpos : 0 < γ) (hCo : 0 < Co) (hcB : cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))) (hv : (1 / 4 : ℝ) ≤ v) : cB ≤ Co * v ^ (1 / γ) := by have hqpos : 0 < (1 / 4 : ℝ) := by norm_num have hpow : (4 : ℝ) ^ (-(1 / γ)) = (1 / 4 : ℝ) ^ (1 / γ) := by rw [Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 4)] rw [← Real.inv_rpow (by norm_num : (0 : ℝ) ≤ 4)] norm_num have hmono : (4 : ℝ) ^ (-(1 / γ)) ≤ v ^ (1 / γ) := by rw [hpow] exact Real.rpow_le_rpow hqpos.le hv (by positivity : 0 ≤ 1 / γ) calc cB ≤ Co * (4 : ℝ) ^ (-(1 / γ)) := hcB _ ≤ Co * v ^ (1 / γ) := mul_le_mul_of_nonneg_left hmono hCo.le
CausalSmith.Stat.PolicyRegretMarginOverlap.activeBlock_overlap_bound_gzero · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:499

Explicit two-point least-favorable law P_{n,σ} on 𝒳=ℝ with covariate marginal Lebesgue on [0,1], active block B_n=[0, c_B h_n^α], weak-arm propensity q_n on B_n, charged treated cell carrying contrast σ h_n, and off-block contrast τ_0=(u_0+2)/2 ∈ (u_0,2). The weak-arm scale is EXACTLY the displayed q_n = qLower α γ n (= 1/4 if β_{α,γ}=0, else h_n^{β_{α,γ}}), which lies in (0,1/2] for all large n; the constants admissibility 8 c_B c_Q < log 5 (c_Q = 1 here) is carried by the divergence lemma.

Definition (Lean source)
noncomputable def twoPointWitness (α γ u0 cB : ℝ) (n : ℕ) (σ : ℝ) : ObservedLaw ℝ := let h := hLower α γ n let q := qLower α γ n let τ0 := (u0 + 2) / 2 let inBlock : ℝ → Prop := fun x => 0 ≤ x ∧ x ≤ cB * h ^ α let prop : ℝ → ℝ := fun x => if inBlock x then q else 1 / 2 let contrast : ℝ → ℝ := fun x => if inBlock x then σ * h else τ0 let mu0 : ℝ → ℝ := fun x => if inBlock x then 0 else -τ0 / 2 let mu1 : ℝ → ℝ := fun x => if inBlock x then σ * h else τ0 / 2 let outcome : ℝ → BoolMeasure ℝ := fun x a => if inBlock x then (if a then bernoulliPM (σ * h) else Measure.dirac 0) else (if a then bernoulliPM (τ0 / 2) else bernoulliPM (-τ0 / 2)) { dataMeasure := ((volume.restrict (Icc (0 : ℝ) 1)).bind fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) PX := volume.restrict (Icc (0 : ℝ) 1) contrast := contrast propensity := prop mu0 := mu0 mu1 := mu1 }
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:527
theorem twoPointWitness_optimal_plus

For the σ = +1 member of the two-point pair, the law-optimal policy treats every covariate value: the contrast is +h_n on the active block and the strictly positive off-block value τ₀ elsewhere, hence nonnegative throughout.

Formal statement
α γ u0 cB :
n :
hn1 :
1 ≤ n
hwin :
∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true
Proof (Lean source)
lemma twoPointWitness_optimal_plus (α γ u0 cB : ℝ) {n : ℕ} (hn1 : 1 ≤ n) (hwin : MarginWindow u0) : ∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true := by intro x unfold lawOptimalPolicy optimalPolicy have hh_nonneg : 0 ≤ hLower α γ n := by have hnpos : 0 < n := lt_of_lt_of_le Nat.zero_lt_one hn1 exact (hLower_pos_of_pos_nat α γ hnpos).le have hτ0_nonneg : 0 ≤ (u0 + 2) / 2 := by linarith [hwin.1] by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · simp [twoPointWitness, hxB, hh_nonneg] · simp [twoPointWitness, hxB, hτ0_nonneg]
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_optimal_plus · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:557
theorem twoPointWitness_optimal_minus

For the σ = -1 member of the two-point pair, the law-optimal policy treats exactly the covariate values OUTSIDE the active block: the contrast is -h_n on the block, so treating there is harmful, and +τ₀ off it.

Formal statement
α γ u0 cB :
n :
hn1 :
1 ≤ n
hwin :
∀ x : ℝ,
lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x
= true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)
Proof (Lean source)
lemma twoPointWitness_optimal_minus (α γ u0 cB : ℝ) {n : ℕ} (hn1 : 1 ≤ n) (hwin : MarginWindow u0) : ∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α) := by intro x unfold lawOptimalPolicy optimalPolicy have hh_pos : 0 < hLower α γ n := by have hnpos : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 exact hLower_pos_of_pos_nat α γ hnpos have hτ0_nonneg : 0 ≤ (u0 + 2) / 2 := by linarith [hwin.1] by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · simp [twoPointWitness, hxB, not_le.mpr (neg_neg_of_pos hh_pos)] · simp [twoPointWitness, hxB, hτ0_nonneg]
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_optimal_minus · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:573
theorem twoPointWitness_positivity

Each two-point witness satisfies positivity — its propensity is strictly between zero and one at every covariate value — as soon as the weak-arm scale q_n lies in the interval from zero (exclusive) to one half.

Formal statement
α γ u0 cB σ :
n :
hq :
0 < qLower α γ n ∧ qLower α γ n ≤ 1 / 2
Positivity (twoPointWitness α γ u0 cB n σ)
Proof (Lean source)
lemma twoPointWitness_positivity (α γ u0 cB σ : ℝ) (n : ℕ) (hq : 0 < qLower α γ n ∧ qLower α γ n ≤ 1 / 2) : Positivity (twoPointWitness α γ u0 cB n σ) := by exact Filter.Eventually.of_forall fun x => by by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · simp [twoPointWitness, hxB] constructor · exact hq.1 · linarith [hq.2] · simp [twoPointWitness, hxB] norm_num
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_positivity · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:594
theorem twoPointWitness_strictOverlapEndpoint

Each two-point witness satisfies the strict-overlap endpoint condition at any floor underline_p in the interval from zero (exclusive) to one quarter.

Formal statement
α γ u0 cB underlineP σ :
n :
hq :
0 < qLower α γ n ∧ qLower α γ n ≤ 1 / 2
hup :
0 < underlineP
huple :
underlineP ≤ 1 / 4
StrictOverlapEndpoint (twoPointWitness α γ u0 cB n σ) γ underlineP
Proof (Lean source)
lemma twoPointWitness_strictOverlapEndpoint (α γ u0 cB underlineP σ : ℝ) (n : ℕ) (hq : 0 < qLower α γ n ∧ qLower α γ n ≤ 1 / 2) (hup : 0 < underlineP) (huple : underlineP ≤ 1 / 4) : StrictOverlapEndpoint (twoPointWitness α γ u0 cB n σ) γ underlineP := by intro hγ0 have hq_eq_quarter : qLower α γ n = (1 / 4 : ℝ) := by simp [qLower, betaAG, hγ0] refine ⟨hup, by linarith, ?_⟩ exact Filter.Eventually.of_forall fun x => by by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · simp [overlap, twoPointWitness, hxB] constructor · rw [hq_eq_quarter] exact huple · rw [hq_eq_quarter] linarith · simp [overlap, twoPointWitness, hxB] norm_num linarith
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_strictOverlapEndpoint · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:609
theorem twoPointWitness_zeroEffect

Each two-point witness satisfies the canonical zero-effect regularity condition, for either sign σ = ±1: its contrast never vanishes — it is ±h_n on the active block and the strictly positive τ₀ off it — so the zero-contrast set is empty and in particular null.

Formal statement
α γ u0 cB :
policySet :
Set (Policy ℝ)
n :
σ :
hn1 :
1 ≤ n
hwin :
:
σ = 1 ∨ σ = -1
ZeroEffectRegular (twoPointWitness α γ u0 cB n σ) policySet
Proof (Lean source)
lemma twoPointWitness_zeroEffect (α γ u0 cB : ℝ) (policySet : Set (Policy ℝ)) {n : ℕ} (σ : ℝ) (hn1 : 1 ≤ n) (hwin : MarginWindow u0) (hσ : σ = 1 ∨ σ = -1) : ZeroEffectRegular (twoPointWitness α γ u0 cB n σ) policySet := by left let P : ObservedLaw ℝ := twoPointWitness α γ u0 cB n σ change P.PX.real {x | P.contrast x = 0} = 0 have hh_pos : 0 < hLower α γ n := by have hnpos : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 exact hLower_pos_of_pos_nat α γ hnpos have hτ0_pos : 0 < (u0 + 2) / 2 := by linarith [hwin.1] have hzero_empty : {x | P.contrast x = 0} = ∅ := by ext x constructor · intro hx change P.contrast x = 0 at hx by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · have hc : P.contrast x = σ * hLower α γ n := by simp [P, twoPointWitness, hxB] rw [hc] at hx rcases hσ with rfl | rfl · linarith · linarith · have hc : P.contrast x = (u0 + 2) / 2 := by simp [P, twoPointWitness, hxB] rw [hc] at hx linarith · intro hx cases hx rw [hzero_empty, measureReal_empty]
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_zeroEffect · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:635
theorem twoPointWitness_marginTail

Each two-point witness obeys the Tsybakov margin condition with exponent α and constant C_m, provided the block-width constant c_B is positive and at most C_m.

Formal statement
α γ u0 cB Cm :
n :
σ :
:
0 ≤ α
hwin :
hCm :
0 < Cm
hcB :
0 < cB
hcBm :
cB ≤ Cm
hn1 :
1 ≤ n
:
σ = 1 ∨ σ = -1
MarginTail (twoPointWitness α γ u0 cB n σ) Cm α u0
Proof (Lean source)
lemma twoPointWitness_marginTail (α γ u0 cB Cm : ℝ) {n : ℕ} (σ : ℝ) (hα : 0 ≤ α) (hwin : MarginWindow u0) (hCm : 0 < Cm) (hcB : 0 < cB) (hcBm : cB ≤ Cm) (hn1 : 1 ≤ n) (hσ : σ = 1 ∨ σ = -1) : MarginTail (twoPointWitness α γ u0 cB n σ) Cm α u0 := by refine ⟨hα, hCm, hwin.1, ?_⟩ intro u hu hu_le let P : ObservedLaw ℝ := twoPointWitness α γ u0 cB n σ let h : ℝ := hLower α γ n let B : Set ℝ := Icc (0 : ℝ) (cB * h ^ α) let E : Set ℝ := {x | 0 < |P.contrast x| ∧ |P.contrast x| ≤ u} change P.PX.real E ≤ Cm * u ^ α have hnposNat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hh_pos : 0 < h := by simpa [h] using hLower_pos_of_pos_nat α γ hnposNat have hsig_abs : |σ * h| = h := by rcases hσ with rfl | rfl · simp [abs_of_pos hh_pos] · simp [abs_of_pos hh_pos] have hτ0_pos : 0 < (u0 + 2) / 2 := by linarith [hwin.1] have hτ0_gt : u0 < (u0 + 2) / 2 := by linarith [hwin.2] have hprobPX : IsProbabilityMeasure P.PX := by simpa [P, twoPointWitness] using restricted_volume_Icc01_isProbabilityMeasure letI : IsProbabilityMeasure P.PX := hprobPX have hB_nonneg : 0 ≤ cB * h ^ α := mul_nonneg hcB.le (Real.rpow_nonneg hh_pos.le _) have hsubsetB : E ⊆ B := by intro x hx by_contra hxB have hxBpred : ¬ (0 ≤ x ∧ x ≤ cB * h ^ α) := by simpa [B] using hxB have hcontrast_off : P.contrast x = (u0 + 2) / 2 := by simp [P, twoPointWitness, h, hxBpred] have hτ0_le_u : (u0 + 2) / 2 ≤ u := by have := hx.2 rw [hcontrast_off] at this simpa [abs_of_pos hτ0_pos] using this linarith have hBmass : P.PX.real B ≤ cB * h ^ α := by have hbase := restricted_volume_real_Icc_zero_le (a := cB * h ^ α) hB_nonneg simpa [P, twoPointWitness, B, h] using hbase have hmass : P.PX.real E ≤ cB * h ^ α := (measureReal_mono (μ := P.PX) hsubsetB (measure_ne_top P.PX B)).trans hBmass by_cases hhu : h ≤ u · have hhpow : h ^ α ≤ u ^ α := Real.rpow_le_rpow hh_pos.le hhu hα calc P.PX.real E ≤ cB * h ^ α := hmass _ ≤ cB * u ^ α := mul_le_mul_of_nonneg_left hhpow hcB.le _ ≤ Cm * u ^ α := mul_le_mul_of_nonneg_right hcBm (Real.rpow_nonneg hu.le _) · have hEempty : E = ∅ := by ext x constructor · intro hx have hxB : x ∈ B := hsubsetB hx have hxBpred : 0 ≤ x ∧ x ≤ cB * h ^ α := by simpa [B] using hxB have hcontrast_on : P.contrast x = σ * h := by simp [P, twoPointWitness, h, hxBpred] have hle : h ≤ u := by have := hx.2 rw [hcontrast_on, hsig_abs] at this exact this exact elim (hhu hle) · intro hx cases hx rw [hEempty, measureReal_empty] exact mul_nonneg hCm.le (Real.rpow_nonneg hu.le _)
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_marginTail · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:670
theorem twoPointWitness_boundedOutcome

Each two-point witness has outcomes in [-1,1], for either sign σ = ±1.

Formal statement
α γ u0 cB σ :
n :
hwin :
hn1 :
1 ≤ n
hh_le_half :
hLower α γ n ≤ 1 / 2
:
σ = 1 ∨ σ = -1
BoundedOutcome (twoPointWitness α γ u0 cB n σ)
Proof (Lean source)
lemma twoPointWitness_boundedOutcome (α γ u0 cB σ : ℝ) {n : ℕ} (hwin : MarginWindow u0) (hn1 : 1 ≤ n) (hh_le_half : hLower α γ n ≤ 1 / 2) (hσ : σ = 1 ∨ σ = -1) : BoundedOutcome (twoPointWitness α γ u0 cB n σ) := by let h : ℝ := hLower α γ n let q : ℝ := qLower α γ n let τ0 : ℝ := (u0 + 2) / 2 let inBlock : ℝ → Prop := fun x => 0 ≤ x ∧ x ≤ cB * h ^ α let prop : ℝ → ℝ := fun x => if inBlock x then q else 1 / 2 let outcome : ℝ → BoolMeasure ℝ := fun x a => if inBlock x then (if a then bernoulliPM (σ * h) else Measure.dirac 0) else (if a then bernoulliPM (τ0 / 2) else bernoulliPM (-τ0 / 2)) let m : Measure ℝ := volume.restrict (Icc (0 : ℝ) 1) have hbad_meas : MeasurableSet {O : Observation ℝ | O.Y ∉ Icc (-1 : ℝ) 1} := by exact measurableSet_Icc.compl.preimage measurable_observation_Y have hout_bad : ∀ x a, outcome x a {y | y ∉ Icc (-1 : ℝ) 1} = 0 := by intro x a by_cases hxB : inBlock x · dsimp [outcome] simp [hxB] by_cases ha : a · simpa [ha, Set.mem_Icc] using bernoulliPM_bad_support_zero (σ * h) · simp [ha] · dsimp [outcome] simp [hxB] by_cases ha : a · simpa [ha, Set.mem_Icc] using bernoulliPM_bad_support_zero (τ0 / 2) · simpa [ha, Set.mem_Icc] using bernoulliPM_bad_support_zero (-τ0 / 2) have hbad_zero : ((m.bind fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) {O | O.Y ∉ Icc (-1 : ℝ) 1}) = 0 := by have ha_zero : ∀ x a, ((outcome x a).map (Observation.mk x a)) {O | O.Y ∉ Icc (-1 : ℝ) 1} = 0 := by intro x a rw [Measure.map_apply (measurable_observation_mk x a) hbad_meas] simpa using hout_bad x a have ha_zero' : ∀ x a, ((outcome x a).map (Observation.mk x a)) {O | -1 ≤ O.Y → 1 < O.Y} = 0 := by intro x a simpa [Set.mem_Icc] using ha_zero x a apply le_antisymm · calc ((m.bind fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) {O | O.Y ∉ Icc (-1 : ℝ) 1}) ≤ ∫⁻ x, (((bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) {O | O.Y ∉ Icc (-1 : ℝ) 1}) ∂m := Measure.bind_apply_le _ hbad_meas _ ≤ ∫⁻ x, ∫⁻ a, (((outcome x a).map (Observation.mk x a)) {O | O.Y ∉ Icc (-1 : ℝ) 1}) ∂bernoulliBool (prop x) ∂m := by exact lintegral_mono fun x => Measure.bind_apply_le _ hbad_meas _ = 0 := by simp [ha_zero'] · exact bot_le constructor · rw [ae_iff] simpa [twoPointWitness, h, q, τ0, inBlock, prop, outcome, m] using hbad_zero · intro x by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · constructor · simp [twoPointWitness, hxB] · have hh_pos : 0 < hLower α γ n := by have hnpos : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 exact hLower_pos_of_pos_nat α γ hnpos have habs : |σ * hLower α γ n| = hLower α γ n := by rcases hσ with rfl | rfl · simp [abs_of_pos hh_pos] · simp [abs_of_pos hh_pos] have hle : |σ * hLower α γ n| ≤ 1 := by rw [habs]; linarith simpa [twoPointWitness, hxB] using (show (σ * hLower α γ n) ∈ Icc (-1 : ℝ) 1 from ⟨(abs_le.mp hle).1, (abs_le.mp hle).2⟩) · constructor · have hτlo : -1 ≤ -((u0 + 2) / 2) / 2 := by linarith [hwin.2] have hτhi : -((u0 + 2) / 2) / 2 ≤ 1 := by linarith [hwin.1] simpa [twoPointWitness, hxB] using (show (-((u0 + 2) / 2) / 2) ∈ Icc (-1 : ℝ) 1 from ⟨hτlo, hτhi⟩) · have hτlo : -1 ≤ ((u0 + 2) / 2) / 2 := by linarith [hwin.1] have hτhi : ((u0 + 2) / 2) / 2 ≤ 1 := by linarith [hwin.2] simpa [twoPointWitness, hxB] using (show (((u0 + 2) / 2) / 2) ∈ Icc (-1 : ℝ) 1 from ⟨hτlo, hτhi⟩)
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_boundedOutcome · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:741
theorem twoPointWitness_wellFormed

Each two-point witness is a well-formed observed law, for either sign σ = ±1.

Formal statement
α γ u0 cB σ :
n :
hwin :
hn1 :
1 ≤ n
hh_le_half :
hLower α γ n ≤ 1 / 2
:
σ = 1 ∨ σ = -1
hq :
0 < qLower α γ n ∧ qLower α γ n ≤ 1 / 2
WellFormedLaw (twoPointWitness α γ u0 cB n σ)
Proof (Lean source)
lemma twoPointWitness_wellFormed (α γ u0 cB σ : ℝ) {n : ℕ} (hwin : MarginWindow u0) (hn1 : 1 ≤ n) (hh_le_half : hLower α γ n ≤ 1 / 2) (hσ : σ = 1 ∨ σ = -1) (hq : 0 < qLower α γ n ∧ qLower α γ n ≤ 1 / 2) : WellFormedLaw (twoPointWitness α γ u0 cB n σ) := by classical let h : ℝ := hLower α γ n let q : ℝ := qLower α γ n let τ0 : ℝ := (u0 + 2) / 2 let inBlock : ℝ → Prop := fun x => 0 ≤ x ∧ x ≤ cB * h ^ α let prop : ℝ → ℝ := fun x => if inBlock x then q else 1 / 2 let contrast : ℝ → ℝ := fun x => if inBlock x then σ * h else τ0 let mu0 : ℝ → ℝ := fun x => if inBlock x then 0 else -τ0 / 2 let mu1 : ℝ → ℝ := fun x => if inBlock x then σ * h else τ0 / 2 let outcome : ℝ → BoolMeasure ℝ := fun x a => if inBlock x then (if a then bernoulliPM (σ * h) else Measure.dirac 0) else (if a then bernoulliPM (τ0 / 2) else bernoulliPM (-τ0 / 2)) let m : Measure ℝ := volume.restrict (Icc (0 : ℝ) 1) let data : Measure (Observation ℝ) := m.bind fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a) have hmprob : IsProbabilityMeasure m := by simpa [m] using restricted_volume_Icc01_isProbabilityMeasure letI : IsProbabilityMeasure m := hmprob have hprop_bounds : ∀ x, 0 ≤ prop x ∧ prop x ≤ 1 := by intro x by_cases hxB : inBlock x · simp [prop, hxB] exact ⟨hq.1.le, hq.2.trans (by norm_num)⟩ · simp [prop, hxB] norm_num have hp1 : ∀ x, IsProbabilityMeasure (bernoulliBool (prop x)) := by intro x exact bernoulliBool_isProbabilityMeasure (hprop_bounds x).1 (hprop_bounds x).2 have hBmeas : MeasurableSet {x | inBlock x} := by dsimp [inBlock] exact measurableSet_Icc have hprop_meas : Measurable prop := by dsimp [prop] exact Measurable.ite hBmeas measurable_const measurable_const have hcontrast_meas : Measurable contrast := by dsimp [contrast] exact Measurable.ite hBmeas measurable_const measurable_const have hmu0_meas : Measurable mu0 := by dsimp [mu0] exact Measurable.ite hBmeas measurable_const measurable_const have hmu1_meas : Measurable mu1 := by dsimp [mu1] exact Measurable.ite hBmeas measurable_const measurable_const have hnposNat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hh_pos : 0 < h := by simpa [h] using hLower_pos_of_pos_nat α γ hnposNat have hsig_abs : |σ * h| = h := by rcases hσ with rfl | rfl · simp [abs_of_pos hh_pos] · simp [abs_of_pos hh_pos] have hsig_le : |σ * h| ≤ 1 := by rw [hsig_abs] linarith have hp2 : ∀ x a, IsProbabilityMeasure (outcome x a) := by intro x a by_cases hxB : inBlock x · by_cases ha : a · dsimp [outcome] simp [hxB, ha] exact bernoulliPM_isProbabilityMeasure (abs_le.mp hsig_le).1 (abs_le.mp hsig_le).2 · dsimp [outcome] simpa [hxB, ha] using (show IsProbabilityMeasure (Measure.dirac (0 : ℝ)) by infer_instance) · by_cases ha : a · dsimp [outcome] simp [hxB, ha] have hlo : -1 ≤ τ0 / 2 := by dsimp [τ0]; linarith [hwin.1] have hhi : τ0 / 2 ≤ 1 := by dsimp [τ0]; linarith [hwin.2] exact bernoulliPM_isProbabilityMeasure hlo hhi · dsimp [outcome] simp [hxB, ha] have hlo : -1 ≤ -τ0 / 2 := by dsimp [τ0]; linarith [hwin.2] have hhi : -τ0 / 2 ≤ 1 := by dsimp [τ0]; linarith [hwin.1] exact bernoulliPM_isProbabilityMeasure hlo hhi have hκ1 : Measurable (fun x : ℝ => bernoulliBool (prop x)) := by exact measurable_bernoulliBool.comp hprop_meas have hκ2 : Measurable fun p : ℝ × Bool => outcome p.1 p.2 := by dsimp [outcome, inBlock] have hBprod : MeasurableSet {p : ℝ × Bool | 0 ≤ p.1 ∧ p.1 ≤ cB * h ^ α} := measurableSet_Icc.preimage measurable_fst have hAtrue : MeasurableSet {p : ℝ × Bool | p.2 = true} := (measurableSet_singleton true).preimage measurable_snd have hOn : Measurable fun p : ℝ × Bool => if p.2 = true then bernoulliPM (σ * h) else (Measure.dirac (0 : ℝ) : Measure ℝ) := by exact Measurable.ite hAtrue (show Measurable (fun _ : ℝ × Bool => bernoulliPM (σ * h)) from measurable_const) (show Measurable (fun _ : ℝ × Bool => (Measure.dirac (0 : ℝ) : Measure ℝ)) from measurable_const) have hOff : Measurable fun p : ℝ × Bool => if p.2 = true then bernoulliPM (τ0 / 2) else bernoulliPM (-τ0 / 2) := by exact Measurable.ite hAtrue (show Measurable (fun _ : ℝ × Bool => bernoulliPM (τ0 / 2)) from measurable_const) (show Measurable (fun _ : ℝ × Bool => bernoulliPM (-τ0 / 2)) from measurable_const) exact Measurable.ite hBprod hOn hOff have hg : ∀ (x : ℝ) (a : Bool), Measurable (fun y : ℝ => Observation.mk x a y) := by intro x a exact measurable_observation_mk x a have hmap : ∀ (x : ℝ), Measurable fun a : Bool => (outcome x a).map (Observation.mk x a) := by intro x exact measurable_of_finite _ have hker : Measurable fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a) := by rw [show (fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) = (fun x => ofReal (if inBlock x then q else 1 / 2) • Measure.map (Observation.mk x true) (if inBlock x then bernoulliPM (σ * h) else bernoulliPM (τ0 / 2)) + ofReal (1 - (if inBlock x then q else 1 / 2)) • Measure.map (Observation.mk x false) (if inBlock x then Measure.dirac 0 else bernoulliPM (-τ0 / 2))) by funext x rw [bernoulliBool_bind] simp [outcome, prop]] exact twoPointWitness_expanded_kernel_measurable α cB σ h q τ0 have hdata_prob : IsProbabilityMeasure data := by have hmapprob : ∀ x a, IsProbabilityMeasure ((outcome x a).map (Observation.mk x a)) := by intro x a letI : IsProbabilityMeasure (outcome x a) := hp2 x a exact Measure.isProbabilityMeasure_map (hg x a).aemeasurable have hinner : ∀ x, IsProbabilityMeasure ((bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) := by intro x letI : IsProbabilityMeasure (bernoulliBool (prop x)) := hp1 x exact isProbabilityMeasure_bind (hmap x).aemeasurable (Filter.Eventually.of_forall fun a => hmapprob x a) change IsProbabilityMeasure (m.bind fun x => (bernoulliBool (prop x)).bind fun a => (outcome x a).map (Observation.mk x a)) exact isProbabilityMeasure_bind hker.aemeasurable (Filter.Eventually.of_forall fun x => hinner x) have hmapX : data.map (fun O : Observation ℝ => O.X) = m := by have hmap_eq := map_bind_bind_map_proj (m := m) (κ₁ := fun x : ℝ => bernoulliBool (prop x)) (κ₂ := outcome) (g := fun x a y => Observation.mk x a y) (π := fun O : Observation ℝ => O.X) hp1 hp2 hg hmap hker measurable_observation_X (by intro x a y; rfl) simpa [data] using hmap_eq have hmu1_abs : ∀ x, |mu1 x| ≤ 1 := by intro x by_cases hxB : inBlock x · simp [mu1, hxB, hsig_abs] linarith · dsimp [mu1] simp [hxB] have hlo : -1 ≤ τ0 / 2 := by dsimp [τ0]; linarith [hwin.1] have hhi : τ0 / 2 ≤ 1 := by dsimp [τ0]; linarith [hwin.2] exact abs_le.mpr ⟨hlo, hhi⟩ have hmu0_abs : ∀ x, |mu0 x| ≤ 1 := by intro x by_cases hxB : inBlock x · simp [mu0, hxB] · dsimp [mu0] simp [hxB] have hlo : -1 ≤ -τ0 / 2 := by dsimp [τ0]; linarith [hwin.2] have hhi : -τ0 / 2 ≤ 1 := by dsimp [τ0]; linarith [hwin.1] exact abs_le.mpr ⟨hlo, hhi⟩ refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ · simpa [twoPointWitness, h, q, τ0, inBlock, prop, outcome, m, data] using hdata_prob · simpa [twoPointWitness, m] using hmprob · simpa [twoPointWitness, h, q, τ0, inBlock, prop, outcome, m, data] using hmapX · simpa [twoPointWitness, h, q, τ0, inBlock, contrast] using hcontrast_meas · simpa [twoPointWitness, h, q, τ0, inBlock, prop] using hprop_meas · simpa [twoPointWitness, h, q, τ0, inBlock, mu0] using hmu0_meas · simpa [twoPointWitness, h, q, τ0, inBlock, mu1] using hmu1_meas · intro x by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · simp [twoPointWitness, hxB] · simp [twoPointWitness, hxB] ring · intro x by_cases hxB : 0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α · simp [twoPointWitness, hxB] exact ⟨hq.1.le, hq.2.trans (by norm_num)⟩ · simp [twoPointWitness, hxB] norm_num · intro φ hφmeas hφbdd let f : Observation ℝ → ℝ := fun O => boolIndicator O.A * φ O.X have hfmeas : Measurable f := by exact ((measurable_of_finite (fun b : Bool => boolIndicator b)).comp measurable_observation_A).mul (hφmeas.comp measurable_observation_X) rcases hφbdd with ⟨M, hM⟩ have hMnonneg : 0 ≤ M := (abs_nonneg (φ 0)).trans (hM 0) have hfbdd : ∃ M' : ℝ, ∀ O, |f O| ≤ M' := by refine ⟨M, ?_⟩ intro O have hb : |boolIndicator O.A| ≤ (1 : ℝ) := by cases O.A <;> simp [boolIndicator] calc |f O| = |boolIndicator O.A| * |φ O.X| := by simp [f, abs_mul] _ ≤ 1 * M := mul_le_mul hb (hM O.X) (abs_nonneg _) (by norm_num) _ = M := one_mul M have hf : Integrable f data := by letI : IsProbabilityMeasure data := hdata_prob exact integrable_of_measurable_bounded hfmeas hfbdd have hinner_const : ∀ x a, ∫ y, f (Observation.mk x a y) ∂outcome x a = boolIndicator a * φ x := by intro x a letI : IsProbabilityMeasure (outcome x a) := hp2 x a simp [f] have hf₂ : ∀ᵐ x ∂m, Integrable (fun a => ∫ y, f (Observation.mk x a y) ∂outcome x a) (bernoulliBool (prop x)) := by exact Filter.Eventually.of_forall fun x => by letI : IsProbabilityMeasure (bernoulliBool (prop x)) := hp1 x exact Integrable.of_finite have hf' : Integrable (fun x => ∫ a, ∫ y, f (Observation.mk x a y) ∂outcome x a ∂bernoulliBool (prop x)) m := by have hcollapse_point : (fun x => ∫ a, ∫ y, f (Observation.mk x a y) ∂outcome x a ∂bernoulliBool (prop x)) = fun x => prop x * φ x := by funext x rw [bernoulliBool_integral (hprop_bounds x).1 (hprop_bounds x).2] simp [hinner_const, boolIndicator] rw [hcollapse_point] have hmeas : Measurable (fun x => prop x * φ x) := by exact hprop_meas.mul hφmeas have hbdd : ∃ M' : ℝ, ∀ x, |prop x * φ x| ≤ M' := by refine ⟨M, ?_⟩ intro x have hp_nonneg := (hprop_bounds x).1 have hp_le := (hprop_bounds x).2 have hpabs : |prop x| ≤ 1 := by rwa [abs_of_nonneg hp_nonneg] calc |prop x * φ x| = |prop x| * |φ x| := abs_mul _ _ _ ≤ 1 * M := mul_le_mul hpabs (hM x) (abs_nonneg _) (by norm_num) _ = M := one_mul M exact integrable_of_measurable_bounded hmeas hbdd have hcollapse := integral_bind_bind_map (m := m) (κ₁ := fun x : ℝ => bernoulliBool (prop x)) (κ₂ := outcome) (g := fun x a y => Observation.mk x a y) (f := f) hg hmap hker hf -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_wellFormed · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:829
theorem witness_membership Lemma 1 in the paper ↗

lem:witness-membership. For all large n the two witness laws belong to def:law-class, and the two explicit witness-optimal policies are x ↦ 1 (under P_{n,+}) and x ↦ 1{x ∉ B_n} (under P_{n,-}); if these belong to Π they are the two policy actions of the two-point reduction. The membership is DERIVED from the construction, not assumed.

Formal statement
α γ u0 cB Cm Co co underlineP :
policySet :
Set (Policy ℝ)
σ :
:
0 ≤ α
:
0 ≤ γ
hwin :
hCm :
0 < Cm
hCo :
0 < Co
hco :
0 < co
hcB :
0 < cB
hcBm :
cB ≤ Cm
hcBo :
cB ≤ Co
hup :
0 < underlineP
note c_B overlap-decay smallness (def:two-point-witness constant choice)
hcB_gpos :
0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))
hcB_gzero :
0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))
huple :
underlineP ≤ 1 / 4
:
σ = 1 ∨ σ = -1
∀ᶠ n : ℕ in atTop,
LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n σ) ∧
(∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧
(∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α))
Proof (Lean source)
lemma witness_membership (α γ u0 cB Cm Co co underlineP : ℝ) (policySet : Set (Policy ℝ)) (σ : ℝ) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hwin : MarginWindow u0) (hCm : 0 < Cm) (hCo : 0 < Co) (hco : 0 < co) (hcB : 0 < cB) (hcBm : cB ≤ Cm) (hcBo : cB ≤ Co) (hup : 0 < underlineP) -- note c_B overlap-decay smallness (def:two-point-witness constant choice) (hcB_gpos : 0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))) (hcB_gzero : 0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))) (huple : underlineP ≤ 1 / 4) (hσ : σ = 1 ∨ σ = -1) : ∀ᶠ n : ℕ in atTop, LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n σ) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)) := by /- The note's active-block overlap-decay verification needs exactly `hcBo`, `hcB_gpos`, and `hcB_gzero`: for `γ = 0` the block mass is controlled by `cB ≤ Co`; for `0 < γ, 0 < α` by `cB ≤ Co * co ^ (-(α / γ))`; and for `0 < γ, α = 0` by `cB ≤ Co * 4 ^ (-(1 / γ))`. The `OverlapDecay` window now includes the required hypothesis `u ≤ u0`. Since the off-block contrast is `(u0 + 2) / 2 > u0`, every admissible overlap-decay event is confined to the active block. The remaining calculation is the active-block mass/exponent split used in the note: `γ=0` by `hcBo`, `γ>0, α>0` by `hcB_gpos` and `(α+1) * betaAG α γ / γ = α`, and `γ>0, α=0` by `hcB_gzero`. -/ classical have hod_eventually : ∀ᶠ n : ℕ in atTop, OverlapDecay (twoPointWitness α γ u0 cB n σ) u0 Co co α γ := by /- For `0 < u ≤ u0`, the off-block branch has contrast `τ0 = (u0 + 2) / 2 > u0`, so the event cannot contain off-block points. What remains is the active block `B_n`, with mass `cB * hLower α γ n ^ α` and overlap scale `qLower α γ n`. The three note cases listed above discharge the bound. -/ have hh_event := eventually_hLower_le_half α γ hα hγ have hq_event := eventually_qLower_pos_le_half α γ hα hγ filter_upwards [hh_event, hq_event, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hh_le_half hq_props hn1 intro u v hu hu_le hv hv_le let P : ObservedLaw ℝ := twoPointWitness α γ u0 cB n σ let h : ℝ := hLower α γ n let q : ℝ := qLower α γ n let B : Set ℝ := Icc (0 : ℝ) (cB * h ^ α) let E : Set ℝ := {x | overlap P x ≤ v ∧ 0 < |P.contrast x| ∧ |P.contrast x| ≤ u} change P.PX.real E ≤ Co * u ^ α * (if γ = 0 then 1 else v ^ (1 / γ)) have hnposNat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hh_pos : 0 < h := by simpa [h] using hLower_pos_of_pos_nat α γ hnposNat have hq_pos : 0 < q := by simpa [q] using hq_props.1 have hq_le_half : q ≤ (1 / 2 : ℝ) := by simpa [q] using hq_props.2 have hq_le_one_sub : q ≤ 1 - q := by linarith have hsig_abs : |σ * h| = h := by rcases hσ with rfl | rfl · simp [abs_of_pos hh_pos] · simp [abs_of_pos hh_pos] have hτ0_pos : 0 < (u0 + 2) / 2 := by linarith [hwin.1] have hτ0_gt : u0 < (u0 + 2) / 2 := by linarith [hwin.2] have hprobPX : IsProbabilityMeasure P.PX := by simpa [P, twoPointWitness] using restricted_volume_Icc01_isProbabilityMeasure letI : IsProbabilityMeasure P.PX := hprobPX have hB_nonneg : 0 ≤ cB * h ^ α := mul_nonneg hcB.le (Real.rpow_nonneg hh_pos.le _) have hsubsetB : E ⊆ B := by intro x hx by_contra hxB have hxBpred : ¬ (0 ≤ x ∧ x ≤ cB * h ^ α) := by simpa [B] using hxB have hcontrast_off : P.contrast x = (u0 + 2) / 2 := by simp [P, twoPointWitness, h, hxBpred] have habs : |P.contrast x| ≤ u := hx.2.2 have hτ0_le_u : (u0 + 2) / 2 ≤ u := by rw [hcontrast_off] at habs simpa [abs_of_pos hτ0_pos] using habs linarith have hBmass : P.PX.real B ≤ cB * h ^ α := by have hbase := restricted_volume_real_Icc_zero_le (a := cB * h ^ α) hB_nonneg simpa [P, twoPointWitness, B, h] using hbase have hmass : P.PX.real E ≤ cB * h ^ α := (measureReal_mono (μ := P.PX) hsubsetB (measure_ne_top P.PX B)).trans hBmass have hrhs_nonneg : 0 ≤ Co * u ^ α * (if γ = 0 then 1 else v ^ (1 / γ)) := by by_cases hγ0 : γ = 0 · simp [hγ0, mul_nonneg hCo.le (Real.rpow_nonneg hu.le _)] · simpa [hγ0] using mul_nonneg (mul_nonneg hCo.le (Real.rpow_nonneg hu.le _)) (Real.rpow_nonneg hv.le _) have hE_empty_of_not_hle : ¬ h ≤ u → E = ∅ := by intro hnot ext x constructor · intro hx have hxB : x ∈ B := hsubsetB hx have hxBpred : 0 ≤ x ∧ x ≤ cB * h ^ α := by simpa [B] using hxB have hcontrast_on : P.contrast x = σ * h := by simp [P, twoPointWitness, h, hxBpred] have hle : h ≤ u := by have := hx.2.2 rw [hcontrast_on, hsig_abs] at this exact this exact elim (hnot hle) · intro hx simp at hx have hE_empty_of_not_qle : ¬ q ≤ v → E = ∅ := by intro hnot ext x constructor · intro hx have hxB : x ∈ B := hsubsetB hx have hxBpred : 0 ≤ x ∧ x ≤ cB * h ^ α := by simpa [B] using hxB have hoverlap_on : overlap P x = q := by simp [P, overlap, twoPointWitness, h, q, hxBpred] simpa [q] using hq_le_one_sub have hle : q ≤ v := by simpa [hoverlap_on] using hx.1 exact elim (hnot hle) · intro hx cases hx by_cases hγ0 : γ = 0 · by_cases hhu : h ≤ u · have hhpow : h ^ α ≤ u ^ α := Real.rpow_le_rpow hh_pos.le hhu hα calc P.PX.real E ≤ cB * h ^ α := hmass _ ≤ cB * u ^ α := mul_le_mul_of_nonneg_left hhpow hcB.le _ ≤ Co * u ^ α := mul_le_mul_of_nonneg_right hcBo (Real.rpow_nonneg hu.le _) _ = Co * u ^ α * (if γ = 0 then 1 else v ^ (1 / γ)) := by simp [hγ0] · have hEempty := hE_empty_of_not_hle hhu rw [hEempty, measureReal_empty] exact hrhs_nonneg · have hγpos : 0 < γ := lt_of_le_of_ne hγ (Ne.symm hγ0) by_cases hhu : h ≤ u · by_cases hqv : q ≤ v · by_cases hα0 : α = 0 · have hβ0 : betaAG α γ = 0 := by unfold betaAG simp [hγ0, hα0] have hq_eq : q = (1 / 4 : ℝ) := by simp [q, qLower, hβ0] have hquarter_le_v : (1 / 4 : ℝ) ≤ v := by simpa [hq_eq] using hqv have hmass_cB : P.PX.real E ≤ cB := by simpa [hα0] using hmass calc P.PX.real E ≤ cB := hmass_cB _ ≤ Co * v ^ (1 / γ) := activeBlock_overlap_bound_gzero hγpos hCo (hcB_gzero hγpos hα0) hquarter_le_v _ = Co * u ^ α * (if γ = 0 then 1 else v ^ (1 / γ)) := by simp [hγ0, hα0] · have hαpos : 0 < α := lt_of_le_of_ne hα (Ne.symm hα0) have hβpos : 0 < betaAG α γ := by unfold betaAG have hdenpos : 0 < α + 1 := by linarith simp [hγ0, div_pos (mul_pos hαpos hγpos) hdenpos] have hβne : betaAG α γ ≠ 0 := ne_of_gt hβpos have hq_eq : q = h ^ betaAG α γ := by simp [q, qLower, h, hβne] have hqv' : h ^ betaAG α γ ≤ v := by simpa [hq_eq] using hqv calc P.PX.real E ≤ cB * h ^ α := hmass _ ≤ Co * u ^ α * v ^ (1 / γ) := activeBlock_overlap_bound_gpos hαpos hγpos hCo hco (hcB_gpos hγpos hαpos) hh_pos hu hv hqv' hv_le _ = Co * u ^ α * (if γ = 0 then 1 else v ^ (1 / γ)) := by simp [hγ0] · have hEempty := hE_empty_of_not_qle hqv rw [hEempty, measureReal_empty] exact hrhs_nonneg · have hEempty := hE_empty_of_not_hle hhu rw [hEempty, measureReal_empty] exact hrhs_nonneg filter_upwards [hod_eventually, eventually_hLower_le_half α γ hα hγ, eventually_qLower_pos_le_half α γ hα hγ, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hod hh_le_half hq_props hn1 have hrest : LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n σ) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)) := by have hwf : WellFormedLaw (twoPointWitness α γ u0 cB n σ) := twoPointWitness_wellFormed α γ u0 cB σ hwin hn1 hh_le_half hσ hq_props have hbdd : BoundedOutcome (twoPointWitness α γ u0 cB n σ) := twoPointWitness_boundedOutcome α γ u0 cB σ hwin hn1 hh_le_half hσ have hpos : Positivity (twoPointWitness α γ u0 cB n σ) := twoPointWitness_positivity α γ u0 cB σ n hq_props have hmargin : MarginTail (twoPointWitness α γ u0 cB n σ) Cm α u0 := twoPointWitness_marginTail α γ u0 cB Cm σ hα hwin hCm hcB hcBm hn1 hσ have hzero : ZeroEffectRegular (twoPointWitness α γ u0 cB n σ) policySet := twoPointWitness_zeroEffect α γ u0 cB policySet σ hn1 hwin hσ have hstrict : StrictOverlapEndpoint (twoPointWitness α γ u0 cB n σ) γ underlineP := twoPointWitness_strictOverlapEndpoint α γ u0 cB underlineP σ n hq_props hup huple have hopt_plus := twoPointWitness_optimal_plus α γ u0 cB hn1 hwin have hopt_minus := twoPointWitness_optimal_minus α γ u0 cB hn1 hwin exact ⟨ { wf := hwf bdd := hbdd pos := hpos margin := hmargin zero := hzero overlapDecay := hod strict := hstrict }, hopt_plus, hopt_minus⟩ rcases hrest with ⟨hclass, hopt_plus, hopt_minus⟩ exact ⟨{ hclass with overlapDecay := hod }, hopt_plus, hopt_minus⟩
CausalSmith.Stat.PolicyRegretMarginOverlap.witness_membership · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:1303
theorem chiSqDiv_three_cell_bound_of_restrict Lemma lem:three-cell-chiSq-bound in the paper ↗

Three-cell χ² bound from proportional restrictions.

Formal statement
Ω :
Pplus Pminus :
s :
Fin 3 → Set Ω
A m q h :
hac :
Pplus ≪ Pminus
hs :
∀ i, MeasurableSet (s i)
hdisj :
Pairwise (onFun Disjoint s)
hcover :
(⋃ i, s i) = univ
hh0 :
0 ≤ h
hh1 :
h ≤ (1 / 2 : ℝ)
hA_nonneg :
0 ≤ A
hA_le :
A ≤ m * q
hν1 :
(Pminus (s 1)).toReal = A * ((1 - h) / 2)
hν2 :
(Pminus (s 2)).toReal = A * ((1 + h) / 2)
hrestrict :
∀ i,
Pplus.restrict (s i)
= ofReal (if i = 0 then (1 : ℝ) else if i = 1 then (1 + h) / (1 - h) else (1 - h) / (1 + h)) • Pminus.restrict (s i)
chiSqDiv Pplus Pminus ≤ 8 * m * q * h ^ (2 : ℕ)
Proof (Lean source)
lemma chiSqDiv_three_cell_bound_of_restrict {Ω : Type*} [MeasurableSpace Ω] (Pplus Pminus : Measure Ω) [IsFiniteMeasure Pminus] (s : Fin 3 → Set Ω) (A m q h : ℝ) (hac : Pplus ≪ Pminus) (hs : ∀ i, MeasurableSet (s i)) (hdisj : Pairwise (onFun Disjoint s)) (hcover : (⋃ i, s i) = univ) (hh0 : 0 ≤ h) (hh1 : h ≤ (1 / 2 : ℝ)) (hA_nonneg : 0 ≤ A) (hA_le : A ≤ m * q) (hν1 : (Pminus (s 1)).toReal = A * ((1 - h) / 2)) (hν2 : (Pminus (s 2)).toReal = A * ((1 + h) / 2)) (hrestrict : ∀ i, Pplus.restrict (s i) = ofReal (if i = 0 then (1 : ℝ) else if i = 1 then (1 + h) / (1 - h) else (1 - h) / (1 + h)) • Pminus.restrict (s i)) : chiSqDiv Pplus Pminus ≤ 8 * m * q * h ^ (2 : ℕ) := by classical let c : Fin 3 → ℝ := fun i => if i = 0 then (1 : ℝ) else if i = 1 then (1 + h) / (1 - h) else (1 - h) / (1 + h) have hc_nonneg : ∀ i, 0 ≤ c i := by intro i dsimp [c] fin_cases i <;> simp only [Fin.isValue] · norm_num · exact div_nonneg (by linarith) (by linarith) · exact div_nonneg (by linarith) (by linarith) have hχ := CausalSmith.Mathlib.ProductChiSquared.chiSqDiv_eq_sum_partition_of_restrict_eq_smul Pplus Pminus s c hac hs hdisj hcover hc_nonneg (by intro i dsimp [c] exact hrestrict i) have hsum : (∑ i : Fin 3, (c i - 1) ^ (2 : ℕ) * (Pminus (s i)).toReal) ≤ 8 * (m * q * h ^ (2 : ℕ)) := by rw [Fin.sum_univ_three] dsimp [c] rw [hν1, hν2] have h1ph_pos : 0 < 1 + h := by linarith have h1mh_pos : 0 < 1 - h := by linarith have hden_pos : 0 < 1 - h ^ (2 : ℕ) := by nlinarith [sq_nonneg h, hh1] have hbound_factor : 4 / (1 - h ^ (2 : ℕ)) ≤ 8 := by have hhalf : (1 : ℝ) / 2 ≤ 1 - h ^ (2 : ℕ) := by nlinarith [sq_nonneg h, hh1] exact (div_le_iff₀ hden_pos).mpr (by nlinarith) have hAh_nonneg : 0 ≤ A * h ^ (2 : ℕ) := mul_nonneg hA_nonneg (sq_nonneg h) have hmq_nonneg : 0 ≤ m * q := hA_nonneg.trans hA_le have hmqh_nonneg : 0 ≤ m * q * h ^ (2 : ℕ) := mul_nonneg hmq_nonneg (sq_nonneg h) have hA_h_le : A * h ^ (2 : ℕ) ≤ m * q * h ^ (2 : ℕ) := mul_le_mul_of_nonneg_right hA_le (sq_nonneg h) calc ((1 : ℝ) - 1) ^ (2 : ℕ) * (Pminus (s 0)).toReal + ((1 + h) / (1 - h) - 1) ^ (2 : ℕ) * (A * ((1 - h) / 2)) + ((1 - h) / (1 + h) - 1) ^ (2 : ℕ) * (A * ((1 + h) / 2)) = (4 / (1 - h ^ (2 : ℕ))) * (A * h ^ (2 : ℕ)) := by field_simp [ne_of_gt h1ph_pos, ne_of_gt h1mh_pos, ne_of_gt hden_pos] ring _ ≤ 8 * (A * h ^ (2 : ℕ)) := mul_le_mul_of_nonneg_right hbound_factor hAh_nonneg _ ≤ 8 * (m * q * h ^ (2 : ℕ)) := mul_le_mul_of_nonneg_left hA_h_le (by norm_num) calc chiSqDiv Pplus Pminus = ∑ i : Fin 3, (c i - 1) ^ (2 : ℕ) * (Pminus (s i)).toReal := hχ _ ≤ 8 * (m * q * h ^ (2 : ℕ)) := hsum _ = 8 * m * q * h ^ (2 : ℕ) := by ring
CausalSmith.Stat.PolicyRegretMarginOverlap.chiSqDiv_three_cell_bound_of_restrict · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:1525
theorem twoPointWitness_one_draw_chiSq_bound

For all large enough sample sizes, the two members of the two-point pair are both probability laws, the σ = +1 law is absolutely continuous with respect to the σ = -1 law with square-integrable likelihood-ratio deviation, and their ONE-DRAW chi-squared divergence is at most 8 c_B h_n^{2+α+β_{α,γ}}.

Formal statement
α γ u0 cB :
hwin :
hcB :
0 < cB
:
0 ≤ α
:
0 ≤ γ
∀ᶠ n : ℕ in atTop,
IsProbabilityMeasure (twoPointWitness α γ u0 cB n 1).dataMeasure ∧
IsProbabilityMeasure (twoPointWitness α γ u0 cB n (-1)).dataMeasure ∧
(twoPointWitness α γ u0 cB n 1).dataMeasure ≪ (twoPointWitness α γ u0 cB n (-1)).dataMeasure ∧
Integrable (fun x => (((twoPointWitness α γ u0 cB n 1).dataMeasure.rnDeriv (twoPointWitness α γ u0 cB n (-1)).dataMeasure x).toReal - 1) ^ 2) (twoPointWitness α γ u0 cB n (-1)).dataMeasure ∧
chiSqDiv (twoPointWitness α γ u0 cB n 1).dataMeasure (twoPointWitness α γ u0 cB n (-1)).dataMeasure
≤ 8 * cB * (hLower α γ n) ^ (2 + α + betaAG α γ)
Proof (Lean source)
lemma twoPointWitness_one_draw_chiSq_bound (α γ u0 cB : ℝ) (hwin : MarginWindow u0) (hcB : 0 < cB) (hα : 0 ≤ α) (hγ : 0 ≤ γ) : ∀ᶠ n : ℕ in atTop, IsProbabilityMeasure (twoPointWitness α γ u0 cB n 1).dataMeasure ∧ IsProbabilityMeasure (twoPointWitness α γ u0 cB n (-1)).dataMeasure ∧ (twoPointWitness α γ u0 cB n 1).dataMeasure ≪ (twoPointWitness α γ u0 cB n (-1)).dataMeasure ∧ Integrable (fun x => (((twoPointWitness α γ u0 cB n 1).dataMeasure.rnDeriv (twoPointWitness α γ u0 cB n (-1)).dataMeasure x).toReal - 1) ^ 2) (twoPointWitness α γ u0 cB n (-1)).dataMeasure ∧ chiSqDiv (twoPointWitness α γ u0 cB n 1).dataMeasure (twoPointWitness α γ u0 cB n (-1)).dataMeasure ≤ 8 * cB * (hLower α γ n) ^ (2 + α + betaAG α γ) := by /- Local computation needed by `two_point_divergence`: for large `n`, `h = hLower α γ n ≤ 1/2`, `q = qLower α γ n ∈ (0,1/2]`, and the two witness laws have the same `(X,A)` kernel and the same outcome kernel except on `{x ∈ B_n, A = true}`. On that cell the outcome kernels are `bernoulliPM h` and `bernoulliPM (-h)`, so the RN ratio is the pulled-back Bernoulli ratio and the χ² contribution is `PX(B_n) * q * 4*h^2/(1-h^2) ≤ 8*cB*h^(2+α+betaAG α γ)`. The reusable finite-partition χ² reduction is now built above as `chiSqDiv_three_cell_bound_of_restrict`; the remaining substrate gap is the concrete restriction/mass calculation for this nested `Measure.bind`/`Measure.map` witness, namely the three cells `{¬(B_n X ∧ A)}`, `{B_n X ∧ A ∧ Y=1}`, and `{B_n X ∧ A ∧ Y=-1}`. -/ classical filter_upwards [eventually_hLower_le_half α γ hα hγ, eventually_qLower_pos_le_half α γ hα hγ, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hh_le_half hq hn1 let h : ℝ := hLower α γ n let q : ℝ := qLower α γ n let τ0 : ℝ := (u0 + 2) / 2 let B : Set ℝ := Icc (0 : ℝ) (cB * h ^ α) let prop : ℝ → ℝ := fun x => if x ∈ B then q else 1 / 2 let outcomeP : ℝ → BoolMeasure ℝ := fun x a => if x ∈ B then (if a then bernoulliPM h else Measure.dirac 0) else (if a then bernoulliPM (τ0 / 2) else bernoulliPM (-τ0 / 2)) let outcomeM : ℝ → BoolMeasure ℝ := fun x a => if x ∈ B then (if a then bernoulliPM (-h) else Measure.dirac 0) else (if a then bernoulliPM (τ0 / 2) else bernoulliPM (-τ0 / 2)) let m : Measure ℝ := volume.restrict (Icc (0 : ℝ) 1) let Pp : Measure (Observation ℝ) := (twoPointWitness α γ u0 cB n 1).dataMeasure let Pm : Measure (Observation ℝ) := (twoPointWitness α γ u0 cB n (-1)).dataMeasure let s1 : Set (Observation ℝ) := {O | O.X ∈ B ∧ O.A = true ∧ O.Y = (1 : ℝ)} let s2 : Set (Observation ℝ) := {O | O.X ∈ B ∧ O.A = true ∧ O.Y = (-1 : ℝ)} let s0 : Set (Observation ℝ) := (s1 ∪ s2)ᶜ let s : Fin 3 → Set (Observation ℝ) := fun i => if i = 0 then s0 else if i = 1 then s1 else s2 have hnposNat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hh_pos : 0 < h := by simpa [h] using hLower_pos_of_pos_nat α γ hnposNat have hh0 : 0 ≤ h := hh_pos.le have hq_pos : 0 < q := by simpa [q] using hq.1 have hq_nonneg : 0 ≤ q := hq_pos.le have hq_le_half : q ≤ (1 / 2 : ℝ) := by simpa [q] using hq.2 have hB_nonneg : 0 ≤ cB * h ^ α := mul_nonneg hcB.le (Real.rpow_nonneg hh_pos.le _) have hB_meas : MeasurableSet B := by dsimp [B] exact measurableSet_Icc have hs1 : MeasurableSet s1 := by have hX : MeasurableSet {O : Observation ℝ | O.X ∈ B} := hB_meas.preimage measurable_observation_X have hA : MeasurableSet {O : Observation ℝ | O.A = true} := (measurableSet_singleton true).preimage measurable_observation_A have hY : MeasurableSet {O : Observation ℝ | O.Y = (1 : ℝ)} := (measurableSet_singleton (1 : ℝ)).preimage measurable_observation_Y change MeasurableSet ({O : Observation ℝ | O.X ∈ B} ∩ ({O : Observation ℝ | O.A = true} ∩ {O : Observation ℝ | O.Y = (1 : ℝ)})) exact hX.inter (hA.inter hY) have hs2 : MeasurableSet s2 := by have hX : MeasurableSet {O : Observation ℝ | O.X ∈ B} := hB_meas.preimage measurable_observation_X have hA : MeasurableSet {O : Observation ℝ | O.A = true} := (measurableSet_singleton true).preimage measurable_observation_A have hY : MeasurableSet {O : Observation ℝ | O.Y = (-1 : ℝ)} := (measurableSet_singleton (-1 : ℝ)).preimage measurable_observation_Y change MeasurableSet ({O : Observation ℝ | O.X ∈ B} ∩ ({O : Observation ℝ | O.A = true} ∩ {O : Observation ℝ | O.Y = (-1 : ℝ)})) exact hX.inter (hA.inter hY) have hs0 : MeasurableSet s0 := by dsimp [s0] exact (hs1.union hs2).compl have hs : ∀ i, MeasurableSet (s i) := by intro i fin_cases i <;> simp [s, hs0, hs1, hs2] have hdisj01 : Disjoint s0 s1 := by rw [Set.disjoint_left] intro O h0 h1 exact h0 (inl h1) have hdisj02 : Disjoint s0 s2 := by rw [Set.disjoint_left] intro O h0 h2 exact h0 (inr h2) have hdisj12 : Disjoint s1 s2 := by rw [Set.disjoint_left] intro O h1 h2 have hy1 : O.Y = (1 : ℝ) := h1.2.2 have hy2 : O.Y = (-1 : ℝ) := h2.2.2 linarith have hdisj : Pairwise (onFun Disjoint s) := by intro i j hij fin_cases i <;> fin_cases j <;> simp [s] at hij ⊢ · exact hdisj01 · exact hdisj02 · exact hdisj01.symm · exact hdisj12 · exact hdisj02.symm · exact hdisj12.symm have hcover : (⋃ i, s i) = univ := by ext O constructor · intro _ trivial · intro _ by_cases hO : O ∈ s1 ∪ s2 · rcases hO with hO1 | hO2 · exact Set.mem_iUnion.mpr ⟨(1 : Fin 3), by simp [s, hO1]⟩ · exact Set.mem_iUnion.mpr ⟨(2 : Fin 3), by simp [s, hO2]⟩ · have hnot1 : O ∉ s1 := fun hO1 => hO (inl hO1) have hnot2 : O ∉ s2 := fun hO2 => hO (inr hO2) exact Set.mem_iUnion.mpr ⟨(0 : Fin 3), by simp [s, s0, hnot1, hnot2]⟩ have hPp_data : Pp = m.bind fun x => (bernoulliBool (prop x)).bind fun a => (outcomeP x a).map (Observation.mk x a) := by simp [Pp, twoPointWitness, h, q, τ0, B, prop, outcomeP, m] have hPm_data : Pm = m.bind fun x => (bernoulliBool (prop x)).bind fun a => (outcomeM x a).map (Observation.mk x a) := by simp [Pm, twoPointWitness, h, q, τ0, B, prop, outcomeM, m] have hkerP : Measurable fun x => (bernoulliBool (prop x)).bind fun a => (outcomeP x a).map (Observation.mk x a) := by rw [show (fun x => (bernoulliBool (prop x)).bind fun a => (outcomeP x a).map (Observation.mk x a)) = (fun x => ofReal (if x ∈ B then q else 1 / 2) • Measure.map (Observation.mk x true) (if x ∈ B then bernoulliPM h else bernoulliPM (τ0 / 2)) + ofReal (1 - (if x ∈ B then q else 1 / 2)) • Measure.map (Observation.mk x false) (if x ∈ B then Measure.dirac 0 else bernoulliPM (-τ0 / 2))) by funext x rw [bernoulliBool_bind] simp [outcomeP, prop]] simpa [B] using twoPointWitness_expanded_kernel_measurable α cB 1 h q τ0 have hkerM : Measurable fun x => (bernoulliBool (prop x)).bind fun a => (outcomeM x a).map (Observation.mk x a) := by rw [show (fun x => (bernoulliBool (prop x)).bind fun a => (outcomeM x a).map (Observation.mk x a)) = (fun x => ofReal (if x ∈ B then q else 1 / 2) • Measure.map (Observation.mk x true) (if x ∈ B then bernoulliPM ((-1 : ℝ) * h) else bernoulliPM (τ0 / 2)) + ofReal (1 - (if x ∈ B then q else 1 / 2)) • Measure.map (Observation.mk x false) (if x ∈ B then Measure.dirac 0 else bernoulliPM (-τ0 / 2))) by funext x rw [bernoulliBool_bind] simp [outcomeM, prop]] simpa [B] using twoPointWitness_expanded_kernel_measurable α cB (-1) h q τ0 have hinner0 : ∀ x (t : Set (Observation ℝ)), MeasurableSet t → ((bernoulliBool (prop x)).bind fun a => (outcomeP x a).map (Observation.mk x a)) (t ∩ s0) = ((bernoulliBool (prop x)).bind fun a => (outcomeM x a).map (Observation.mk x a)) (t ∩ s0) := by intro x t ht rw [bernoulliBool_bind, bernoulliBool_bind] rw [Measure.add_apply, Measure.add_apply, Measure.smul_apply, Measure.smul_apply, Measure.smul_apply, Measure.smul_apply] repeat rw [Measure.map_apply (measurable_observation_mk x true)] repeat rw [Measure.map_apply (measurable_observation_mk x false)] · by_cases hxB : x ∈ B <;> simp [prop, outcomeP, outcomeM, s0, s1, s2, hxB, bernoulliPM, twoPointMean] all_goals exact ht.inter hs0 have hinner1P : ∀ x (t : Set (Observation ℝ)), MeasurableSet t → ((bernoulliBool (prop x)).bind fun a => (outcomeP x a).map (Observation.mk x a)) (t ∩ s1) = (if x ∈ B then ofReal q * ofReal ((1 + h) / 2) * (if Observation.mk x true (1 : ℝ) ∈ t then 1 else 0) else 0) := by intro x t ht rw [bernoulliBool_bind] rw [Measure.add_apply, Measure.smul_apply, Measure.smul_apply] rw [Measure.map_apply (measurable_observation_mk x true)] rw [Measure.map_apply (measurable_observation_mk x false)] · by_cases hxB : x ∈ B · by_cases hxt : Observation.mk x true (1 : ℝ) ∈ t · simp [prop, outcomeP, s1, hxB, hxt, bernoulliPM, twoPointMean, Pi.single_eq_of_ne (show (-1 : ℝ) ≠ 1 by norm_num)] · simp [prop, outcomeP, s1, hxB, hxt, bernoulliPM, twoPointMean] · simp [prop, outcomeP, s1, hxB, bernoulliPM, twoPointMean] all_goals exact ht.inter hs1 have hinner1M : ∀ x (t : Set (Observation ℝ)), MeasurableSet t → ((bernoulliBool (prop x)).bind fun a => (outcomeM x a).map (Observation.mk x a)) (t ∩ s1) = (if x ∈ B then ofReal q * ofReal ((1 - h) / 2) * (if Observation.mk x true (1 : ℝ) ∈ t then 1 else 0) else 0) := by intro x t ht rw [bernoulliBool_bind] rw [Measure.add_apply, Measure.smul_apply, Measure.smul_apply] rw [Measure.map_apply (measurable_observation_mk x true)] rw [Measure.map_apply (measurable_observation_mk x false)] · by_cases hxB : x ∈ B · by_cases hxt : Observation.mk x true (1 : ℝ) ∈ t · simp [prop, outcomeM, s1, hxB, hxt, bernoulliPM, twoPointMean, Pi.single_eq_of_ne (show (-1 : ℝ) ≠ 1 by norm_num), show (1 + -h) / 2 = (1 - h) / 2 by ring] · simp [prop, outcomeM, s1, hxB, hxt, bernoulliPM, twoPointMean] · simp [prop, outcomeM, s1, hxB, bernoulliPM, twoPointMean] all_goals exact ht.inter hs1 have hinner2P : ∀ x (t : Set (Observation ℝ)), MeasurableSet t → ((bernoulliBool (prop x)).bind fun a => (outcomeP x a).map (Observation.mk x a)) (t ∩ s2) = (if x ∈ B then ofReal q * ofReal ((1 - h) / 2) * (if Observation.mk x true (-1 : ℝ) ∈ t then 1 else 0) else 0) := by intro x t ht rw [bernoulliBool_bind] rw [Measure.add_apply, Measure.smul_apply, Measure.smul_apply] rw [Measure.map_apply (measurable_observation_mk x true)] rw [Measure.map_apply (measurable_observation_mk x false)] · by_cases hxB : x ∈ B · by_cases hxt : Observation.mk x true (-1 : ℝ) ∈ t · simp [prop, outcomeP, s2, hxB, hxt, bernoulliPM, twoPointMean, Pi.single_eq_of_ne (show (1 : ℝ) ≠ -1 by norm_num)] · simp [prop, outcomeP, s2, hxB, hxt, bernoulliPM, twoPointMean] · simp [prop, outcomeP, s2, hxB, bernoulliPM, twoPointMean] all_goals exact ht.inter hs2 have hinner2M : ∀ x (t : Set (Observation ℝ)), MeasurableSet t → ((bernoulliBool (prop x)).bind fun a => (outcomeM x a).map (Observation.mk x a)) (t ∩ s2) = (if x ∈ B then ofReal q * ofReal ((1 + h) / 2) * (if Observation.mk x true (-1 : ℝ) ∈ t then 1 else 0) else 0) := by intro x t ht -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.twoPointWitness_one_draw_chiSq_bound · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:1612
theorem two_point_divergence Lemma 2 in the paper ↗

lem:two-point-divergence. The per-observation χ²-divergence scales as χ² ≤ C h_n^{2+α+β_{α,γ}} = C h_n^{D_{α,γ}} (i.e. m_n q_n h_n² with m_n ~ h_n^α, q_n ~ h_n^{β_{α,γ}}); with h_n = n^{-1/D_{α,γ}} the per-draw divergence is ≤ C/n, so by the product identity the n-fold divergence is uniformly bounded. The admissibility 8 c_B c_Q < log 5 (c_Q = 1 for the qLower weak-arm scale) keeps the product divergence below a constant.

Formal statement
α γ u0 cB :
hwin :
hcB :
0 < cB
:
0 ≤ α
:
0 ≤ γ
hconst :
8 * cB < log 5
∃ C : ℝ,
0 < C ∧
∀ᶠ n : ℕ in atTop,
(Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n 1).dataMeasure) ≪ (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) ∧
Integrable (fun x => (((Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n 1).dataMeasure).rnDeriv (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) x).toReal - 1) ^ 2) (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) ∧
chiSqDiv (twoPointWitness α γ u0 cB n 1).dataMeasure (twoPointWitness α γ u0 cB n (-1)).dataMeasure
≤ C * (hLower α γ n) ^ (2 + α + betaAG α γ) ∧
chiSqDiv (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n 1).dataMeasure) (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure)
≤ C
Proof (Lean source)
lemma two_point_divergence (α γ u0 cB : ℝ) (hwin : MarginWindow u0) (hcB : 0 < cB) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hconst : 8 * cB < log 5) : ∃ C : ℝ, 0 < C ∧ ∀ᶠ n : ℕ in atTop, (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n 1).dataMeasure) ≪ (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) ∧ Integrable (fun x => (((Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n 1).dataMeasure).rnDeriv (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) x).toReal - 1) ^ 2) (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) ∧ chiSqDiv (twoPointWitness α γ u0 cB n 1).dataMeasure (twoPointWitness α γ u0 cB n (-1)).dataMeasure ≤ C * (hLower α γ n) ^ (2 + α + betaAG α γ) ∧ chiSqDiv (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n 1).dataMeasure) (Measure.pi fun _ : Fin n => (twoPointWitness α γ u0 cB n (-1)).dataMeasure) ≤ C := by classical let C : ℝ := max (8 * cB) 5 have hCpos : 0 < C := by dsimp [C] exact lt_of_lt_of_le (by norm_num : (0 : ℝ) < 5) (le_max_right _ _) refine ⟨C, hCpos, ?_⟩ have hone := twoPointWitness_one_draw_chiSq_bound α γ u0 cB hwin hcB hα hγ filter_upwards [hone, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hone_n hn1 rcases hone_n with ⟨hprobPp0, hprobPm0, hac0, hint0, hchi8_0⟩ let Pp : Measure (Observation ℝ) := (twoPointWitness α γ u0 cB n 1).dataMeasure let Pm : Measure (Observation ℝ) := (twoPointWitness α γ u0 cB n (-1)).dataMeasure letI : IsProbabilityMeasure Pp := by simpa [Pp] using hprobPp0 letI : IsProbabilityMeasure Pm := by simpa [Pm] using hprobPm0 have hac : Pp ≪ Pm := by simpa [Pp, Pm] using hac0 have hint : Integrable (fun x => ((Pp.rnDeriv Pm x).toReal - 1) ^ 2) Pm := by simpa [Pp, Pm] using hint0 have hchi8 : chiSqDiv Pp Pm ≤ 8 * cB * (hLower α γ n) ^ (2 + α + betaAG α γ) := by simpa [Pp, Pm] using hchi8_0 have hnposNat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hnpos : 0 < (n : ℝ) := by exact_mod_cast hnposNat have hbeta_nonneg : 0 ≤ betaAG α γ := by unfold betaAG by_cases hγ0 : γ = 0 · simp [hγ0] · have hγpos : 0 < γ := lt_of_le_of_ne hγ (Ne.symm hγ0) have hdenpos : 0 < α + 1 := by linarith simp [hγ0, div_nonneg (mul_nonneg hα hγpos.le) hdenpos.le] have hDpos : 0 < Dag α γ := by unfold Dag linarith have hpowD : (hLower α γ n) ^ (2 + α + betaAG α γ) = (n : ℝ) ^ (-1 : ℝ) := by have hExp : 2 + α + betaAG α γ = Dag α γ := by rfl calc (hLower α γ n) ^ (2 + α + betaAG α γ) = (hLower α γ n) ^ (Dag α γ) := by rw [hExp] _ = ((n : ℝ) ^ (-(1 / Dag α γ))) ^ (Dag α γ) := by rfl _ = (n : ℝ) ^ (-(1 / Dag α γ) * Dag α γ) := by rw [← Real.rpow_mul hnpos.le] _ = (n : ℝ) ^ (-1 : ℝ) := by congr 1 field_simp [hDpos.ne'] have hp_pos : 0 < hLower α γ n := by unfold hLower exact Real.rpow_pos_of_pos hnpos _ have hpow_nonneg : 0 ≤ (hLower α γ n) ^ (2 + α + betaAG α γ) := Real.rpow_nonneg hp_pos.le _ have hchi_one : chiSqDiv Pp Pm ≤ C * (hLower α γ n) ^ (2 + α + betaAG α γ) := by calc chiSqDiv Pp Pm ≤ 8 * cB * (hLower α γ n) ^ (2 + α + betaAG α γ) := hchi8 _ ≤ C * (hLower α γ n) ^ (2 + α + betaAG α γ) := mul_le_mul_of_nonneg_right (le_max_left _ _) hpow_nonneg let Pprod : Measure (Fin n → Observation ℝ) := Measure.pi fun _ : Fin n => Pp let Qprod : Measure (Fin n → Observation ℝ) := Measure.pi fun _ : Fin n => Pm have hac_prod : Pprod ≪ Qprod := by dsimp [Pprod, Qprod] exact Causalean.Stat.pi_iid_absolutelyContinuous Pp Pm hac n have hint_prod : Integrable (fun x => ((Pprod.rnDeriv Qprod x).toReal - 1) ^ 2) Qprod := by dsimp [Pprod, Qprod] exact Causalean.Stat.pi_iid_integrable_sq_dev Pp Pm hac hint n have hchi_non : 0 ≤ chiSqDiv Pp Pm := Causalean.Stat.chiSqDiv_nonneg have hchi_per_inv : chiSqDiv Pp Pm ≤ 8 * cB * (n : ℝ) ^ (-1 : ℝ) := by simpa [hpowD] using hchi8 have hmul_budget : (n : ℝ) * chiSqDiv Pp Pm ≤ 8 * cB := by calc (n : ℝ) * chiSqDiv Pp Pm ≤ (n : ℝ) * (8 * cB * (n : ℝ) ^ (-1 : ℝ)) := mul_le_mul_of_nonneg_left hchi_per_inv hnpos.le _ = 8 * cB := by rw [Real.rpow_neg_one] field_simp [hnpos.ne'] have hpow_exp : (1 + chiSqDiv Pp Pm) ^ n ≤ exp ((n : ℝ) * chiSqDiv Pp Pm) := by calc (1 + chiSqDiv Pp Pm) ^ n ≤ (exp (chiSqDiv Pp Pm)) ^ n := by exact pow_le_pow_left₀ (by linarith) (by linarith [Real.add_one_le_exp (chiSqDiv Pp Pm)]) n _ = exp ((n : ℝ) * chiSqDiv Pp Pm) := by rw [← Real.exp_nat_mul] have hpow_le_five : (1 + chiSqDiv Pp Pm) ^ n ≤ 5 := by calc (1 + chiSqDiv Pp Pm) ^ n ≤ exp ((n : ℝ) * chiSqDiv Pp Pm) := hpow_exp _ ≤ exp (log 5) := Real.exp_le_exp.mpr (le_of_lt (lt_of_le_of_lt hmul_budget hconst)) _ = 5 := by rw [Real.exp_log (by norm_num : (0 : ℝ) < 5)] have hprod_eq : 1 + chiSqDiv Pprod Qprod = (1 + chiSqDiv Pp Pm) ^ n := by dsimp [Pprod, Qprod] exact Causalean.Stat.one_add_chiSqDiv_pi_iid_general Pp Pm hac hint n have hchi_prod_four : chiSqDiv Pprod Qprod ≤ 4 := by have hone_le : 1 + chiSqDiv Pprod Qprod ≤ 5 := by rw [hprod_eq] exact hpow_le_five linarith have hchi_prod : chiSqDiv Pprod Qprod ≤ C := by exact hchi_prod_four.trans ((by norm_num : (4 : ℝ) ≤ 5).trans (le_max_right (8 * cB) 5)) exact ⟨by simpa [Pprod, Qprod, Pp, Pm] using hac_prod, by simpa [Pprod, Qprod, Pp, Pm] using hint_prod, by simpa [Pp, Pm] using hchi_one, by simpa [Pprod, Qprod, Pp, Pm] using hchi_prod⟩
CausalSmith.Stat.PolicyRegretMarginOverlap.two_point_divergence · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2102
theorem restricted_volume_real_Icc_zero Lemma restricted_volume_real_Icc_zero in the paper ↗

Lebesgue mass of [0,a] under Lebesgue measure restricted to [0,1].

Formal statement
a :
ha0 :
0 ≤ a
ha1 :
a ≤ 1
(volume.restrict (Icc (0 : ℝ) 1)).real (Icc (0 : ℝ) a) = a
Proof (Lean source)
lemma restricted_volume_real_Icc_zero {a : ℝ} (ha0 : 0 ≤ a) (ha1 : a ≤ 1) : (volume.restrict (Icc (0 : ℝ) 1)).real (Icc (0 : ℝ) a) = a := by rw [measureReal_def, Measure.restrict_apply measurableSet_Icc] have hinter : Icc (0 : ℝ) a ∩ Icc (0 : ℝ) 1 = Icc (0 : ℝ) a := by ext x constructor · intro hx exact hx.1 · intro hx exact ⟨hx, ⟨hx.1, le_trans hx.2 ha1⟩⟩ rw [hinter] have hvol : volume.real (Icc (0 : ℝ) a) = a := by simpa using (Real.volume_real_Icc_of_le ha0 : volume.real (Icc (0 : ℝ) a) = a - 0) simpa [measureReal_def] using hvol
CausalSmith.Stat.PolicyRegretMarginOverlap.restricted_volume_real_Icc_zero · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2253
theorem regret_separation Lemma 3 in the paper ↗

lem:regret-separation. The witness optimal labels are opposite on B_n, forcing regret separation ≥ c h_n^{1+α} for every policy.

Formal statement
α γ u0 cB Cm Co co underlineP :
policySet :
Set (Policy ℝ)
hwin :
hcB :
0 < cB
:
0 ≤ α
:
0 ≤ γ
hCm :
0 < Cm
hCo :
0 < Co
hco :
0 < co
hcBm :
cB ≤ Cm
hcBo :
cB ≤ Co
hup :
0 < underlineP
note c_B overlap-decay smallness (def:two-point-witness constant choice)
hcB_gpos :
0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))
hcB_gzero :
0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))
huple :
underlineP ≤ 1 / 4
hπmeas :
∀ π ∈ policySet, Measurable π
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
∀ π ∈ policySet,
max (lawRegret (twoPointWitness α γ u0 cB n 1) π) (lawRegret (twoPointWitness α γ u0 cB n (-1)) π)
≥ c * (hLower α γ n) ^ (1 + α)
Proof (Lean source)
lemma regret_separation (α γ u0 cB Cm Co co underlineP : ℝ) (policySet : Set (Policy ℝ)) (hwin : MarginWindow u0) (hcB : 0 < cB) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hCm : 0 < Cm) (hCo : 0 < Co) (hco : 0 < co) (hcBm : cB ≤ Cm) (hcBo : cB ≤ Co) (hup : 0 < underlineP) -- note c_B overlap-decay smallness (def:two-point-witness constant choice) (hcB_gpos : 0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))) (hcB_gzero : 0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))) (huple : underlineP ≤ 1 / 4) (hπmeas : ∀ π ∈ policySet, Measurable π) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, ∀ π ∈ policySet, max (lawRegret (twoPointWitness α γ u0 cB n 1) π) (lawRegret (twoPointWitness α γ u0 cB n (-1)) π) ≥ c * (hLower α γ n) ^ (1 + α) := by classical let csep : ℝ := min cB 1 / 4 have hcmin_pos : 0 < min cB 1 := lt_min hcB zero_lt_one have hcsep_pos : 0 < csep := by dsimp [csep] positivity refine ⟨csep, hcsep_pos, ?_⟩ have hmemP : ∀ᶠ n : ℕ in atTop, LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n 1) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)) := witness_membership α γ u0 cB Cm Co co underlineP policySet 1 hα hγ hwin hCm hCo hco hcB hcBm hcBo hup hcB_gpos hcB_gzero huple (inl rfl) have hmemM : ∀ᶠ n : ℕ in atTop, LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n (-1)) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)) := witness_membership α γ u0 cB Cm Co co underlineP policySet (-1) hα hγ hwin hCm hCo hco hcB hcBm hcBo hup hcB_gpos hcB_gzero huple (inr rfl) filter_upwards [hmemP, hmemM, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hwitP hwitM hn1 intro π hπ let hp : ℝ := hLower α γ n let ell : ℝ := min cB 1 * hp ^ α let E : Set ℝ := Icc (0 : ℝ) ell let Pp : ObservedLaw ℝ := twoPointWitness α γ u0 cB n 1 let Pm : ObservedLaw ℝ := twoPointWitness α γ u0 cB n (-1) have hnposNat : 0 < n := lt_of_lt_of_le (by norm_num) hn1 have hp_pos : 0 < hp := by simpa [hp] using hLower_pos_of_pos_nat α γ hnposNat have hp_le_one : hp ≤ 1 := by simpa [hp] using hLower_le_one_of_one_le_nat α γ hα hγ hn1 have hp_pow_nonneg : 0 ≤ hp ^ α := Real.rpow_nonneg hp_pos.le α have hp_pow_le_one : hp ^ α ≤ 1 := Real.rpow_le_one hp_pos.le hp_le_one hα have hmin_nonneg : 0 ≤ min cB 1 := le_of_lt hcmin_pos have hmin_le_cB : min cB 1 ≤ cB := min_le_left _ _ have hmin_le_one : min cB 1 ≤ (1 : ℝ) := min_le_right _ _ have hell_nonneg : 0 ≤ ell := by dsimp [ell] exact mul_nonneg hmin_nonneg hp_pow_nonneg have hell_le_one : ell ≤ 1 := by dsimp [ell] calc min cB 1 * hp ^ α ≤ 1 * 1 := mul_le_mul hmin_le_one hp_pow_le_one hp_pow_nonneg zero_le_one _ = 1 := by norm_num have hEreal : Pp.PX.real E = ell := by have hbase := restricted_volume_real_Icc_zero (a := ell) hell_nonneg hell_le_one simpa [Pp, twoPointWitness, E] using hbase rcases hwitP with ⟨hclassP, hoptp, _⟩ rcases hwitM with ⟨hclassM, _, hoptm⟩ have hwfpP : WellFormedLaw Pp := by simpa [Pp] using hclassP.wf have hbddp : BoundedOutcome Pp := by simpa [Pp] using hclassP.bdd letI : IsProbabilityMeasure Pp.PX := hwfpP.2.1 let Dp : Set ℝ := disagreementSet π (lawOptimalPolicy Pp) let Dm : Set ℝ := disagreementSet π (lawOptimalPolicy Pm) let Bp : Set ℝ := Dp ∩ {x | hp / 2 < |Pp.contrast x|} let Bm : Set ℝ := Dm ∩ {x | hp / 2 < |Pm.contrast x|} have hhalf_pos : 0 < hp / 2 := by positivity have hregp_le := regret_disagreement_large_contrast_le Pp π hwfpP hbddp (hπmeas π hπ) hhalf_pos have hwfmP : WellFormedLaw Pm := by simpa [Pm] using hclassM.wf have hbddm : BoundedOutcome Pm := by simpa [Pm] using hclassM.bdd have hregm_le := regret_disagreement_large_contrast_le Pm π hwfmP hbddm (hπmeas π hπ) hhalf_pos have hRplus : (hp / 2) * Pp.PX.real Bp ≤ lawRegret Pp π := by have hmul := mul_le_mul_of_nonneg_left hregp_le hhalf_pos.le have hcalc : (hp / 2) * (lawRegret Pp π / (hp / 2)) = lawRegret Pp π := by field_simp [hhalf_pos.ne'] simpa [Bp, Dp, hcalc] using hmul have hRminus : (hp / 2) * Pm.PX.real Bm ≤ lawRegret Pm π := by have hmul := mul_le_mul_of_nonneg_left hregm_le hhalf_pos.le have hcalc : (hp / 2) * (lawRegret Pm π / (hp / 2)) = lawRegret Pm π := by field_simp [hhalf_pos.ne'] simpa [Bm, Dm, hcalc] using hmul have hEsubset : E ⊆ Bp ∪ Bm := by intro x hxE have hx0 : 0 ≤ x := hxE.1 have hxell : x ≤ ell := hxE.2 have hxblock : 0 ≤ x ∧ x ≤ cB * hp ^ α := by refine ⟨hx0, ?_⟩ calc x ≤ ell := hxell _ = min cB 1 * hp ^ α := rfl _ ≤ cB * hp ^ α := mul_le_mul_of_nonneg_right hmin_le_cB hp_pow_nonneg have hcp : Pp.contrast x = hp := by simp [Pp, twoPointWitness, hp, hxblock] have hcm : Pm.contrast x = -hp := by simp [Pm, twoPointWitness, hp, hxblock] have hbigp : hp / 2 < |Pp.contrast x| := by rw [hcp, abs_of_pos hp_pos] linarith have hbigm : hp / 2 < |Pm.contrast x| := by rw [hcm, abs_neg, abs_of_pos hp_pos] linarith have hoptp_true : lawOptimalPolicy Pp x = true := by simpa [Pp] using hoptp x have hoptm_false : lawOptimalPolicy Pm x = false := by cases hopt : lawOptimalPolicy Pm x · rfl · have hnotblock : ¬ (0 ≤ x ∧ x ≤ cB * hp ^ α) := by have := (hoptm x).mp hopt simpa [Pm, hp] using this exact elim (hnotblock hxblock) by_cases hπtrue : π x = true · right refine ⟨?_, hbigm⟩ simp [Dm, disagreementSet, hπtrue, hoptm_false] · left have hπfalse : π x = false := by cases hπx : π x · rfl · exact elim (hπtrue hπx) refine ⟨?_, hbigp⟩ simp [Dp, disagreementSet, hπfalse, hoptp_true] have hmeasure_union : Pp.PX.real E ≤ Pp.PX.real Bp + Pp.PX.real Bm := by calc Pp.PX.real E ≤ Pp.PX.real (Bp ∪ Bm) := measureReal_mono (μ := Pp.PX) hEsubset (measure_ne_top Pp.PX (Bp ∪ Bm)) _ ≤ Pp.PX.real Bp + Pp.PX.real Bm := measureReal_union_le Bp Bm have hmeasure : ell ≤ Pp.PX.real Bp + Pm.PX.real Bm := by have hsame : Pp.PX = Pm.PX := by simp [Pp, Pm, twoPointWitness] calc ell = Pp.PX.real E := hEreal.symm _ ≤ Pp.PX.real Bp + Pp.PX.real Bm := hmeasure_union _ = Pp.PX.real Bp + Pm.PX.real Bm := by rw [← hsame] have hsumR : (hp / 2) * ell ≤ lawRegret Pp π + lawRegret Pm π := by have hmul_measure : (hp / 2) * ell ≤ (hp / 2) * (Pp.PX.real Bp + Pm.PX.real Bm) := mul_le_mul_of_nonneg_left hmeasure hhalf_pos.le have hparts : (hp / 2) * (Pp.PX.real Bp + Pm.PX.real Bm) ≤ lawRegret Pp π + lawRegret Pm π := by nlinarith [hRplus, hRminus] exact hmul_measure.trans hparts have hpow_add : hp ^ (1 + α) = hp * hp ^ α := by rw [Real.rpow_add hp_pos, Real.rpow_one] have hsumR' : (min cB 1 / 2) * hp ^ (1 + α) ≤ lawRegret Pp π + lawRegret Pm π := by calc (min cB 1 / 2) * hp ^ (1 + α) = (hp / 2) * ell := by rw [hpow_add] ring _ ≤ lawRegret Pp π + lawRegret Pm π := hsumR have hmaxsum : lawRegret Pp π + lawRegret Pm π ≤ 2 * max (lawRegret Pp π) (lawRegret Pm π) := by nlinarith [le_max_left (lawRegret Pp π) (lawRegret Pm π), le_max_right (lawRegret Pp π) (lawRegret Pm π)] have htarget : csep * hp ^ (1 + α) ≤ max (lawRegret Pp π) (lawRegret Pm π) := by dsimp [csep] nlinarith [hsumR', hmaxsum] simpa [Pp, Pm, hp] using htarget
CausalSmith.Stat.PolicyRegretMarginOverlap.regret_separation · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2271
theorem lawRegret_nonneg_of_wellformed

Welfare regret is nonnegative under the welfare-identity hypotheses.

Formal statement
𝒳 :
Type*
P :
π :
Policy 𝒳
hwf :
hbdd :
:
0 ≤ lawRegret P π
Proof (Lean source)
lemma lawRegret_nonneg_of_wellformed {𝒳 : Type*} [MeasurableSpace 𝒳] (P : ObservedLaw 𝒳) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hπ : Measurable π) : 0 ≤ lawRegret P π := by have hreg := regret_eq_disagreement_integral P π hwf hbdd hπ rw [hreg] exact integral_nonneg (fun x => mul_nonneg (abs_nonneg _) (by unfold disagreementIndicator split <;> norm_num))
CausalSmith.Stat.PolicyRegretMarginOverlap.lawRegret_nonneg_of_wellformed · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2448
theorem lawRegret_le_two_of_wellformed

Under bounded outcomes, any measurable deterministic policy has regret at most 2.

Formal statement
𝒳 :
Type*
P :
π :
Policy 𝒳
hwf :
hbdd :
:
lawRegret P π ≤ 2
Proof (Lean source)
lemma lawRegret_le_two_of_wellformed {𝒳 : Type*} [MeasurableSpace 𝒳] (P : ObservedLaw 𝒳) (π : Policy 𝒳) (hwf : WellFormedLaw P) (hbdd : BoundedOutcome P) (hπ : Measurable π) : lawRegret P π ≤ 2 := by rcases hwf with ⟨hprobData, hprobPX, hmap, hτmeas, hemeas, hmu0meas, hmu1meas, hτeq, herange, heSem, hmu1Sem, hmu0Sem⟩ letI : IsProbabilityMeasure P.PX := hprobPX have hτ_bound : ∀ x, |P.contrast x| ≤ (2 : ℝ) := by intro x rw [hτeq x] have hmu0 : |P.mu0 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).1.1, (hbdd.2 x).1.2⟩ have hmu1 : |P.mu1 x| ≤ (1 : ℝ) := abs_le.mpr ⟨(hbdd.2 x).2.1, (hbdd.2 x).2.2⟩ calc |P.mu1 x - P.mu0 x| ≤ |P.mu1 x| + |P.mu0 x| := abs_sub _ _ _ ≤ 1 + 1 := add_le_add hmu1 hmu0 _ = (2 : ℝ) := by norm_num let f : 𝒳 → ℝ := fun x => |P.contrast x| * disagreementIndicator π (lawOptimalPolicy P) x have hDmeas : MeasurableSet (disagreementSet π (lawOptimalPolicy P)) := measurableSet_disagreementSet P π hτmeas hπ have hf_meas : Measurable f := by have hτabs : Measurable (fun x => |P.contrast x|) := by simpa [Real.norm_eq_abs] using hτmeas.norm dsimp [f] apply hτabs.mul unfold disagreementIndicator exact Measurable.ite hDmeas measurable_const measurable_const have hf_int : Integrable f P.PX := by refine Integrable.of_bound hf_meas.aestronglyMeasurable 2 ?_ filter_upwards with x have hind : |disagreementIndicator π (lawOptimalPolicy P) x| ≤ (1 : ℝ) := by unfold disagreementIndicator split <;> simp calc |f x| = |P.contrast x| * |disagreementIndicator π (lawOptimalPolicy P) x| := by simp [f, abs_mul] _ ≤ 2 * 1 := by gcongr exact hτ_bound x _ = (2 : ℝ) := by norm_num have hreg := regret_eq_disagreement_integral P π ⟨hprobData, hprobPX, hmap, hτmeas, hemeas, hmu0meas, hmu1meas, hτeq, herange, heSem, hmu1Sem, hmu0Sem⟩ hbdd hπ rw [hreg] change ∫ x, f x ∂P.PX ≤ 2 calc ∫ x, f x ∂P.PX ≤ ∫ _x, (2 : ℝ) ∂P.PX := by refine integral_mono hf_int (integrable_const (2 : ℝ)) ?_ intro x calc f x = |P.contrast x| * disagreementIndicator π (lawOptimalPolicy P) x := rfl _ ≤ 2 * 1 := by have hind_nonneg : 0 ≤ disagreementIndicator π (lawOptimalPolicy P) x := by unfold disagreementIndicator split <;> norm_num have hind_le : disagreementIndicator π (lawOptimalPolicy P) x ≤ (1 : ℝ) := by unfold disagreementIndicator split <;> norm_num exact mul_le_mul (hτ_bound x) hind_le hind_nonneg (by norm_num : 0 ≤ (2 : ℝ)) _ = 2 := by norm_num _ = 2 := by simp
CausalSmith.Stat.PolicyRegretMarginOverlap.lawRegret_le_two_of_wellformed · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2461
theorem minimax_lower Theorem 3 in the paper ↗

thm:minimax-lower (CRUX). The sharp constructive converse over the baseline observed-law class: M_n ≥ c n^{-r_⋆(α,γ)} for all large n.

Formal statement
α γ u0 cB Cm Co co underlineP :
policySet :
Set (Policy ℝ)
hwin :
:
0 ≤ α
:
0 ≤ γ
hCm :
0 < Cm
hCo :
0 < Co
hco :
0 < co
hcB :
0 < cB
hcBm :
cB ≤ Cm
hcBo :
cB ≤ Co
hup :
0 < underlineP
note c_B overlap-decay smallness (def:two-point-witness constant choice)
hcB_gpos :
0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))
hcB_gzero :
0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))
huple :
underlineP ≤ 1 / 4
hsmall :
8 * cB < log 5
hπnonempty :
policySet.Nonempty
hπmeas :
∀ π ∈ policySet, Measurable π
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
minimaxRegret {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} policySet n
≥ c * (n : ℝ) ^ (-(rStar α γ))
Proof (Lean source)
theorem minimax_lower (α γ u0 cB Cm Co co underlineP : ℝ) (policySet : Set (Policy ℝ)) (hwin : MarginWindow u0) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hCm : 0 < Cm) (hCo : 0 < Co) (hco : 0 < co) (hcB : 0 < cB) (hcBm : cB ≤ Cm) (hcBo : cB ≤ Co) (hup : 0 < underlineP) -- note c_B overlap-decay smallness (def:two-point-witness constant choice) (hcB_gpos : 0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))) (hcB_gzero : 0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))) (huple : underlineP ≤ 1 / 4) (hsmall : 8 * cB < log 5) (hπnonempty : policySet.Nonempty) (hπmeas : ∀ π ∈ policySet, Measurable π) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, minimaxRegret {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} policySet n ≥ c * (n : ℝ) ^ (-(rStar α γ)) := by classical rcases regret_separation α γ u0 cB Cm Co co underlineP policySet hwin hcB hα hγ hCm hCo hco hcBm hcBo hup hcB_gpos hcB_gzero huple hπmeas with ⟨csep, hcsep, hsep_eventual⟩ rcases two_point_divergence α γ u0 cB hwin hcB hα hγ hsmall with ⟨Cchi, hCchi, hdiv_eventual⟩ rcases (Causalean.Stat.le_cam_two_point_chisq.1 Cchi hCchi.le) with ⟨ctest, hctest, htest_floor⟩ let c : ℝ := csep * ctest / 2 refine ⟨c, by positivity, ?_⟩ have hmemP : ∀ᶠ n : ℕ in atTop, LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n 1) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)) := witness_membership α γ u0 cB Cm Co co underlineP policySet 1 hα hγ hwin hCm hCo hco hcB hcBm hcBo hup hcB_gpos hcB_gzero huple (inl rfl) have hmemM : ∀ᶠ n : ℕ in atTop, LawClass α γ Cm u0 Co co underlineP policySet (twoPointWitness α γ u0 cB n (-1)) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n 1) x = true) ∧ (∀ x : ℝ, lawOptimalPolicy (twoPointWitness α γ u0 cB n (-1)) x = true ↔ ¬ (0 ≤ x ∧ x ≤ cB * (hLower α γ n) ^ α)) := witness_membership α γ u0 cB Cm Co co underlineP policySet (-1) hα hγ hwin hCm hCo hco hcB hcBm hcBo hup hcB_gpos hcB_gzero huple (inr rfl) filter_upwards [hsep_eventual, hdiv_eventual, hmemP, hmemM, Filter.eventually_atTop.mpr ⟨1, fun n hn => hn⟩] with n hsep_n hdiv_n hwitP hwitM hn1 rcases hwitP with ⟨hclassP0, _hoptP, _hoptM_P⟩ rcases hwitM with ⟨hclassM0, _hoptP_M, _hoptM⟩ rcases hdiv_n with ⟨hac_prod0, hint_prod0, _hchi_one, hchi_prod0⟩ let Pp : ObservedLaw ℝ := twoPointWitness α γ u0 cB n 1 let Pm : ObservedLaw ℝ := twoPointWitness α γ u0 cB n (-1) have hclassP : LawClass α γ Cm u0 Co co underlineP policySet Pp := by simpa [Pp] using hclassP0 have hclassM : LawClass α γ Cm u0 Co co underlineP policySet Pm := by simpa [Pm] using hclassM0 letI : IsProbabilityMeasure Pp.dataMeasure := hclassP.wf.1 letI : IsProbabilityMeasure Pm.dataMeasure := hclassM.wf.1 let Sample : Type := Fin n → Observation ℝ let Pprod : Measure Sample := Measure.pi fun _ : Fin n => Pp.dataMeasure let Qprod : Measure Sample := Measure.pi fun _ : Fin n => Pm.dataMeasure have hac_prod : Pprod ≪ Qprod := by simpa [Pprod, Qprod, Pp, Pm] using hac_prod0 have hint_prod : Integrable (fun x => ((Pprod.rnDeriv Qprod x).toReal - 1) ^ 2) Qprod := by simpa [Pprod, Qprod, Pp, Pm] using hint_prod0 have hchi_prod : chiSqDiv Pprod Qprod ≤ Cchi := by simpa [Pprod, Qprod, Pp, Pm] using hchi_prod0 have hnposNat : 0 < n := Nat.lt_of_lt_of_le Nat.zero_lt_one hn1 have hnpos : 0 < (n : ℝ) := by exact_mod_cast hnposNat have hrate_eq : (hLower α γ n) ^ (1 + α) = (n : ℝ) ^ (-(rStar α γ)) := by have hDpos : 0 < Dag α γ := Dag_pos_of_nonneg α γ hα hγ unfold hLower rStar rw [← Real.rpow_mul (le_of_lt hnpos)] congr 1 field_simp [ne_of_gt hDpos] change c * (n : ℝ) ^ (-(rStar α γ)) ≤ minimaxRegret {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} policySet n rcases hπnonempty with ⟨π0, hπ0⟩ let est0 : (Fin n → Observation ℝ) → Policy ℝ := fun _ => π0 letI : Nonempty {est : (Fin n → Observation ℝ) → Policy ℝ // (∀ sample, est sample ∈ policySet) ∧ ∀ P : ObservedLaw ℝ, Measurable (fun sample : Fin n → Observation ℝ => lawRegret P (est sample))} := ⟨⟨est0, ⟨fun _ => hπ0, fun P => by simpa [est0] using (measurable_const : Measurable (fun _ : Fin n → Observation ℝ => lawRegret P π0))⟩⟩⟩ rw [minimaxRegret] refine le_ciInf ?_ intro est let Rp : ℝ := ∫ sample, lawRegret Pp (est.1 sample) ∂Pprod let Rm : ℝ := ∫ sample, lawRegret Pm (est.1 sample) ∂Qprod let sep : ℝ := csep * (hLower α γ n) ^ (1 + α) let fP : Sample → ℝ := fun sample => lawRegret Pp (est.1 sample) let fM : Sample → ℝ := fun sample => lawRegret Pm (est.1 sample) let A : Set Sample := {sample | sep ≤ fM sample} have hsep_pos : 0 < sep := by dsimp [sep] exact mul_pos hcsep (Real.rpow_pos_of_pos (hLower_pos_of_pos_nat α γ hnposNat) _) have hsep_nonneg : 0 ≤ sep := hsep_pos.le have hfP_meas : Measurable fP := by simpa [fP, Pprod, Pp] using est.2.2 Pp have hfM_meas : Measurable fM := by simpa [fM, Qprod, Pm] using est.2.2 Pm have hfP_nonneg : 0 ≤ᵐ[Pprod] fP := by filter_upwards with sample exact lawRegret_nonneg_of_wellformed Pp (est.1 sample) hclassP.wf hclassP.bdd (hπmeas (est.1 sample) (est.2.1 sample)) have hfM_nonneg : 0 ≤ᵐ[Qprod] fM := by filter_upwards with sample exact lawRegret_nonneg_of_wellformed Pm (est.1 sample) hclassM.wf hclassM.bdd (hπmeas (est.1 sample) (est.2.1 sample)) have hfP_int : Integrable fP Pprod := by refine Integrable.of_bound hfP_meas.aestronglyMeasurable 2 ?_ filter_upwards with sample have hnon := lawRegret_nonneg_of_wellformed Pp (est.1 sample) hclassP.wf hclassP.bdd (hπmeas (est.1 sample) (est.2.1 sample)) have hle := lawRegret_le_two_of_wellformed Pp (est.1 sample) hclassP.wf hclassP.bdd (hπmeas (est.1 sample) (est.2.1 sample)) simpa [fP, Real.norm_eq_abs, abs_of_nonneg hnon] using hle have hfM_int : Integrable fM Qprod := by refine Integrable.of_bound hfM_meas.aestronglyMeasurable 2 ?_ filter_upwards with sample have hnon := lawRegret_nonneg_of_wellformed Pm (est.1 sample) hclassM.wf hclassM.bdd (hπmeas (est.1 sample) (est.2.1 sample)) have hle := lawRegret_le_two_of_wellformed Pm (est.1 sample) hclassM.wf hclassM.bdd (hπmeas (est.1 sample) (est.2.1 sample)) simpa [fM, Real.norm_eq_abs, abs_of_nonneg hnon] using hle have hAmeas : MeasurableSet A := by dsimp [A] exact measurableSet_le measurable_const hfM_meas have htest : ctest ≤ Pprod.real Aᶜ + Qprod.real A := by exact htest_floor Pprod Qprod hac_prod hint_prod hchi_prod A hAmeas have hP_mark : sep * Pprod.real {sample | sep ≤ fP sample} ≤ Rp := by simpa [Rp, fP] using (mul_meas_ge_le_integral_of_nonneg (μ := Pprod) hfP_nonneg hfP_int sep) have hM_mark : sep * Qprod.real A ≤ Rm := by simpa [Rm, fM, A] using (mul_meas_ge_le_integral_of_nonneg (μ := Qprod) hfM_nonneg hfM_int sep) have hcomp_subset : Aᶜ ⊆ {sample | sep ≤ fP sample} := by intro sample hsample have hm_not : ¬ sep ≤ fM sample := by simpa [A] using hsample have hm_lt : fM sample < sep := lt_of_not_ge hm_not have hsep_sample : sep ≤ max (fP sample) (fM sample) := by simpa [sep, fP, fM, Pp, Pm] using hsep_n (est.1 sample) (est.2.1 sample) by_contra hp_not have hp_lt : fP sample < sep := lt_of_not_ge hp_not have hmax_lt : max (fP sample) (fM sample) < sep := max_lt hp_lt hm_lt exact not_lt_of_ge hsep_sample hmax_lt have hcomp_measure : Pprod.real Aᶜ ≤ Pprod.real {sample | sep ≤ fP sample} := measureReal_mono (μ := Pprod) hcomp_subset (measure_ne_top Pprod {sample | sep ≤ fP sample}) have hP_event : sep * Pprod.real Aᶜ ≤ Rp := (mul_le_mul_of_nonneg_left hcomp_measure hsep_nonneg).trans hP_mark have hsum_event : sep * (Pprod.real Aᶜ + Qprod.real A) ≤ Rp + Rm := by nlinarith [hP_event, hM_mark] have hsum_lower : sep * ctest ≤ Rp + Rm := by have hmul := mul_le_mul_of_nonneg_left htest hsep_nonneg exact hmul.trans hsum_event have hmax_lower : sep * ctest / 2 ≤ max Rp Rm := by have hsum_max : Rp + Rm ≤ 2 * max Rp Rm := by nlinarith [le_max_left Rp Rm, le_max_right Rp Rm] nlinarith [hsum_lower, hsum_max] have htarget_eq : c * (n : ℝ) ^ (-(rStar α γ)) = sep * ctest / 2 := by dsimp [c, sep] rw [← hrate_eq] ring let F : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} → ℝ := fun P => ∫ sample, lawRegret P.1 (est.1 sample) ∂(Measure.pi fun _ : Fin n => P.1.dataMeasure) letI : Nonempty {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} := ⟨⟨Pp, hclassP⟩⟩ have hF_bdd : BddAbove (range F) := by refine ⟨2, ?_⟩ rintro y ⟨Psub, rfl⟩ letI : IsProbabilityMeasure Psub.1.dataMeasure := Psub.2.wf.1 let f : (Fin n → Observation ℝ) → ℝ := fun sample => lawRegret Psub.1 (est.1 sample) have hf_meas : Measurable f := by simpa [f] using est.2.2 Psub.1 have hf_int : Integrable f (Measure.pi fun _ : Fin n => Psub.1.dataMeasure) := by refine Integrable.of_bound hf_meas.aestronglyMeasurable 2 ?_ filter_upwards with sample have hnon := lawRegret_nonneg_of_wellformed Psub.1 (est.1 sample) Psub.2.wf Psub.2.bdd (hπmeas (est.1 sample) (est.2.1 sample)) have hle := lawRegret_le_two_of_wellformed Psub.1 (est.1 sample) Psub.2.wf Psub.2.bdd (hπmeas (est.1 sample) (est.2.1 sample)) simpa [f, Real.norm_eq_abs, abs_of_nonneg hnon] using hle calc F Psub = ∫ sample, f sample ∂(Measure.pi fun _ : Fin n => Psub.1.dataMeasure) := by rfl _ ≤ ∫ _sample, (2 : ℝ) ∂(Measure.pi fun _ : Fin n => Psub.1.dataMeasure) := by refine integral_mono hf_int (integrable_const (2 : ℝ)) ?_ intro sample exact lawRegret_le_two_of_wellformed Psub.1 (est.1 sample) Psub.2.wf Psub.2.bdd (hπmeas (est.1 sample) (est.2.1 sample)) _ = 2 := by simp have hp_sup : Rp ≤ (⨆ P : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P}, ∫ sample, lawRegret P.1 (est.1 sample) ∂(Measure.pi fun _ : Fin n => P.1.dataMeasure)) := by simpa [Rp, Pprod, Pp] using (le_ciSup hF_bdd (⟨Pp, hclassP⟩ : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P})) have hm_sup : Rm ≤ (⨆ P : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P}, ∫ sample, lawRegret P.1 (est.1 sample) ∂(Measure.pi fun _ : Fin n => P.1.dataMeasure)) := by simpa [Rm, Qprod, Pm] using (le_ciSup hF_bdd (⟨Pm, hclassM⟩ : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P})) have hmax_sup : max Rp Rm ≤ (⨆ P : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P}, ∫ sample, lawRegret P.1 (est.1 sample) ∂(Measure.pi fun _ : Fin n => P.1.dataMeasure)) := max_le hp_sup hm_sup calc c * (n : ℝ) ^ (-(rStar α γ)) = sep * ctest / 2 := htarget_eq _ ≤ max Rp Rm := hmax_lower _ ≤ (⨆ P : {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P}, -- … truncated; follow the source link for the rest …
CausalSmith.Stat.PolicyRegretMarginOverlap.minimax_lower · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2529
theorem rate_characterization

thm:rate-characterization (HEADLINE, lower-bound only). M_n ≥ c n^{-(1+α)/(2+α+β_{α,γ})}.

Formal statement
α γ u0 cB Cm Co co underlineP :
policySet :
Set (Policy ℝ)
hwin :
:
0 ≤ α
:
0 ≤ γ
hCm :
0 < Cm
hCo :
0 < Co
hco :
0 < co
hcB :
0 < cB
hcBm :
cB ≤ Cm
hcBo :
cB ≤ Co
hup :
0 < underlineP
note c_B overlap-decay smallness (def:two-point-witness constant choice)
hcB_gpos :
0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))
hcB_gzero :
0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))
huple :
underlineP ≤ 1 / 4
hsmall :
8 * cB < log 5
hπnonempty :
policySet.Nonempty
hπmeas :
∀ π ∈ policySet, Measurable π
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
minimaxRegret {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} policySet n
≥ c * (n : ℝ) ^ (-((1 + α) / (2 + α + betaAG α γ)))
Proof (Lean source)
theorem rate_characterization (α γ u0 cB Cm Co co underlineP : ℝ) (policySet : Set (Policy ℝ)) (hwin : MarginWindow u0) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hCm : 0 < Cm) (hCo : 0 < Co) (hco : 0 < co) (hcB : 0 < cB) (hcBm : cB ≤ Cm) (hcBo : cB ≤ Co) (hup : 0 < underlineP) -- note c_B overlap-decay smallness (def:two-point-witness constant choice) (hcB_gpos : 0 < γ → 0 < α → cB ≤ Co * co ^ (-(α / γ))) (hcB_gzero : 0 < γ → α = 0 → cB ≤ Co * (4 : ℝ) ^ (-(1 / γ))) (huple : underlineP ≤ 1 / 4) (hsmall : 8 * cB < log 5) (hπnonempty : policySet.Nonempty) (hπmeas : ∀ π ∈ policySet, Measurable π) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, minimaxRegret {P : ObservedLaw ℝ | LawClass α γ Cm u0 Co co underlineP policySet P} policySet n ≥ c * (n : ℝ) ^ (-((1 + α) / (2 + α + betaAG α γ))) := by simpa [rStar, Dag] using minimax_lower α γ u0 cB Cm Co co underlineP policySet hwin hα hγ hCm hCo hco hcB hcBm hcBo hup hcB_gpos hcB_gzero huple hsmall hπnonempty hπmeas
CausalSmith.Stat.PolicyRegretMarginOverlap.rate_characterization · CausalSmith/Stat/STAT_PolicyRegretMarginOverlap_Research/T_minimax_lower.lean:2783