Formalization: A Minimax Lower Bound for Interior Dose-Response Estimation

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 28 declarations Environment S1 — i.i.d. observational continuous-dose sampling world

Environment S1 — i.i.d. observational continuous-dose sampling world

structure DoseObs

Observed unit O = (Y, A, X) with outcome Y ∈ ℝ, continuous treatment A ∈ [0,1], and covariate vector X ∈ [0,1]^d. The carrier fields are typed over / Fin d → ℝ (the witness measure constructions require -valued ranges), and the declared treatment range [0,1] and covariate cube [0,1]^d are pinned as a STANDING a.s. support clause on the law by the two IidSampling support conjuncts (A ∈ [0,1] and X ∈ [0,1]^d almost surely under P), which every law in HolderDoseClass carries via HolderDoseClass.iid. Y is unconstrained (). @realizes O

Definition (Lean source)
d :
Y :
A :
X :
Fin d → ℝ
CausalSmith.Stat.DoseResponseMinimax.DoseObs · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:50
instance instMeasurableSpaceDoseObs

The observed-data type is made measurable by identifying each observation with its outcome, treatment, and covariate tuple.

Definition (Lean source)
instance instMeasurableSpaceDoseObs {d : ℕ} : MeasurableSpace (DoseObs d) := comap (fun O : DoseObs d => (O.Y, O.A, O.X)) inferInstance
CausalSmith.Stat.DoseResponseMinimax.instMeasurableSpaceDoseObs · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:63
def cube

The covariate cube [0,1]^d.

Definition (Lean source)
def cube (d : ℕ) : Set (Fin d → ℝ) := {x | ∀ i, x i ∈ Icc (0 : ℝ) 1}
CausalSmith.Stat.DoseResponseMinimax.cube · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:68
def doseWindow

The interior treatment window [t_0 - ε_0, t_0 + ε_0].

Definition (Lean source)
def doseWindow (t0 eps0 : ℝ) : Set ℝ := Icc (t0 - eps0) (t0 + eps0)
CausalSmith.Stat.DoseResponseMinimax.doseWindow · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:71
def HolderBall1D

Univariate Hölder ball of order order and radius M on a set S ⊆ ℝ: all derivatives up to the largest integer k = ⌈order⌉ - 1 strictly below order exist continuously on S, are bounded by M, and the k-th derivative is (order - k)-Hölder with constant M. This is the standard nonparametric C^{⌈order⌉-1, order-⌈order⌉+1} convention, including integer orders.

Definition (Lean source)
def HolderBall1D (f : ℝ → ℝ) (order M : ℝ) (S : Set ℝ) : Prop := ContDiffOn ℝ (⌈order⌉₊ - 1) f S ∧ (∀ j : ℕ, j ≤ ⌈order⌉₊ - 1 → ∀ x ∈ S, |iteratedDeriv j f x| ≤ M) ∧ (∀ x ∈ S, ∀ y ∈ S, |iteratedDeriv (⌈order⌉₊ - 1) f x - iteratedDeriv (⌈order⌉₊ - 1) f y| ≤ M * |x - y| ^ (order - ((⌈order⌉₊ - 1 : ℕ) : ℝ)))
CausalSmith.Stat.DoseResponseMinimax.HolderBall1D · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:74
def HolderBallND

Multivariate Hölder ball of order order and radius M on a set S ⊆ (Fin d → ℝ): all iterated Fréchet derivatives up to the largest integer k = ⌈order⌉ - 1 strictly below order exist continuously on S, are bounded by M in operator norm, and the k-th derivative is (order - k)-Hölder with constant M. Notation for the library ball Causalean.Stat.Nonparametric.HolderBallStd (same ⌈order⌉-1 convention).

Definition (Lean source)
abbrev HolderBallND {d : ℕ} (f : (Fin d → ℝ) → ℝ) (order M : ℝ) (S : Set (Fin d → ℝ)) : Prop := HolderBallStd f order M S
CausalSmith.Stat.DoseResponseMinimax.HolderBallND · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:86
structure DoseLaw

Build-inline observed-law object: the per-draw observation law, the covariate marginal, the law-side nuisances μ_P, π_P, p_{X,P}, and the potential-outcome process Y(·) (the causal overlay S2).

Definition (Lean source)
d :
dataMeasure :
PX :
Measure (Fin d → ℝ)
mu :
ℝ → (Fin d → ℝ) → ℝ
pi :
ℝ → (Fin d → ℝ) → ℝ
px :
(Fin d → ℝ) → ℝ
pot :
ℝ → DoseObs d → ℝ
CausalSmith.Stat.DoseResponseMinimax.DoseLaw · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:96

O_1, …, O_n are i.i.d. draws from P. Carries the full i.i.d. content by reusing Causalean.Stat.IIDSample (mutually independent, identically distributed measurable maps with law P.dataMeasure), together with IsProbabilityMeasure P.dataMeasure certifying that the per-draw law — hence the n-fold product Measure.pi (fun _ : Fin n => P.dataMeasure) formed in minimaxRisk — is a probability measure. Also pins the observed-unit support O = (Y,A,X) to the sampling space {(Y,A,X): Y∈ℝ, A∈[0,1], X∈[0,1]^d}: under P the treatment A ∈ [0,1] and the covariate vector X ∈ [0,1]^d almost surely. @realizes O(the IidSampling conjunction pins the observed-unit law a.s. to {(Y,A,X): Y∈ℝ, A∈[0,1], X∈[0,1]^d} through its A-support and X-support conjuncts)

Definition (Lean source)
def IidSampling {d : ℕ} (P : DoseLaw d) : Prop := IsProbabilityMeasure P.dataMeasure ∧ (∀ᵐ O ∂P.dataMeasure, O.A ∈ Icc (0 : ℝ) 1) ∧ -- @realizes A(a.s. treatment-coordinate support A ∈ [0,1] under P, enforcing the declared treatment range [0,1]) (∀ᵐ O ∂P.dataMeasure, O.X ∈ cube d) ∧ -- @realizes X(a.s. covariate-coordinate support X ∈ [0,1]^d under P, enforcing the declared covariate range [0,1]^d) -- @realizes O_1, ..., O_n(i.i.d. n-sample: mutually independent, identically `P.dataMeasure`-distributed measurable draws via `IIDSample` — THIS `IidSampling` i.i.d. realizer is one of the two load-bearing realizers of the sample symbol `O_1,…,O_n` (the other is the `minimaxRisk` `Measure.pi` product law). It is NOT realized by the FOLLOWING `Consistency` declaration; the tag is placed BEFORE the existential so it attaches to `IidSampling`, not to the next decl. Each draw is a.s. in `{A∈[0,1], X∈[0,1]^d}`, and the n-fold product `Measure.pi (fun _ : Fin n => P.dataMeasure)` formed in `minimaxRisk` is their joint law.) ∃ (Ω : Type) (_mΩ : MeasurableSpace Ω) (μ : @Measure Ω _mΩ), Nonempty (@IIDSample Ω (DoseObs d) _mΩ instMeasurableSpaceDoseObs μ P.dataMeasure)
CausalSmith.Stat.DoseResponseMinimax.IidSampling · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:110

Consistency Y = Y(A) almost surely under P: the realized outcome equals the potential outcome at the realized treatment level.

Definition (Lean source)
def Consistency {d : ℕ} (P : DoseLaw d) : Prop := ∀ᵐ O ∂P.dataMeasure, O.Y = P.pot O.A O
CausalSmith.Stat.DoseResponseMinimax.Consistency · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:131
def NoUnmeasuredConfounding Assumption 11 in the paper ↗

Conditional ignorability for the continuous treatment: for every level a ∈ [0,1], the potential outcome Y(a) is independent of A given X under P (the note restricts the dose to the treatment range [0,1]). Encoded in the faithful tested form E[f(Y(a)) ∣ A, X] = E[f(Y(a)) ∣ X] for every bounded measurable test f of the potential outcome (the standard conditional-independence characterization, no StandardBorelSpace requirement).

Definition (Lean source)
def NoUnmeasuredConfounding {d : ℕ} (P : DoseLaw d) : Prop := ∀ a ∈ Icc (0 : ℝ) 1, Measurable (P.pot a) ∧ ∀ (f : ℝ → ℝ), Measurable f → (∃ Mf : ℝ, ∀ y, |f y| ≤ Mf) → Integrable (fun O => f (P.pot a O)) P.dataMeasure ∧ P.dataMeasure[(fun O => f (P.pot a O)) | comap (fun O : DoseObs d => (O.A, O.X)) inferInstance] =ᵐ[P.dataMeasure] P.dataMeasure[(fun O => f (P.pot a O)) | comap (fun O : DoseObs d => O.X) inferInstance]
CausalSmith.Stat.DoseResponseMinimax.NoUnmeasuredConfounding · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:137

Bounded outcome |Y| ≤ M almost surely under P.

Definition (Lean source)
def BoundedOutcome {d : ℕ} (P : DoseLaw d) (M : ℝ) : Prop := ∀ᵐ O ∂P.dataMeasure, |O.Y| ≤ M
CausalSmith.Stat.DoseResponseMinimax.BoundedOutcome · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:155

Interior evaluation point: [t_0 - ε_0, t_0 + ε_0] ⊆ (0,1).

Definition (Lean source)
def InteriorDose (t0 eps0 : ℝ) : Prop := doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1
CausalSmith.Stat.DoseResponseMinimax.InteriorDose · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:160

Local positivity: π_P(a∣x) ≥ c_0 for every a in the ε_0-window and every x ∈ [0,1]^d.

Definition (Lean source)
def LocalPositivity {d : ℕ} (P : DoseLaw d) (c0 t0 eps0 : ℝ) : Prop := ∀ a ∈ doseWindow t0 eps0, ∀ x ∈ cube d, c0 ≤ P.pi a x
CausalSmith.Stat.DoseResponseMinimax.LocalPositivity · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:165
def MuTreatmentHolder Assumption 5 in the paper ↗

Treatment-direction smoothness: for every x ∈ [0,1]^d, the slice a ↦ μ_P(a,x) lies in a Hölder ball of order α, radius M, on the window.

Definition (Lean source)
def MuTreatmentHolder {d : ℕ} (P : DoseLaw d) (alpha M t0 eps0 : ℝ) : Prop := ∀ x ∈ cube d, HolderBall1D (fun a => P.mu a x) alpha M (doseWindow t0 eps0)
CausalSmith.Stat.DoseResponseMinimax.MuTreatmentHolder · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:171
def PiTreatmentHolder Assumption 6 in the paper ↗

Treatment-direction smoothness of the conditional treatment density: for every x ∈ [0,1]^d, a ↦ π_P(a∣x) lies in a Hölder ball of order β, radius M, on the window.

Definition (Lean source)
def PiTreatmentHolder {d : ℕ} (P : DoseLaw d) (beta M t0 eps0 : ℝ) : Prop := ∀ x ∈ cube d, HolderBall1D (fun a => P.pi a x) beta M (doseWindow t0 eps0)
CausalSmith.Stat.DoseResponseMinimax.PiTreatmentHolder · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:177
def MuCovariateHolder Assumption 7 in the paper ↗

Covariate-direction smoothness: x ↦ μ_P(t_0,x) lies in a Hölder ball of order s, radius M, on [0,1]^d.

Definition (Lean source)
def MuCovariateHolder {d : ℕ} (P : DoseLaw d) (s M t0 : ℝ) : Prop := HolderBallND (fun x => P.mu t0 x) s M (cube d)
CausalSmith.Stat.DoseResponseMinimax.MuCovariateHolder · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:184
def PiCovariateHolder Assumption 8 in the paper ↗

Covariate-direction smoothness of the conditional treatment density: x ↦ π_P(t_0∣x) lies in a Hölder ball of order s, radius M, on [0,1]^d.

Definition (Lean source)
def PiCovariateHolder {d : ℕ} (P : DoseLaw d) (s M t0 : ℝ) : Prop := HolderBallND (fun x => P.pi t0 x) s M (cube d)
CausalSmith.Stat.DoseResponseMinimax.PiCovariateHolder · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:190

Covariate-density smoothness and range: p_{X,P} lies in a Hölder ball of order s, radius M, on [0,1]^d, is NONNEGATIVE (0 ≤ p_{X,P} on the cube — the declared density range [0,∞)), and is bounded above by M. The nonnegativity conjunct makes p_{X,P} a genuine density object: with it ENNReal.ofReal (P.px x) = P.px x on the cube, so the PxIsXDensity tie realizes the ACTUAL p_{X,P} density rather than only its ofReal positive part.

Definition (Lean source)
def PxHolder {d : ℕ} (P : DoseLaw d) (s M : ℝ) : Prop := HolderBallND P.px s M (cube d) ∧ (∀ x ∈ cube d, 0 ≤ P.px x) ∧ -- @realizes p_{X,P}(0 ≤ p_{X,P} on cube; enforces the declared density range [0,∞), so the `ofReal` `PxIsXDensity` tie realizes the actual nonnegative density object) (∀ x ∈ cube d, P.px x ≤ M)
CausalSmith.Stat.DoseResponseMinimax.PxHolder · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:196
def BaselineSubmodelSlack Assumption 12 in the paper ↗

Nonempty-interior-of-model (strict-slack baseline) existence hypothesis: there exist a covariate density p_0 on [0,1]^d, a conditional treatment density q_0 on [0,1], a slack η_0 > 0, and an outcome scale B_0 ∈ (0,M), such that p_0 and q_0 have Hölder norms at most M - η_0 in the classes required of p_{X,P} and π_P, q_0(a) ≥ c_0 + η_0 on the ε_0-window, p_0 ≤ M - η_0, and the constant-zero outcome regression admits a symmetric two-point channel on {-B_0, B_0} ⊆ [-M,M]. Provisional D0.R refinement (user_approved = false).

Definition (Lean source)
def BaselineSubmodelSlack (d : ℕ) (beta s M c0 eps0 t0 : ℝ) : Prop := ∃ (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (eta0 B0 : ℝ), 0 < eta0 ∧ 0 < B0 ∧ B0 < M ∧ (∀ x ∈ cube d, 0 ≤ p0 x) ∧ (∀ a, 0 ≤ q0 a) ∧ (∫ x in cube d, p0 x) = 1 ∧ (∫ a in Icc (0 : ℝ) 1, q0 a) = 1 ∧ HolderBallND p0 s (M - eta0) (cube d) ∧ (∀ x ∈ cube d, p0 x ≤ M - eta0) ∧ HolderBall1D q0 beta (M - eta0) (doseWindow t0 eps0) ∧ (∀ a ∈ doseWindow t0 eps0, c0 + eta0 ≤ q0 a)
CausalSmith.Stat.DoseResponseMinimax.BaselineSubmodelSlack · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:208

Semantic tie (μ is the data regression). The conditional mean of Y given (A,X) under the data law equals μ_P(A,X). This pins the free mu field to the actual law, so thetaFunctional = ∫ μ_P(t_0,·)·p_{X,P} is the GENUINE causal value E_P[Y(t_0)] (under consistency + ignorability). Without it mu is disconnected from dataMeasure, which permits a vacuous two-point construction (a Dirac data law with the separation carried only by the free mu); enforcing it makes minimaxRisk the true causal minimax risk.

Definition (Lean source)
def MuIsRegression {d : ℕ} (P : DoseLaw d) : Prop := P.dataMeasure[(fun O => O.Y) | comap (fun O : DoseObs d => (O.A, O.X)) inferInstance] =ᵐ[P.dataMeasure] (fun O => P.mu O.A O.X)
CausalSmith.Stat.DoseResponseMinimax.MuIsRegression · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:225

Semantic tie (p_{X,P} is the X-marginal density). The pushforward of the data law under X is p_{X,P}·(Lebesgue ↾ [0,1]^d), tying the free px field to the actual covariate law so thetaFunctional integrates μ against the genuine P_X.

Definition (Lean source)
def PxIsXDensity {d : ℕ} (P : DoseLaw d) : Prop := P.dataMeasure.map (fun O => O.X) = (volume.restrict (cube d)).withDensity (fun x => ofReal (P.px x))
CausalSmith.Stat.DoseResponseMinimax.PxIsXDensity · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:238

Semantic tie / range-normalization (π_P is the conditional treatment density). The pushforward of the data law under (A,X) equals the measure with joint density (a,x) ↦ π_P(a∣x)·p_{X,P}(x) w.r.t. Lebesgue on [0,1]×[0,1]^d. Together with PxIsXDensity (the X-marginal is p_{X,P}·Leb) this pins π_P(·∣x) to be the GENUINE conditional density of A given X = x under P — it is normalized (∫_{[0,1]} π_P(a∣x) da = 1 for P_X-a.e. x, forced by consistency of the joint with its X-marginal) and tied to dataMeasure. Without it the pi field is disconnected from dataMeasure, so the class P_{α,β,s} would be strictly BROADER than the paper class (an arbitrary π field satisfying only the Hölder/positivity atoms, never required to be the law's actual treatment density). The core symbol pi_P(a∣x) is defined as the conditional density of A given X = x under P, so this tie is exactly the note's stated meaning of π_P, not an added restriction. The leading conjunct ENFORCES the declared density range 0 ≤ π_P on [0,1]×[0,1]^d: with it ENNReal.ofReal (π_P·p_{X,P}) genuinely equals π_P·p_{X,P} (both factors nonnegative, using PxHolder's 0 ≤ p_{X,P}), so the tie realizes the ACTUAL nonnegative conditional treatment density object, not only its ofReal positive part. @realizes pi_P(0 ≤ π_P on [0,1]×cube enforcing the declared range [0,∞), AND P.dataMeasure.map (A,X) = (Leb↾[0,1] ⊗ Leb↾[0,1]^d).withDensity (π_P·p_{X,P}); together the range-clause + joint-factorization tie pin pi to the law's genuine nonnegative conditional treatment density)

Definition (Lean source)
def PiIsCondTreatmentDensity {d : ℕ} (P : DoseLaw d) : Prop := (∀ a ∈ Icc (0 : ℝ) 1, ∀ x ∈ cube d, 0 ≤ P.pi a x) ∧ -- @realizes pi_P(0 ≤ pi_P on [0,1]×cube; enforces the declared density range [0,∞), so the `ofReal` joint-density tie realizes the actual nonnegative conditional treatment density) P.dataMeasure.map (fun O => (O.A, O.X)) = ((volume.restrict (Icc (0 : ℝ) 1)).prod (volume.restrict (cube d))).withDensity (fun p => ofReal (P.pi p.1 p.2 * P.px p.2))
CausalSmith.Stat.DoseResponseMinimax.PiIsCondTreatmentDensity · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:246
structure HolderDoseClass

The anisotropic Hölder dose-response model class P_{α,β,s}(M,c_0,ε_0,t_0): the bundle of the member-atom properties, including the three SEMANTIC TIES (μ_P is the data regression, p_{X,P} is the X-marginal density, and π_P is the law's conditional treatment density) that make it a genuine CAUSAL class and pin it to EXACTLY the paper class (so minimaxRisk over it is the true causal minimax risk and thetaFunctional is E_P[Y(t_0)], not a free-field artifact, and the class is not strictly broader than P_{α,β,s} through a free π field). (ass:baseline-submodel-slack is NOT a member; it is a separate theorem hypothesis.) The two regime theorems take (hP : HolderDoseClass … P).

Definition (Lean source)
d :
alpha beta s M c0 eps0 t0 :
P :
iid :
consistency :
Consistency P
ignorability :
bdd :
interior :
InteriorDose t0 eps0
positivity :
LocalPositivity P c0 t0 eps0
muT :
MuTreatmentHolder P alpha M t0 eps0
piT :
PiTreatmentHolder P beta M t0 eps0
muX :
piX :
pxH :
PxHolder P s M
muReg :
pxDens :
CausalSmith.Stat.DoseResponseMinimax.HolderDoseClass · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:270
def RegimeConstants

Standing well-formedness of the S3 regime constants: each lies in its declared space — α, β, s, M, c_0 ∈ (0,∞), t_0 ∈ (0,1), ε_0 ∈ (0,1/2). This is the ENFORCING realization cluster for those setup symbols; it is threaded as a hypothesis into every regime lemma/theorem so the constants are never used outside their declared spaces.

Definition (Lean source)
def RegimeConstants (alpha beta s M c0 eps0 t0 : ℝ) : Prop := 0 < alpha ∧ -- @realizes alpha(0 < alpha; declared space (0,∞), treatment-direction Hölder order) 0 < beta ∧ -- @realizes beta(0 < beta; declared space (0,∞), treatment-density Hölder order) 0 < s ∧ -- @realizes s(0 < s; declared space (0,∞), covariate-direction Hölder order) 0 < M ∧ -- @realizes M(0 < M; declared space (0,∞), common Hölder radius / outcome bound) 0 < c0 ∧ -- @realizes c_0(0 < c0; declared space (0,∞), local-positivity floor) t0 ∈ Ioo (0 : ℝ) 1 ∧ -- @realizes t_0(t0 ∈ (0,1); declared interior evaluation-point space) eps0 ∈ Ioo (0 : ℝ) (1 / 2) ∧ -- @realizes epsilon_0(eps0 ∈ (0,1/2); declared interior-radius half-width space) InteriorDose t0 eps0 -- @realizes evaluation window(`[t_0-ε_0,t_0+ε_0] ⊆ (0,1)`)
CausalSmith.Stat.DoseResponseMinimax.RegimeConstants · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:329

Identifying partial-mean (backdoor-adjustment) functional θ_P(t_0) = ∫_{[0,1]^d} μ_P(t_0,x) p_{X,P}(x) dx (Lebesgue). Under consistency and ignorability this equals the causal dose-response value E_P[Y(t_0)].

Definition (Lean source)
noncomputable def thetaFunctional {d : ℕ} (P : DoseLaw d) (t0 : ℝ) : ℝ := ∫ x in cube d, P.mu t0 x * P.px x
CausalSmith.Stat.DoseResponseMinimax.thetaFunctional · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:347

Pointwise minimax mean-squared risk R_n(C, t_0) = inf_{θ̂_n} sup_{P ∈ C} E_P[(θ̂_n - θ_P(t_0))^2]. The infimum ranges over MEASURABLE estimators truncated to [-M,M] (the bounded-estimand range: truncating to the interval containing every θ_P(t_0) never increases MSE and yields the SAME minimax value, while keeping the inner squared loss bounded by (2M)^2 under each n-fold probability law — so the / are well-posed, with no junk-0 inflation of the converse).

Definition (Lean source)
noncomputable def minimaxRisk {d : ℕ} (M : ℝ) (n : ℕ) (C : DoseLaw d → Prop) (t0 : ℝ) : ℝ := ⨅ est : {est : (Fin n → DoseObs d) → ℝ // Measurable est ∧ ∀ s, est s ∈ Icc (-M) M}, -- @realizes O_1, ..., O_n(estimator domain is the size-`n` sample `Fin n → DoseObs d`) ⨆ P : {P : DoseLaw d // C P}, -- @realizes O_1, ..., O_n(the i.i.d. `n`-sample as the `n`-fold PRODUCT LAW `Measure.pi (fun _ : Fin n => P.dataMeasure)` over `Fin n → DoseObs d` — THIS `minimaxRisk` product law is the second of the two load-bearing realizers of the sample symbol (the first is the `IidSampling` i.i.d. realizer); its factors are mutually independent and identically `P.dataMeasure`-distributed exactly by the `IIDSample` conjunct of `IidSampling`. It is NOT realized by the FOLLOWING `publishedHoifRate` declaration; the tag is placed BEFORE the integral so it attaches to `minimaxRisk`, not to the next decl.) ∫ s, (est.1 s - thetaFunctional P.1 t0) ^ 2 ∂(Measure.pi fun _ : Fin n => (P.1).dataMeasure)
CausalSmith.Stat.DoseResponseMinimax.minimaxRisk · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:354
def publishedHoifRate Definition 4 in the paper ↗

Published Bonvini–Kennedy benchmark rate ρ_n = n^{-2α/(2α+1)} ∨ n^{-2/(1 + d/(4s) + 1/α)}. @realizes rho_n

Definition (Lean source)
noncomputable def publishedHoifRate (n : ℕ) (alpha s : ℝ) (d : ℕ) : ℝ := max ((n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))) ((n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))))
CausalSmith.Stat.DoseResponseMinimax.publishedHoifRate · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:372
theorem publishedHoifRate_nonneg

The published-rate frontier sequence is nonnegative, enforcing the declared range ρ_n ∈ [0,∞) of the setup symbol rho_n: each branch (n:ℝ)^(·) is an rpow of the nonnegative base (n:ℝ) ≥ 0, hence ≥ 0, and the max preserves it. @realizes rho_n

Formal statement
n :
alpha s :
d :
0 ≤ publishedHoifRate n alpha s d
Proof (Lean source)
theorem publishedHoifRate_nonneg (n : ℕ) (alpha s : ℝ) (d : ℕ) : 0 ≤ publishedHoifRate n alpha s d := (Real.rpow_nonneg (Nat.cast_nonneg n) _).trans (le_max_left _ _)
CausalSmith.Stat.DoseResponseMinimax.publishedHoifRate_nonneg · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Basic.lean:379
Frontier 1 declarations
def betaFrontierHandle Remark 1 in the paper ↗

Headline frontier handle. For EVERY β > 0, records the DELIVERED all-β oracle lower floor R_n ≥ c n^{-2α/(2α+1)} on the corresponding original class, together with the regime-by-regime ρ_n comparison for every n ≥ 1. The deficient comparison is restricted to the note's regime 0 < s < d/4. The final disjunction records, without selecting or certifying an upper endpoint, the unresolved upper-frontier alternatives: attainability of ρ_n, an intermediate exponent, or genuinely β-sensitive rates.

Definition (Lean source)
def betaFrontierHandle {d : ℕ} (alpha s M c0 eps0 t0 : ℝ) : Prop := ∀ beta : ℝ, 0 < beta → (∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0) ∧ (∀ n : ℕ, 1 ≤ n → (d : ℝ) ≤ 4 * s → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))) ∧ (∀ n : ℕ, 1 ≤ n → 0 < s ∧ 4 * s < (d : ℝ) → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1)) ∧ ((∃ C : ℝ, 0 < C ∧ ∀ᶠ n : ℕ in atTop, minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ≤ C * publishedHoifRate n alpha s d) ∨ (∃ kappa C : ℝ, 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < kappa ∧ kappa < 2 * alpha / (2 * alpha + 1) ∧ 0 < C ∧ ∀ᶠ n : ℕ in atTop, minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ≤ C * (n : ℝ) ^ (-kappa)) ∨ (∃ beta' kappa kappa' c C c' C' : ℝ, 0 < beta' ∧ beta' ≠ beta ∧ kappa' ≠ kappa ∧ 0 < c ∧ 0 < C ∧ 0 < c' ∧ 0 < C' ∧ (∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-kappa) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ∧ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ≤ C * (n : ℝ) ^ (-kappa)) ∧ (∀ᶠ n : ℕ in atTop, c' * (n : ℝ) ^ (-kappa') ≤ minimaxRisk M n (HolderDoseClass d alpha beta' s M c0 eps0 t0) t0 ∧ minimaxRisk M n (HolderDoseClass d alpha beta' s M c0 eps0 t0) t0 ≤ C' * (n : ℝ) ^ (-kappa'))))
CausalSmith.Stat.DoseResponseMinimax.betaFrontierHandle · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Frontier.lean:19
Helpers.Divergence 2 declarations
theorem bernoulli_mean_channel_kl_source Lemma 1 in the paper ↗

The signed two-point mean channel has quadratic KL divergence on the central half of its mean range. This local wrapper links the paper lemma to the reusable Causalean implementation.

Formal statement
B u v :
hB :
0 < B
hu :
|u| ≤ B / 2
hv :
|v| ≤ B / 2
ofReal (2 * (u - v) ^ 2 / B ^ 2)
Proof (Lean source)
lemma bernoulli_mean_channel_kl_source (B u v : ℝ) (hB : 0 < B) (hu : |u| ≤ B / 2) (hv : |v| ≤ B / 2) : klDiv (twoPointMean B u) (twoPointMean B v) ≤ ofReal (2 * (u - v) ^ 2 / B ^ 2) := by calc klDiv (twoPointMean B u) (twoPointMean B v) ≤ ofReal ((u - v) ^ 2 / B ^ 2) := bernoulli_mean_channel_kl B u v hB hu hv _ ≤ ofReal (2 * (u - v) ^ 2 / B ^ 2) := by apply ENNReal.ofReal_le_ofReal rw [mul_div_assoc] nlinarith [div_nonneg (sq_nonneg (u - v)) (sq_nonneg B)]
CausalSmith.Stat.DoseResponseMinimax.bernoulli_mean_channel_kl_source · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Divergence.lean:42
theorem le_cam_two_point_mse_source Lemma 2 in the paper ↗

Le Cam's two-point reduction: a finite KL budget gives a positive, budget-dependent constant multiplying the squared parameter separation.

Formal statement
K :
∃ cK : ℝ,
0 < cK ∧
∀ {S : Type*} [MeasurableSpace S] (Q0 Q1 : Measure S) [IsProbabilityMeasure Q0] [IsProbabilityMeasure Q1] (theta0 theta1 : ℝ),
klDiv Q0 Q1
≤ ENNReal.ofReal K → ∀ T : S → ℝ, Measurable T → Integrable (fun s => (T s - theta0) ^ 2) Q0 → Integrable (fun s => (T s - theta1) ^ 2) Q1 → cK * (theta1 - theta0) ^ 2 ≤ max (∫ s, (T s - theta0) ^ 2 ∂Q0) (∫ s, (T s - theta1) ^ 2 ∂Q1)
Proof (Lean source)
lemma le_cam_two_point_mse_source (K : ℝ) : ∃ cK : ℝ, 0 < cK ∧ ∀ {S : Type*} [MeasurableSpace S] (Q0 Q1 : Measure S) [IsProbabilityMeasure Q0] [IsProbabilityMeasure Q1] (theta0 theta1 : ℝ), InformationTheory.klDiv Q0 Q1 ≤ ENNReal.ofReal K → ∀ T : S → ℝ, Measurable T → Integrable (fun s => (T s - theta0) ^ 2) Q0 → Integrable (fun s => (T s - theta1) ^ 2) Q1 → cK * (theta1 - theta0) ^ 2 ≤ max (∫ s, (T s - theta0) ^ 2 ∂Q0) (∫ s, (T s - theta1) ^ 2 ∂Q1) := by exact le_cam_two_point_mse K
CausalSmith.Stat.DoseResponseMinimax.le_cam_two_point_mse_source · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Divergence.lean:59
Helpers.FrontierBracket 1 declarations
theorem certified_beta_frontier_bracket

Certified β-frontier bracket. Assume the strict-slack baseline. For every β > 0 there is c > 0 with R_n ≥ c n^{-2α/(2α+1)} eventually; and — for EVERY n ≥ 1, not merely eventually, matching the note's unconditional ρ_n algebra — in the smooth-covariate regime s ≥ d/4 (d ≤ 4s) the benchmark ρ_n collapses to that oracle exponent, while in the deficient regime 0 < s < d/4 (4s < d) ρ_n has a strictly smaller exponent. The regime identities are stated outside the ∀ᶠ n (eventually) clause so they are NOT weakened to large n only. No same-class upper endpoint is packaged.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ c : ℝ,
0 < c ∧
(∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0) ∧
(∀ n : ℕ, 1 ≤ n → ((d : ℝ) ≤ 4 * s → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))) ∧ (4 * s < (d : ℝ) → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1)))
Proof (Lean source)
lemma certified_beta_frontier_bracket {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ c : ℝ, 0 < c ∧ (∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0) ∧ (∀ n : ℕ, 1 ≤ n → ((d : ℝ) ≤ 4 * s → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))) ∧ (4 * s < (d : ℝ) → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1))) := by rcases sharp_pointwise_lower_bound alpha beta s M c0 eps0 t0 halpha hbeta hs hreg hslack with ⟨c, hc, hfloor⟩ refine ⟨c, hc, hfloor, ?_⟩ intro n hge refine ⟨?_, ?_⟩ · intro hsd exact rho_oracle_regime_algebra n alpha s d halpha hs hsd hge · intro hsd exact rho_deficient_regime_algebra n alpha s d halpha hs hsd hge
CausalSmith.Stat.DoseResponseMinimax.certified_beta_frontier_bracket · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/FrontierBracket.lean:20
Helpers.RateAlgebra 2 declarations
theorem rho_oracle_regime_algebra Lemma 3 in the paper ↗

Smooth-covariate collapse: if 0 < α, 0 < s, and d ≤ 4 s (i.e. s ≥ d/4), then ρ_n = n^{-2α/(2α+1)} for every n ≥ 1.

Formal statement
n :
alpha s :
d :
halpha :
0 < alpha
hs :
0 < s
hsd :
(d : ℝ) ≤ 4 * s
hn :
1 ≤ n
publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))
Proof (Lean source)
lemma rho_oracle_regime_algebra (n : ℕ) (alpha s : ℝ) (d : ℕ) (halpha : 0 < alpha) (hs : 0 < s) (hsd : (d : ℝ) ≤ 4 * s) (hn : 1 ≤ n) : publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) := by by_cases hn1 : n = 1 · subst n simp [publishedHoifRate] · have hnat : 1 < n := by omega have hbase : (1 : ℝ) < (n : ℝ) := by exact_mod_cast hnat have hs4 : 0 < 4 * s := by positivity have hdfrac : (d : ℝ) / (4 * s) ≤ 1 := by rw [div_le_one hs4] simpa using hsd have hden_pos : 0 < 1 + (d : ℝ) / (4 * s) + 1 / alpha := by positivity have hden_le : 1 + (d : ℝ) / (4 * s) + 1 / alpha ≤ 2 + 1 / alpha := by linarith have hfrac : 2 / (2 + 1 / alpha) ≤ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) := by exact div_le_div_of_nonneg_left (by norm_num : (0 : ℝ) ≤ 2) hden_pos hden_le have hid : 2 / (2 + 1 / alpha) = 2 * alpha / (2 * alpha + 1) := by field_simp [halpha.ne'] have hexp : 2 * alpha / (2 * alpha + 1) ≤ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) := by rwa [← hid] have hpow : (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ≤ (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) := by rw [Real.rpow_le_rpow_left_iff hbase] linarith rw [publishedHoifRate] exact max_eq_left hpow
CausalSmith.Stat.DoseResponseMinimax.rho_oracle_regime_algebra · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/RateAlgebra.lean:19
theorem rho_deficient_regime_algebra Lemma 4 in the paper ↗

Deficient-covariate collapse: if 0 < α, 0 < s, and 4 s < d (i.e. 0 < s < d/4), then ρ_n = n^{-2/(1 + d/(4s) + 1/α)} for every n ≥ 1, and the deficient exponent is strictly smaller than the oracle exponent.

Formal statement
n :
alpha s :
d :
halpha :
0 < alpha
hs :
0 < s
hsd :
4 * s < (d : ℝ)
hn :
1 ≤ n
publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧
2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1)
Proof (Lean source)
lemma rho_deficient_regime_algebra (n : ℕ) (alpha s : ℝ) (d : ℕ) (halpha : 0 < alpha) (hs : 0 < s) (hsd : 4 * s < (d : ℝ)) (hn : 1 ≤ n) : publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1) := by have hs4 : 0 < 4 * s := by positivity have hone_lt : 1 < (d : ℝ) / (4 * s) := by rw [one_lt_div hs4] simpa using hsd have hden_pos : 0 < 2 + 1 / alpha := by positivity have hden_lt : 2 + 1 / alpha < 1 + (d : ℝ) / (4 * s) + 1 / alpha := by linarith have hfrac : 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 / (2 + 1 / alpha) := by exact div_lt_div_of_pos_left (by norm_num : (0 : ℝ) < 2) hden_pos hden_lt have hid : 2 / (2 + 1 / alpha) = 2 * alpha / (2 * alpha + 1) := by field_simp [halpha.ne'] have hexp : 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1) := by rwa [hid] at hfrac constructor · by_cases hn1 : n = 1 · subst n simp [publishedHoifRate] · have hnat : 1 < n := by omega have hbase : (1 : ℝ) < (n : ℝ) := by exact_mod_cast hnat have hpow : (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) := by rw [Real.rpow_le_rpow_left_iff hbase] linarith rw [publishedHoifRate] exact max_eq_right hpow · exact hexp
CausalSmith.Stat.DoseResponseMinimax.rho_deficient_regime_algebra · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/RateAlgebra.lean:52
Helpers.TwoPointConstruction 3 declarations
theorem thetaFunctional_abs_le

Uniform bound on the identifying functional over the model class: |θ_P(t_0)| ≤ M · M · vol([0,1]^d). Used for BddAbove of the worst-case risk.

Formal statement
P :
alpha beta s M c0 eps0 t0 :
hM :
0 ≤ M
heps :
0 ≤ eps0
hP :
HolderDoseClass d alpha beta s M c0 eps0 t0 P
|thetaFunctional P t0| ≤ M * M * (volume.real (cube d))
Proof (Lean source)
lemma thetaFunctional_abs_le {P : DoseLaw d} {alpha beta s M c0 eps0 t0 : ℝ} (hM : 0 ≤ M) (heps : 0 ≤ eps0) (hP : HolderDoseClass d alpha beta s M c0 eps0 t0 P) : |thetaFunctional P t0| ≤ M * M * (volume.real (cube d)) := by rw [thetaFunctional] have hbound : ∀ x ∈ cube d, ‖P.mu t0 x * P.px x‖ ≤ M * M := by intro x hx have ht0win : t0 ∈ doseWindow t0 eps0 := center_mem_doseWindow heps have hmu : |P.mu t0 x| ≤ M := by have h := (hP.muT x hx).2.1 0 (zero_le _) t0 ht0win simpa using h have hpx : |P.px x| ≤ M := by have h := hP.pxH.1.2.1 0 (zero_le _) x hx simpa [Real.norm_eq_abs] using h rw [Real.norm_eq_abs, abs_mul] exact mul_le_mul hmu hpx (abs_nonneg _) hM simpa [Real.norm_eq_abs, mul_assoc] using (norm_setIntegral_le_of_norm_le_const (μ := volume) (s := cube d) (f := fun x => P.mu t0 x * P.px x) (C := M * M) (volume_cube_lt_top d) hbound)
CausalSmith.Stat.DoseResponseMinimax.thetaFunctional_abs_le · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/TwoPointConstruction.lean:34
theorem minimaxRisk_two_point_lower

The two-point Le Cam reduction in minimax form: two class members with bounded KL between their n-fold product laws force the pointwise minimax risk to be at least c_K times their squared target separation.

Formal statement
alpha beta s M c0 eps0 t0 :
hM :
0 < M
heps :
0 ≤ eps0
n :
P0 P1 :
h0 :
HolderDoseClass d alpha beta s M c0 eps0 t0 P0
h1 :
HolderDoseClass d alpha beta s M c0 eps0 t0 P1
K cK :
hcK :
0 < cK
hbody :
∀ {S : Type*} [MeasurableSpace S] (Q0 Q1 : Measure S) [IsProbabilityMeasure Q0] [IsProbabilityMeasure Q1] (theta0 theta1 : ℝ),
klDiv Q0 Q1
≤ ENNReal.ofReal K → ∀ T : S → ℝ, Measurable T → Integrable (fun s => (T s - theta0) ^ 2) Q0 → Integrable (fun s => (T s - theta1) ^ 2) Q1 → cK * (theta1 - theta0) ^ 2 ≤ max (∫ s, (T s - theta0) ^ 2 ∂Q0) (∫ s, (T s - theta1) ^ 2 ∂Q1)
hKL :
klDiv (Measure.pi fun _ : Fin n => P0.dataMeasure) (Measure.pi fun _ : Fin n => P1.dataMeasure)
≤ ENNReal.ofReal K
cK * (thetaFunctional P1 t0 - thetaFunctional P0 t0) ^ 2
minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0
Proof (Lean source)
lemma minimaxRisk_two_point_lower {alpha beta s M c0 eps0 t0 : ℝ} (hM : 0 < M) (heps : 0 ≤ eps0) (n : ℕ) (P0 P1 : DoseLaw d) (h0 : HolderDoseClass d alpha beta s M c0 eps0 t0 P0) (h1 : HolderDoseClass d alpha beta s M c0 eps0 t0 P1) (K cK : ℝ) (hcK : 0 < cK) (hbody : ∀ {S : Type*} [MeasurableSpace S] (Q0 Q1 : Measure S) [IsProbabilityMeasure Q0] [IsProbabilityMeasure Q1] (theta0 theta1 : ℝ), InformationTheory.klDiv Q0 Q1 ≤ ENNReal.ofReal K → ∀ T : S → ℝ, Measurable T → Integrable (fun s => (T s - theta0) ^ 2) Q0 → Integrable (fun s => (T s - theta1) ^ 2) Q1 → cK * (theta1 - theta0) ^ 2 ≤ max (∫ s, (T s - theta0) ^ 2 ∂Q0) (∫ s, (T s - theta1) ^ 2 ∂Q1)) (hKL : InformationTheory.klDiv (Measure.pi fun _ : Fin n => P0.dataMeasure) (Measure.pi fun _ : Fin n => P1.dataMeasure) ≤ ENNReal.ofReal K) : cK * (thetaFunctional P1 t0 - thetaFunctional P0 t0) ^ 2 ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 := by have _ : 0 < cK := hcK let C : DoseLaw d → Prop := HolderDoseClass d alpha beta s M c0 eps0 t0 let Est := {est : (Fin n → DoseObs d) → ℝ // Measurable est ∧ ∀ s, est s ∈ Icc (-M) M} have hMnonneg : 0 ≤ M := hM.le letI : Nonempty Est := ⟨⟨fun _ => 0, measurable_const, fun _ => by exact ⟨by linarith, by linarith⟩⟩⟩ rw [minimaxRisk] change cK * (thetaFunctional P1 t0 - thetaFunctional P0 t0) ^ 2 ≤ ⨅ est : Est, ⨆ P : {P : DoseLaw d // C P}, ∫ s, (est.1 s - thetaFunctional P.1 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P.1.dataMeasure) refine le_ciInf ?_ intro est let T : (Fin n → DoseObs d) → ℝ := est.1 have hT : Measurable T := est.2.1 have hTbd : ∀ s, T s ∈ Icc (-M) M := est.2.2 let θ0 : ℝ := thetaFunctional P0 t0 let θ1 : ℝ := thetaFunctional P1 t0 let Q0 : Measure (Fin n → DoseObs d) := Measure.pi fun _ : Fin n => P0.dataMeasure let Q1 : Measure (Fin n → DoseObs d) := Measure.pi fun _ : Fin n => P1.dataMeasure have hprob0 : IsProbabilityMeasure P0.dataMeasure := h0.iid.1 have hprob1 : IsProbabilityMeasure P1.dataMeasure := h1.iid.1 letI : IsProbabilityMeasure P0.dataMeasure := hprob0 letI : IsProbabilityMeasure P1.dataMeasure := hprob1 letI : IsProbabilityMeasure Q0 := by dsimp [Q0]; infer_instance letI : IsProbabilityMeasure Q1 := by dsimp [Q1]; infer_instance have hInt0 : Integrable (fun s => (T s - θ0) ^ 2) Q0 := by exact Causalean.Stat.mse_integrable_of_estimator_bound Q0 T hT hMnonneg hTbd have hInt1 : Integrable (fun s => (T s - θ1) ^ 2) Q1 := by exact Causalean.Stat.mse_integrable_of_estimator_bound Q1 T hT hMnonneg hTbd have hLC : cK * (θ1 - θ0) ^ 2 ≤ max (∫ s, (T s - θ0) ^ 2 ∂Q0) (∫ s, (T s - θ1) ^ 2 ∂Q1) := by have hKLQ : InformationTheory.klDiv Q0 Q1 ≤ ENNReal.ofReal K := by simpa [Q0, Q1] using hKL let e : (Fin n → DoseObs d) ≃ᵐ ULift (Fin n → DoseObs d) := (MeasurableEquiv.ulift).symm let Q0u : Measure (ULift (Fin n → DoseObs d)) := Measure.map e Q0 let Q1u : Measure (ULift (Fin n → DoseObs d)) := Measure.map e Q1 let Tu : ULift (Fin n → DoseObs d) → ℝ := fun s => T s.down letI : IsProbabilityMeasure Q0u := by dsimp [Q0u] exact Measure.isProbabilityMeasure_map e.measurable.aemeasurable letI : IsProbabilityMeasure Q1u := by dsimp [Q1u] exact Measure.isProbabilityMeasure_map e.measurable.aemeasurable have hKLu : InformationTheory.klDiv Q0u Q1u ≤ ENNReal.ofReal K := by calc InformationTheory.klDiv Q0u Q1u = InformationTheory.klDiv Q0 Q1 := by simpa [Q0u, Q1u, e] using klDiv_map_measurableEquiv e Q0 Q1 _ ≤ ENNReal.ofReal K := hKLQ have hTu : Measurable Tu := by exact hT.comp measurable_down have hTubd : ∀ s, Tu s ∈ Icc (-M) M := fun s => hTbd s.down have hInt0u : Integrable (fun s => (Tu s - θ0) ^ 2) Q0u := by exact Causalean.Stat.mse_integrable_of_estimator_bound Q0u Tu hTu hMnonneg hTubd have hInt1u : Integrable (fun s => (Tu s - θ1) ^ 2) Q1u := by exact Causalean.Stat.mse_integrable_of_estimator_bound Q1u Tu hTu hMnonneg hTubd have hLCu : cK * (θ1 - θ0) ^ 2 ≤ max (∫ s, (Tu s - θ0) ^ 2 ∂Q0u) (∫ s, (Tu s - θ1) ^ 2 ∂Q1u) := by exact hbody Q0u Q1u θ0 θ1 hKLu Tu hTu hInt0u hInt1u have hIntEq0 : (∫ s, (Tu s - θ0) ^ 2 ∂Q0u) = ∫ s, (T s - θ0) ^ 2 ∂Q0 := by exact MeasureTheory.integral_map_equiv e (fun s => (Tu s - θ0) ^ 2) (μ := Q0) have hIntEq1 : (∫ s, (Tu s - θ1) ^ 2 ∂Q1u) = ∫ s, (T s - θ1) ^ 2 ∂Q1 := by exact MeasureTheory.integral_map_equiv e (fun s => (Tu s - θ1) ^ 2) (μ := Q1) simpa [hIntEq0, hIntEq1] using hLCu let A : ℝ := M + M * M * volume.real (cube d) have hA_nonneg : 0 ≤ A := by dsimp [A] positivity have hbdd : BddAbove (range (fun P : {P : DoseLaw d // C P} => ∫ s, (T s - thetaFunctional P.1 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P.1.dataMeasure))) := by refine ⟨A ^ 2, ?_⟩ rintro y ⟨P, rfl⟩ let Q : Measure (Fin n → DoseObs d) := Measure.pi fun _ : Fin n => P.1.dataMeasure let θ : ℝ := thetaFunctional P.1 t0 have hprobP : IsProbabilityMeasure P.1.dataMeasure := P.2.iid.1 letI : IsProbabilityMeasure P.1.dataMeasure := hprobP letI : IsProbabilityMeasure Q := by dsimp [Q]; infer_instance have hInt : Integrable (fun s => (T s - θ) ^ 2) Q := by exact Causalean.Stat.mse_integrable_of_estimator_bound Q T hT hMnonneg hTbd have hConst : Integrable (fun _ : Fin n → DoseObs d => A ^ 2) Q := integrable_const _ have hpoint : (fun s => (T s - θ) ^ 2) ≤ fun _ : Fin n → DoseObs d => A ^ 2 := by intro sample have hTabs : |T sample| ≤ M := abs_le.mpr (hTbd sample) have htheta : |θ| ≤ M * M * volume.real (cube d) := by exact thetaFunctional_abs_le hMnonneg heps P.2 have hdiff : |T sample - θ| ≤ A := by dsimp [A] exact (abs_sub (T sample) θ).trans (add_le_add hTabs htheta) nlinarith [hdiff, abs_nonneg (T sample - θ), hA_nonneg, sq_abs (T sample - θ)] have hle := MeasureTheory.integral_mono hInt hConst hpoint have hconsteq : (∫ _ : Fin n → DoseObs d, A ^ 2 ∂Q) = A ^ 2 := by simp exact hle.trans_eq hconsteq have hsup0 : (∫ s, (T s - thetaFunctional P0 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P0.dataMeasure)) ≤ ⨆ P : {P : DoseLaw d // C P}, ∫ s, (T s - thetaFunctional P.1 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P.1.dataMeasure) := by simpa [C] using le_ciSup hbdd (⟨P0, h0⟩ : {P : DoseLaw d // C P}) have hsup1 : (∫ s, (T s - thetaFunctional P1 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P1.dataMeasure)) ≤ ⨆ P : {P : DoseLaw d // C P}, ∫ s, (T s - thetaFunctional P.1 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P.1.dataMeasure) := by simpa [C] using le_ciSup hbdd (⟨P1, h1⟩ : {P : DoseLaw d // C P}) have hmax : max (∫ s, (T s - θ0) ^ 2 ∂Q0) (∫ s, (T s - θ1) ^ 2 ∂Q1) ≤ ⨆ P : {P : DoseLaw d // C P}, ∫ s, (T s - thetaFunctional P.1 t0) ^ 2 ∂ (Measure.pi fun _ : Fin n => P.1.dataMeasure) := by refine max_le ?_ ?_ · simpa [Q0, θ0, T] using hsup0 · simpa [Q1, θ1, T] using hsup1 exact (by simpa [θ0, θ1] using hLC.trans hmax)
CausalSmith.Stat.DoseResponseMinimax.minimaxRisk_two_point_lower · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/TwoPointConstruction.lean:58
theorem oracle_dose_regression_lower_all_beta Lemma 5 in the paper ↗

The all-β oracle lower floor. Assume the strict-slack baseline. For every β > 0 there is c_or > 0, depending only on the fixed model radii and the slack baseline (not on n), such that for all sufficiently large n, R_n(P_{α,β,s}(M,c_0,ε_0,t_0), t_0) ≥ c_or n^{-2α/(2α+1)}. The construction perturbs only the treatment regression and leaves the treatment density fixed, so the bound is independent of whether β ≥ α.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ cor : ℝ,
0 < cor ∧
∀ᶠ n : ℕ in atTop,
cor * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))
minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0
Proof (Lean source)
lemma oracle_dose_regression_lower_all_beta {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ cor : ℝ, 0 < cor ∧ ∀ᶠ n : ℕ in atTop, cor * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 := by classical have _ : 0 < beta := hbeta have _ : 0 < s := hs rcases hslack with ⟨p0, q0, eta0, B0, heta0, hB0, hB0M, hp0nn, hq0nn, hp0int, hq0int, hp0H, hp0bd, hq0H, hq0pos⟩ have hregC := hreg rcases hreg with ⟨hα, hβ, hsp, hMpos, hc0, ht0, heps, hinterior⟩ let B : ℝ := M / 2 have hBpos : 0 < B := by dsimp [B]; positivity have hBM : B ≤ M := by dsimp [B]; linarith obtain ⟨lambda, hlam_pos, hlam_le4, hMuHolder⟩ := doseBump_holder_gate alpha M t0 eps0 hα hMpos have hlam_leB2 : lambda ≤ B / 2 := by have hB2 : B / 2 = M / 4 := by dsimp [B] ring simpa [hB2] using hlam_le4 have hpX : IsProbabilityMeasure (doseXMeasure (d := d) p0) := doseXMeasure_isProbabilityMeasure (d := d) (p0 := p0) hp0nn hp0int have hpA : IsProbabilityMeasure (doseAMeasure q0) := doseAMeasure_isProbabilityMeasure (q0 := q0) hq0nn hq0int let K : ℝ := 16 * lambda ^ 2 * (M - eta0) / B ^ 2 obtain ⟨cK, hcK, hbody_raw⟩ := Causalean.Stat.Minimax.le_cam_two_point_mse K let hbody : ∀ {S : Type} [MeasurableSpace S] (Q0 Q1 : Measure S) [IsProbabilityMeasure Q0] [IsProbabilityMeasure Q1] (theta0 theta1 : ℝ), InformationTheory.klDiv Q0 Q1 ≤ ENNReal.ofReal K → ∀ T : S → ℝ, Measurable T → Integrable (fun s => (T s - theta0) ^ 2) Q0 → Integrable (fun s => (T s - theta1) ^ 2) Q1 → cK * (theta1 - theta0) ^ 2 ≤ max (∫ s, (T s - theta0) ^ 2 ∂Q0) (∫ s, (T s - theta1) ^ 2 ∂Q1) := hbody_raw refine ⟨4 * cK * lambda ^ 2, ?_, ?_⟩ · positivity have hdenpos : 0 < 2 * alpha + 1 := by nlinarith have hdenne : 2 * alpha + 1 ≠ 0 := ne_of_gt hdenpos have hexp_pos : 0 < 1 / (2 * alpha + 1) := by positivity have hh_tendsto : Tendsto (fun n : ℕ => (n : ℝ) ^ (-(1 / (2 * alpha + 1)))) atTop (𝓝 0) := by exact (tendsto_rpow_neg_atTop hexp_pos).comp tendsto_natCast_atTop_atTop filter_upwards [hh_tendsto.eventually_le_const zero_lt_one, hh_tendsto.eventually_le_const heps.1, Filter.eventually_ge_atTop 1] with n hh1 hheps hn1 let h : ℝ := (n : ℝ) ^ (-(1 / (2 * alpha + 1))) have hhpos : 0 < h := by dsimp [h] have hnpos : 0 < (n : ℝ) := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hn1) exact Real.rpow_pos_of_pos hnpos _ have hhle : h ≤ 1 := by simpa [h] using hh1 have hhe : h ≤ eps0 := by simpa [h] using hheps let P0 : DoseLaw d := doseWitness (d := d) p0 q0 B alpha t0 lambda h (-1) let P1 : DoseLaw d := doseWitness (d := d) p0 q0 B alpha t0 lambda h 1 have hmu_abs_le_B2 : ∀ {zeta : ℝ}, (zeta = -1 ∨ zeta = 1) → ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B / 2 := by intro zeta hzeta a x have hzeta_abs : |zeta| ≤ 1 := by rcases hzeta with rfl | rfl <;> norm_num have hhp_nonneg : 0 ≤ h ^ alpha := Real.rpow_nonneg hhpos.le alpha have hhp_le : h ^ alpha ≤ 1 := Real.rpow_le_one hhpos.le hhle halpha.le have hbump_abs := doseBump_abs_le_one ((a - t0) / h) calc |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| = |zeta| * lambda * h ^ alpha * |doseBump ((a - t0) / h)| := by rw [doseWitnessMu, abs_mul, abs_mul, abs_mul, abs_of_nonneg hlam_pos.le, abs_of_nonneg hhp_nonneg] _ ≤ 1 * lambda * 1 * 1 := by gcongr _ = lambda := by ring _ ≤ B / 2 := hlam_leB2 have hmu_abs_le_B : ∀ {zeta : ℝ}, (zeta = -1 ∨ zeta = 1) → ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B := by intro zeta hzeta a x exact (hmu_abs_le_B2 hzeta a x).trans (by linarith [hBpos]) have hmem0 : HolderDoseClass d alpha beta s M c0 eps0 t0 P0 := by dsimp [P0] exact doseWitness_mem_class (d := d) (p0 := p0) (q0 := q0) (alpha := alpha) (beta := beta) (s := s) (M := M) (c0 := c0) (eps0 := eps0) (t0 := t0) (eta0 := eta0) (B := B) (lambda := lambda) (h := h) (zeta := -1) hregC heta0 hBpos hBM hp0nn hp0int hp0H hp0bd hq0nn hq0int hq0H hq0pos (hmu_abs_le_B (inl rfl)) (hMuHolder (inl rfl) hhpos hhle) (inl rfl) hhpos hhle have hmem1 : HolderDoseClass d alpha beta s M c0 eps0 t0 P1 := by dsimp [P1] exact doseWitness_mem_class (d := d) (p0 := p0) (q0 := q0) (alpha := alpha) (beta := beta) (s := s) (M := M) (c0 := c0) (eps0 := eps0) (t0 := t0) (eta0 := eta0) (B := B) (lambda := lambda) (h := h) (zeta := 1) hregC heta0 hBpos hBM hp0nn hp0int hp0H hp0bd hq0nn hq0int hq0H hq0pos (hmu_abs_le_B (inr rfl)) (hMuHolder (inr rfl) hhpos hhle) (inr rfl) hhpos hhle have hq0bd : ∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0 := by intro a ha have h := hq0H.2.1 0 (zero_le _) a ha exact (le_abs_self (q0 a)).trans (by simpa using h) have hKL0 := doseWitness_kl_nfold_le (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (lambda := lambda) (eta0 := eta0) (t0 := t0) (eps0 := eps0) (h := h) n hBpos halpha hhpos hhle hhe hinterior hpX hpA hp0int hlam_pos.le hlam_leB2 (hmu_abs_le_B2 (inr rfl)) (hmu_abs_le_B2 (inl rfl)) hq0nn hq0bd have hnpos : 0 < (n : ℝ) := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hn1) have hpow_budget : h ^ (2 * alpha + 1) = (n : ℝ)⁻¹ := by dsimp [h] rw [← Real.rpow_mul hnpos.le] have hmul : (-(1 / (2 * alpha + 1))) * (2 * alpha + 1) = -1 := by field_simp [hdenne] rw [hmul, Real.rpow_neg_one] have hn_mul_hpow : (n : ℝ) * h ^ (2 * alpha + 1) = 1 := by rw [hpow_budget] exact mul_inv_cancel₀ (ne_of_gt hnpos) have hbudget_eq : (n : ℝ) * (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1)) = K := by dsimp [K] calc (n : ℝ) * (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1)) = (16 * lambda ^ 2 * (M - eta0) / B ^ 2) * ((n : ℝ) * h ^ (2 * alpha + 1)) := by ring _ = (16 * lambda ^ 2 * (M - eta0) / B ^ 2) * 1 := by rw [hn_mul_hpow] _ = 16 * lambda ^ 2 * (M - eta0) / B ^ 2 := by ring have hKL : InformationTheory.klDiv (Measure.pi fun _ : Fin n => P0.dataMeasure) (Measure.pi fun _ : Fin n => P1.dataMeasure) ≤ ENNReal.ofReal K := by rw [← hbudget_eq] exact hKL0 have hlow := minimaxRisk_two_point_lower (d := d) (alpha := alpha) (beta := beta) (s := s) (M := M) (c0 := c0) (eps0 := eps0) (t0 := t0) hMpos heps.1.le n P0 P1 hmem0 hmem1 K cK hcK hbody hKL have hsep : thetaFunctional P1 t0 - thetaFunctional P0 t0 = 2 * lambda * h ^ alpha := by dsimp [P0, P1] exact doseWitness_theta_sep (d := d) p0 q0 B alpha t0 lambda h hp0int have hrate : h ^ (2 * alpha) = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) := by dsimp [h] rw [← Real.rpow_mul hnpos.le] congr 1 field_simp [hdenne] have hsq_sep : cK * (2 * lambda * h ^ alpha) ^ 2 = (4 * cK * lambda ^ 2) * h ^ (2 * alpha) := by have hpowsq : (h ^ alpha) ^ 2 = h ^ (2 * alpha) := by rw [sq, ← Real.rpow_add hhpos] congr 1 ring calc cK * (2 * lambda * h ^ alpha) ^ 2 = cK * ((2 * lambda) ^ 2 * (h ^ alpha) ^ 2) := by ring _ = (4 * cK * lambda ^ 2) * h ^ (2 * alpha) := by rw [hpowsq] ring calc (4 * cK * lambda ^ 2) * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) = cK * (thetaFunctional P1 t0 - thetaFunctional P0 t0) ^ 2 := by rw [hsep, hsq_sep, hrate] _ ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 := hlow
CausalSmith.Stat.DoseResponseMinimax.oracle_dose_regression_lower_all_beta · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/TwoPointConstruction.lean:212
Helpers.UpperBoundCited 19 declarations This supportive cited leaf records the conditional risk implication in arXiv:2207.11825v1, Section 3.4, Theorem 1 and Remarks 7–8/Figure 1 (Theorem 3.1 in v2).

Cited conditional upper-risk comparator (Bonvini–Kennedy 2022)

This supportive cited leaf records the conditional risk implication in arXiv:2207.11825v1, Section 3.4, Theorem 1 and Remarks 7–8/Figure 1 (Theorem 3.1 in v2). It deliberately does not state a class-level minimax bound.

def EventuallyAtMostConstant

u ≲ v eventually, with the positive constant made explicit.

Definition (Lean source)
def EventuallyAtMostConstant (u v : ℕ → ℝ) : Prop := ∃ C, 0 < C ∧ ∀ᶠ n : ℕ in atTop, u n ≤ C * v n
CausalSmith.Stat.DoseResponseMinimax.EventuallyAtMostConstant · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:20
def EventuallyComparable

Two-sided eventual comparison, used for the source's tuning relations.

Definition (Lean source)
def EventuallyComparable (u v : ℕ → ℝ) : Prop := EventuallyAtMostConstant u v ∧ EventuallyAtMostConstant v u
CausalSmith.Stat.DoseResponseMinimax.EventuallyComparable · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:24
structure BKHOIFEstimatorSpec

Inputs from which the Bonvini–Kennedy second-order estimator used in the Figure 1 rho_n comparison is constructed. The nuisance estimates are indexed by training-sample size. The estimator and every risk/error quantity below are definitions computed from these inputs; no influence kernel is a free field.

Definition (Lean source)
d :
law :
targetDose :
muHat :
ℕ → ℝ → (Fin d → ℝ) → ℝ
piHat :
ℕ → ℝ → (Fin d → ℝ) → ℝ
jointDensityHat :
ℕ → ℝ → (Fin d → ℝ) → ℝ
kernel :
ℝ → ℝ
bandwidth :
ℕ → ℝ
projectionDimension :
ℕ → ℝ
projectionKernel :
ℕ → (Fin d → ℝ) → (Fin d → ℝ) → ℝ
projectionHatKernel :
ℕ → (Fin d → ℝ) → (Fin d → ℝ) → ℝ
CausalSmith.Stat.DoseResponseMinimax.BKHOIFEstimatorSpec · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:28
def bkKernelAt

The localized kernel K_ht appearing in the source theorem.

Definition (Lean source)
noncomputable def bkKernelAt {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (a : ℝ) : ℝ := (E.bandwidth n)⁻¹ * E.kernel ((a - E.targetDose) / E.bandwidth n)
def bkFirstApproxInfluence

The source's first approximate influence function: the localized inverse-density residual score plus the plug-in regression value at the target dose.

Definition (Lean source)
noncomputable def bkFirstApproxInfluence {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (O : DoseObs d) : ℝ := E.muHat n E.targetDose O.X + bkKernelAt E n O.A * (O.Y - E.muHat n O.A O.X) / E.piHat n O.A O.X
CausalSmith.Stat.DoseResponseMinimax.bkFirstApproxInfluence · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:49
def bkResidualOne

The source's first residual factor f₁.

Definition (Lean source)
noncomputable def bkResidualOne {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (O : DoseObs d) : ℝ := bkKernelAt E n O.A * (O.Y - E.muHat n O.A O.X)
def bkResidualTwo

The source's inverse-density residual factor f₂.

Definition (Lean source)
noncomputable def bkResidualTwo {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (O : DoseObs d) : ℝ := bkKernelAt E n O.A / E.piHat n O.A O.X - 1
def bkSecondApproxInfluence

The second approximate influence kernel from Section 3.3: -f₁(Z₁) Π_hat(X₁,X₂) f₂(Z₂). It is definitionally pinned to the estimated projection kernel and nuisance estimates.

Definition (Lean source)
noncomputable def bkSecondApproxInfluence {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (z : Fin 2 → DoseObs d) : ℝ := -bkResidualOne E n (z 0) * E.projectionHatKernel n (z 0).X (z 1).X * bkResidualTwo E n (z 1)
CausalSmith.Stat.DoseResponseMinimax.bkSecondApproxInfluence · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:66
def bkSpecifiedHOIFEstimator

The specified second-order estimator used for the source's Figure 1 rate: the empirical mean of the first approximate influence function plus the order-two U-statistic. The injection sum counts each unordered pair 2! times, so the normalization is exactly 2! * choose n 2, not merely choose n 2.

Definition (Lean source)
noncomputable def bkSpecifiedHOIFEstimator {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (sample : Fin n → DoseObs d) : ℝ := (n : ℝ)⁻¹ * ∑ i, bkFirstApproxInfluence E n (sample i) + ((factorial 2 * choose n 2 : ℕ) : ℝ)⁻¹ * ∑ t : Fin 2 ↪ Fin n, bkSecondApproxInfluence E n (fun i => sample (t i))
CausalSmith.Stat.DoseResponseMinimax.bkSpecifiedHOIFEstimator · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:74
def bkConditionalMSE

Conditional MSE of the specified estimator, conditional on its nuisance-training sample, under the actual i.i.d. evaluation-sample law.

Definition (Lean source)
noncomputable def bkConditionalMSE {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) : ℝ := ∫ sample, (bkSpecifiedHOIFEstimator E n sample - thetaFunctional E.law E.targetDose) ^ 2 ∂(Measure.pi fun _ : Fin n => E.law.dataMeasure)
CausalSmith.Stat.DoseResponseMinimax.bkConditionalMSE · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:84
def bkL2NormCube

Lebesgue norm on the covariate cube.

Definition (Lean source)
noncomputable def bkL2NormCube {d : ℕ} (f : (Fin d → ℝ) → ℝ) : ℝ := sqrt (∫ x in cube d, (f x) ^ 2)
def bkProject

Application of the source's true finite-dimensional projection kernel.

Definition (Lean source)
noncomputable def bkProject {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) (f : (Fin d → ℝ) → ℝ) (x : Fin d → ℝ) : ℝ := ∫ z in cube d, E.projectionKernel n x z * f z
def bkVNorm

Actual outcome-regression nuisance error ‖v‖_g.

Definition (Lean source)
noncomputable def bkVNorm {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) : ℝ := bkL2NormCube (fun x => E.muHat n E.targetDose x - E.law.mu E.targetDose x)
def bkQNorm

Actual reciprocal-treatment-density nuisance error ‖q‖_g.

Definition (Lean source)
noncomputable def bkQNorm {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) : ℝ := bkL2NormCube (fun x => (E.piHat n E.targetDose x)⁻¹ - (E.law.pi E.targetDose x)⁻¹)
def bkProjectionProductError

Product of the actual projection-residual norms of the two nuisance errors.

Definition (Lean source)
noncomputable def bkProjectionProductError {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) : ℝ := let v := fun x => E.muHat n E.targetDose x - E.law.mu E.targetDose x let q := fun x => (E.piHat n E.targetDose x)⁻¹ - (E.law.pi E.targetDose x)⁻¹ bkL2NormCube (fun x => v x - bkProject E n v x) * bkL2NormCube (fun x => q x - bkProject E n q x)
CausalSmith.Stat.DoseResponseMinimax.bkProjectionProductError · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:110
def bkDensitySupError

Actual uniform error of the estimated joint density at the target dose.

Definition (Lean source)
noncomputable def bkDensitySupError {d : ℕ} (E : BKHOIFEstimatorSpec d) (n : ℕ) : ℝ := sSup {r : ℝ | ∃ x ∈ cube d, r = |E.jointDensityHat n E.targetDose x - E.law.pi E.targetDose x * E.law.px x|}
CausalSmith.Stat.DoseResponseMinimax.bkDensitySupError · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:119
structure BKTheorem31Conditions

Assumptions 1–2 and Conditions 1–4 of Bonvini–Kennedy Theorem 1/3.1, spelled out on the source estimator inputs.

Definition (Lean source)
d :
alpha beta :
evaluationLaw :
IsProbabilityMeasure E.law.dataMeasure
outcomeRegressionLaw :
covariateDensityLaw :
treatmentDensityLaw :
positivity :
∃ lo hi : ℝ,
0 < lo ∧
lo ≤ hi ∧
∀ n a x, lo ≤ E.law.pi a x ∧ E.law.pi a x ≤ hi ∧ lo ≤ E.piHat n a x ∧ E.piHat n a x ≤ hi
boundedness :
∃ B : ℝ,
0 < B ∧ (∀ᵐ O ∂E.law.dataMeasure, |O.Y| ≤ B ∧ |O.A| ≤ B) ∧ ∀ n a x, |E.muHat n a x| ≤ B
treatmentSmoothness :
(∀ x, HolderBall1D (fun a => E.law.mu a x) alpha 1 univ) ∧
(∀ n x, HolderBall1D (fun a => E.muHat n a x) alpha 1 univ) ∧
(∀ x, HolderBall1D (fun a => E.law.pi a x) beta 1 univ) ∧
(∀ n x, HolderBall1D (fun a => E.piHat n a x) beta 1 univ)
kernelCondition :
∃ Kmax glo ghi : ℝ,
0 < Kmax ∧
0 < glo ∧
glo ≤ ghi ∧
(∀ u, |E.kernel u| ≤ Kmax) ∧
Function.support E.kernel ⊆ Icc (-1 : ℝ) 1 ∧
(∫ u, E.kernel u) = 1 ∧
(∀ j : ℕ, 1 ≤ j → j ≤ ⌈alpha⌉₊ - 1 → (∫ u, (u ^ j) * E.kernel u) = 0) ∧
(∀ n, 0 < E.bandwidth n) ∧
(∀ n, (∫ a, bkKernelAt E n a) = 1) ∧
∀ n x,
glo ≤ ∫ a, bkKernelAt E n a * (E.law.pi a x * E.law.px x) ∧
(∫ a, bkKernelAt E n a * (E.law.pi a x * E.law.px x)) ≤ ghi
projectionDiagonal :
∃ Cpi : ℝ,
0 < Cpi ∧
∀ n x,
E.projectionKernel n x x ≤ Cpi * E.projectionDimension n ∧
E.projectionHatKernel n x x ≤ Cpi * E.projectionDimension n
localizedDensityRatio :
∃ rlo rhi : ℝ,
0 < rlo ∧
rlo ≤ rhi ∧
∀ n x,
rlo
≤ (∫ a, bkKernelAt E n a * (E.law.pi a x * E.law.px x)) / (∫ a, bkKernelAt E n a * E.jointDensityHat n a x) ∧
(∫ a, bkKernelAt E n a * (E.law.pi a x * E.law.px x)) / (∫ a, bkKernelAt E n a * E.jointDensityHat n a x)
≤ rhi
CausalSmith.Stat.DoseResponseMinimax.BKTheorem31Conditions · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:126
structure BKRateSpecialization

The source's explicit post-theorem rate specialization. Every error sequence is the actual quantity defined from E; no premise can be satisfied by choosing an unrelated favorable sequence.

Definition (Lean source)
d :
alpha beta s gamma₁ gamma₂ :
positiveParameters :
0 < d ∧ 0 < alpha ∧ 0 < beta ∧ 0 < s
treatmentOrder :
alpha ≤ beta
equalCovariateSmoothness :
gamma₁ = s ∧
gamma₂ = s ∧
∃ Bx : ℝ,
0 < Bx ∧
(∀ a, HolderBallND (fun x => E.law.mu a x) s Bx (cube d)) ∧
(∀ n a, HolderBallND (fun x => E.muHat n a x) s Bx (cube d)) ∧
(∀ a, HolderBallND (fun x => E.law.pi a x) s Bx (cube d)) ∧
∀ n a, HolderBallND (fun x => E.piHat n a x) s Bx (cube d)
projectionApproximation :
EventuallyAtMostConstant (bkProjectionProductError E) (fun n => (E.projectionDimension n) ^ (-(gamma₁ + gamma₂) / (d : ℝ)))
smoothTuning :
d ≤ 4 * s → EventuallyComparable E.bandwidth (fun n => (n : ℝ) ^ (-(1 / (2 * alpha + 1)))) ∧
EventuallyComparable E.projectionDimension (fun n => (n : ℝ) * E.bandwidth n)
deficientTuning :
4 * s < d → EventuallyComparable E.bandwidth (fun n => (n : ℝ) ^ (-(4 * s / (alpha * (4 * s + d) + 4 * s)))) ∧
EventuallyComparable E.projectionDimension (fun n => ((n : ℝ) * E.bandwidth n) ^ (2 * d / (d + 4 * s)))
equalRateNuisanceEstimation :
higherOrderDensityRemainderNegligible :
EventuallyAtMostConstant (fun n => (bkVNorm E n * bkQNorm E n * bkDensitySupError E n) ^ 2) (fun n => publishedHoifRate n alpha s d)
CausalSmith.Stat.DoseResponseMinimax.BKRateSpecialization · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:167
def publishedUpperBoundCited Cited result 1 in the paper ↗

Cited conditional comparator (Bonvini–Kennedy 2022, Theorem 1/3.1 and rate discussion; arXiv:2207.11825v1, Section 3.4 and Remarks 7–8/Figure 1). For the source's specified HOIF construction, the theorem conditions and explicit rate specialization imply the eventual bound on its actual conditional MSE.

Definition (Lean source)
def publishedUpperBoundCited (d : ℕ) (alpha beta s gamma₁ gamma₂ : ℝ) : Prop := ∀ E : BKHOIFEstimatorSpec d, BKTheorem31Conditions alpha beta E → BKRateSpecialization alpha beta s gamma₁ gamma₂ E → EventuallyAtMostConstant (bkConditionalMSE E) (fun n => publishedHoifRate n alpha s d)
CausalSmith.Stat.DoseResponseMinimax.publishedUpperBoundCited · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/UpperBoundCited.lean:198
Helpers.Witness.Base 11 declarations

The unit covariate cube is a measurable set.

Formal statement
d :
Proof (Lean source)
lemma measurableSet_cube (d : ℕ) : MeasurableSet (cube d) := by unfold cube measurability
CausalSmith.Stat.DoseResponseMinimax.measurableSet_cube · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:27
theorem restrict_withDensity_ofReal_isProbabilityMeasure Lemma restrict-withDensity-ofReal-isProbability in the paper ↗

A nonnegative density on a measurable restriction that integrates to one defines a probability measure after weighting the restricted measure.

Formal statement
α :
Type*
Set α
α → ℝ
hs :
h_nonneg :
∀ x ∈ s, 0 ≤ f x
h_int :
(∫ x, f x ∂(μ.restrict s)) = 1
IsProbabilityMeasure ((μ.restrict s).withDensity fun x => ofReal (f x))
Proof (Lean source)
lemma restrict_withDensity_ofReal_isProbabilityMeasure {α : Type*} [MeasurableSpace α] {μ : Measure α} {s : Set α} {f : α → ℝ} (hs : MeasurableSet s) (h_nonneg : ∀ x ∈ s, 0 ≤ f x) (h_int : (∫ x, f x ∂(μ.restrict s)) = 1) : IsProbabilityMeasure ((μ.restrict s).withDensity fun x => ofReal (f x)) := by rw [isProbabilityMeasure_iff] rw [withDensity_apply _ MeasurableSet.univ, Measure.restrict_univ] have hf_int : Integrable f (μ.restrict s) := by refine Integrable.of_integral_ne_zero ?_ simp [h_int] have hf_nn : 0 ≤ᵐ[μ.restrict s] f := by rw [EventuallyLE] exact (ae_restrict_iff' hs).2 (Filter.Eventually.of_forall fun x hx => h_nonneg x hx) rw [← ofReal_integral_eq_lintegral_ofReal hf_int hf_nn] simp [h_int]
CausalSmith.Stat.DoseResponseMinimax.restrict_withDensity_ofReal_isProbabilityMeasure · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:33
theorem integrable_of_measurable_ae_bounded Lemma integrable-of-ae-bounded in the paper ↗

On a finite measure space, a measurable real function that is almost surely bounded in absolute value is integrable.

Formal statement
α :
f :
α → ℝ
hfmeas :
C :
hC :
∀ᵐ x ∂μ, |f x| ≤ C
Proof (Lean source)
lemma integrable_of_measurable_ae_bounded {α : Type*} [MeasurableSpace α] {μ : Measure α} [IsFiniteMeasure μ] {f : α → ℝ} (hfmeas : Measurable f) (C : ℝ) (hC : ∀ᵐ x ∂μ, |f x| ≤ C) : Integrable f μ := by refine Integrable.of_bound hfmeas.aestronglyMeasurable (max C 0) ?_ filter_upwards [hC] with x hx exact (by simpa [Real.norm_eq_abs] using hx.trans (le_max_left C 0))
CausalSmith.Stat.DoseResponseMinimax.integrable_of_measurable_ae_bounded · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:52
theorem measurable_doseObs_tuple Lemma doseObs-measurability in the paper ↗

The map sending an observation to its outcome, treatment, and covariate tuple is measurable.

Formal statement
d :
Measurable (fun O : DoseObs d => (O.Y, O.A, O.X))
Proof (Lean source)
lemma measurable_doseObs_tuple {d : ℕ} : Measurable (fun O : DoseObs d => (O.Y, O.A, O.X)) := Measurable.of_comap_le le_rfl
CausalSmith.Stat.DoseResponseMinimax.measurable_doseObs_tuple · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:63
theorem measurable_doseObs_Y

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

Formal statement
d :
Measurable (fun O : DoseObs d => O.Y)
Proof (Lean source)
lemma measurable_doseObs_Y {d : ℕ} : Measurable (fun O : DoseObs d => O.Y) := by change Measurable ((fun p : ℝ × (ℝ × (Fin d → ℝ)) => p.1) ∘ (fun O : DoseObs d => (O.Y, O.A, O.X))) exact measurable_fst.comp measurable_doseObs_tuple
CausalSmith.Stat.DoseResponseMinimax.measurable_doseObs_Y · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:69
theorem measurable_doseObs_A

The observed treatment coordinate is a measurable function of the observation.

Formal statement
d :
Measurable (fun O : DoseObs d => O.A)
Proof (Lean source)
lemma measurable_doseObs_A {d : ℕ} : Measurable (fun O : DoseObs d => O.A) := by change Measurable ((fun p : ℝ × (ℝ × (Fin d → ℝ)) => p.2.1) ∘ (fun O : DoseObs d => (O.Y, O.A, O.X))) exact (measurable_fst.comp measurable_snd).comp measurable_doseObs_tuple
CausalSmith.Stat.DoseResponseMinimax.measurable_doseObs_A · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:75
theorem measurable_doseObs_X

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

Formal statement
d :
Measurable (fun O : DoseObs d => O.X)
Proof (Lean source)
lemma measurable_doseObs_X {d : ℕ} : Measurable (fun O : DoseObs d => O.X) := by change Measurable ((fun p : ℝ × (ℝ × (Fin d → ℝ)) => p.2.2) ∘ (fun O : DoseObs d => (O.Y, O.A, O.X))) exact (measurable_snd.comp measurable_snd).comp measurable_doseObs_tuple
CausalSmith.Stat.DoseResponseMinimax.measurable_doseObs_X · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:81
instance instMeasurableSingletonClassDoseObs

The observed-data space has measurable singleton sets.

Definition (Lean source)
instance instMeasurableSingletonClassDoseObs {d : ℕ} : MeasurableSingletonClass (DoseObs d) := by refine ⟨?_⟩ intro O have hset : MeasurableSet ((fun O' : DoseObs d => (O'.Y, O'.A, O'.X)) ⁻¹' ({(O.Y, O.A, O.X)} : Set (ℝ × ℝ × (Fin d → ℝ)))) := measurable_doseObs_tuple (measurableSet_singleton _) convert hset using 1 ext O' cases O cases O' simp
CausalSmith.Stat.DoseResponseMinimax.instMeasurableSingletonClassDoseObs · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:87
theorem measurable_doseObs_mk

For fixed treatment and covariates, forming an observation from an outcome is measurable.

Formal statement
d :
a :
x :
Fin d → ℝ
Measurable (fun y : ℝ => DoseObs.mk y a x)
Proof (Lean source)
@[fun_prop] lemma measurable_doseObs_mk {d : ℕ} (a : ℝ) (x : Fin d → ℝ) : Measurable (fun y : ℝ => DoseObs.mk y a x) := by rw [measurable_comap_iff] fun_prop
CausalSmith.Stat.DoseResponseMinimax.measurable_doseObs_mk · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:101
theorem measurable_doseObs_mk_AX

Forming an observation from covariates, treatment, and outcome is measurable.

Formal statement
d :
Measurable (fun p : (Fin d → ℝ) × ℝ × ℝ => DoseObs.mk p.2.2 p.2.1 p.1)
Proof (Lean source)
@[fun_prop] lemma measurable_doseObs_mk_AX {d : ℕ} : Measurable (fun p : (Fin d → ℝ) × ℝ × ℝ => DoseObs.mk p.2.2 p.2.1 p.1) := by rw [measurable_comap_iff] fun_prop
CausalSmith.Stat.DoseResponseMinimax.measurable_doseObs_mk_AX · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:108

Base-coordinate marginal of a bind whose fibre is reattached by a map.

Formal statement
α β δ :
Type*
α → Measure β
α → β → δ
δ → α
_hκ :
hp :
∀ a, IsProbabilityMeasure (κ a)
hg :
∀ a, Measurable (g a)
hmap :
Measurable fun a => (κ a).map (g a)
:
hπg :
∀ a b, π (g a b) = a
(m.bind fun a => (κ a).map (g a)).map π = m
Proof (Lean source)
lemma map_bind_map_proj {α β δ : Type*} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace δ] {m : Measure α} {κ : α → Measure β} {g : α → β → δ} {π : δ → α} (_hκ : Measurable κ) (hp : ∀ a, IsProbabilityMeasure (κ a)) (hg : ∀ a, Measurable (g a)) (hmap : Measurable fun a => (κ a).map (g a)) (hπ : Measurable π) (hπg : ∀ a b, π (g a b) = a) : (m.bind fun a => (κ a).map (g a)).map π = m := by have hdπ : Measurable (fun z => Measure.dirac (π z)) := Measure.measurable_dirac.comp hπ have hstep : (fun a => ((κ a).map (g a)).bind fun z => Measure.dirac (π z)) = fun a => Measure.dirac a := by funext a rw [Measure.bind_dirac_eq_map _ hπ, Measure.map_map hπ (hg a)] have hc : (π ∘ g a) = fun _ => a := funext (hπg a) rw [hc, Measure.map_const, (hp a).measure_univ, one_smul] rw [← Measure.bind_dirac_eq_map _ hπ, Measure.bind_bind hmap.aemeasurable hdπ.aemeasurable] rw [hstep, Measure.bind_dirac]
CausalSmith.Stat.DoseResponseMinimax.map_bind_map_proj · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Base.lean:115
Helpers.Witness.BumpHolder 1 declarations
theorem doseBump_holder_gate

SUBSTRATE GATE (the only one of the genuine construction). For a positive Hölder order α and radius M, there is a fixed amplitude λ ∈ (0, M/4] such that for every sign ζ ∈ {−1, +1} and every bandwidth h ∈ (0,1], the scaled smooth bump slice a ↦ ζ·λ·h^α·doseBump((a−t_0)/h) lies in the univariate order-α radius-M Hölder ball on the evaluation window [t_0−ε_0, t_0+ε_0]. This is the classical h^α-normalized Hölder estimate for ContDiffBump; everything else in the construction is proved. The amplitude bound λ ≤ M/4 is the constraint consumed by the two-point KL band (|μ_ζ| ≤ λ ≤ B/2 with B = M/2).

Formal statement
alpha M t0 eps0 :
halpha :
0 < alpha
hM :
0 < M
∃ lam : ℝ
if
0 < lam ∧ lam ≤ M / 4 ∧ ∀ {ζ h : ℝ}, (ζ = -1 ∨ ζ = 1)
and
0 < h
and
h ≤ 1
then
HolderBall1D (fun a => ζ * lam * h ^ alpha * doseBump ((a - t0) / h)) alpha M (doseWindow t0 eps0)
Proof (Lean source)
lemma doseBump_holder_gate (alpha M t0 eps0 : ℝ) (halpha : 0 < alpha) (hM : 0 < M) : ∃ lam : ℝ, 0 < lam ∧ lam ≤ M / 4 ∧ ∀ {ζ h : ℝ}, (ζ = -1 ∨ ζ = 1) → 0 < h → h ≤ 1 → HolderBall1D (fun a => ζ * lam * h ^ alpha * doseBump ((a - t0) / h)) alpha M (doseWindow t0 eps0) := by classical let k : ℕ := ⌈alpha⌉₊ - 1 have hceil_pos : 0 < ⌈alpha⌉₊ := Nat.ceil_pos.mpr halpha have hk_le : (k : ℝ) ≤ alpha := by apply le_of_lt rw [← Nat.lt_ceil] simpa [k] using Nat.pred_lt hceil_pos.ne' let Cderiv : ℕ → ℝ := fun j => choose (doseBump_iteratedDeriv_bound j) have hCderiv_nonneg : ∀ j : ℕ, 0 ≤ Cderiv j := by intro j exact (Classical.choose_spec (doseBump_iteratedDeriv_bound j)).1 have hCderiv_bound : ∀ j : ℕ, ∀ z : ℝ, |iteratedDeriv j doseBump z| ≤ Cderiv j := by intro j exact (Classical.choose_spec (doseBump_iteratedDeriv_bound j)).2 rcases doseBump_ceilPred_iteratedDeriv_holder alpha halpha with ⟨CH, hCH_nonneg, hCH⟩ let S : ℝ := ∑ j ∈ range (k + 1), Cderiv j let B : ℝ := max CH (max S 1) have hB_ge_one : 1 ≤ B := by exact (le_max_right S 1).trans (le_max_right CH (max S 1)) have hB_nonneg : 0 ≤ B := (zero_le_one.trans hB_ge_one) have hB_pos_add : 0 < B + 1 := by linarith have hCH_le_B : CH ≤ B := le_max_left _ _ have hlamB_aux : min (M / 4) (M / (B + 1)) * B ≤ M := by have hmin_le : min (M / 4) (M / (B + 1)) ≤ M / (B + 1) := min_le_right _ _ have hMdiv_nonneg : 0 ≤ M / (B + 1) := (div_pos hM hB_pos_add).le have hB_le_add : B ≤ B + 1 := by linarith calc min (M / 4) (M / (B + 1)) * B ≤ (M / (B + 1)) * B := mul_le_mul_of_nonneg_right hmin_le hB_nonneg _ ≤ (M / (B + 1)) * (B + 1) := mul_le_mul_of_nonneg_left hB_le_add hMdiv_nonneg _ = M := by field_simp [hB_pos_add.ne'] let lam : ℝ := min (M / 4) (M / (B + 1)) have hlam_pos : 0 < lam := by have hM4 : 0 < M / 4 := by positivity have hMdiv : 0 < M / (B + 1) := div_pos hM hB_pos_add exact lt_min hM4 hMdiv have hlam_nonneg : 0 ≤ lam := hlam_pos.le have hlam_le_M4 : lam ≤ M / 4 := min_le_left _ _ have hlamB : lam * B ≤ M := by simpa [lam] using hlamB_aux refine ⟨lam, hlam_pos, hlam_le_M4, ?_⟩ intro ζ h hζ hh_pos hh_le have hζ_abs : |ζ| = 1 := by rcases hζ with rfl | rfl <;> norm_num have hinner : ContDiff ℝ (↑(⊤ : ℕ∞) : WithTop ℕ∞) (fun a : ℝ => (a - t0) / h) := (contDiff_id.sub contDiff_const).div_const h have hsmooth : ContDiff ℝ (↑(⊤ : ℕ∞) : WithTop ℕ∞) (fun a : ℝ => ζ * lam * h ^ alpha * doseBump ((a - t0) / h)) := contDiff_const.mul (doseBump_contDiff_top.comp hinner) refine ⟨hsmooth.contDiffOn.of_le (WithTop.coe_le_coe.mpr le_top), ?_, ?_⟩ · intro j hj x _hx have hjk : j ≤ k := by simpa [k] using hj have hj_alpha : (j : ℝ) ≤ alpha := (Nat.cast_le.mpr hjk).trans hk_le have hj_mem : j ∈ range (k + 1) := by simpa [Finset.mem_range] using Nat.lt_succ_of_le hjk have hCj_le_S : Cderiv j ≤ S := by exact Finset.single_le_sum (fun i _hi => hCderiv_nonneg i) hj_mem have hCj_le_B : Cderiv j ≤ B := by exact hCj_le_S.trans ((le_max_left S 1).trans (le_max_right CH (max S 1))) have hlamCj : lam * Cderiv j ≤ M := by exact (mul_le_mul_of_nonneg_left hCj_le_B hlam_nonneg).trans hlamB have hscale_le : h ^ alpha * (h⁻¹) ^ j ≤ 1 := rpow_mul_inv_pow_le_one hh_pos hh_le hj_alpha have hscale_nonneg : 0 ≤ h ^ alpha * (h⁻¹) ^ j := mul_nonneg (Real.rpow_nonneg hh_pos.le alpha) (pow_nonneg (inv_nonneg.mpr hh_pos.le) j) have hscale_lam_le : lam * (h ^ alpha * (h⁻¹) ^ j) ≤ lam := by simpa using mul_le_mul_of_nonneg_left hscale_le hlam_nonneg have hD := hCderiv_bound j ((x - t0) / h) rw [iteratedDeriv_scaledBump (c := ζ * lam * h ^ alpha) (h := h) (t0 := t0) (_hh := hh_pos.ne') (j := j) (a := x)] change |(ζ * lam * h ^ alpha) * (h⁻¹) ^ j * iteratedDeriv j doseBump ((x - t0) / h)| ≤ M have habs : |(ζ * lam * h ^ alpha) * (h⁻¹) ^ j * iteratedDeriv j doseBump ((x - t0) / h)| = lam * (h ^ alpha * (h⁻¹) ^ j) * |iteratedDeriv j doseBump ((x - t0) / h)| := by rw [abs_mul, abs_mul, abs_mul, abs_mul, hζ_abs, abs_of_nonneg hlam_nonneg, abs_of_nonneg (Real.rpow_nonneg hh_pos.le alpha), abs_of_nonneg (pow_nonneg (inv_nonneg.mpr hh_pos.le) j)] ring calc |(ζ * lam * h ^ alpha) * (h⁻¹) ^ j * iteratedDeriv j doseBump ((x - t0) / h)| = lam * (h ^ alpha * (h⁻¹) ^ j) * |iteratedDeriv j doseBump ((x - t0) / h)| := habs _ ≤ lam * Cderiv j := mul_le_mul hscale_lam_le hD (abs_nonneg _) hlam_nonneg _ ≤ M := hlamCj · intro x _hx y _hy have hCH_lam : lam * CH ≤ M := by exact (mul_le_mul_of_nonneg_left hCH_le_B hlam_nonneg).trans hlamB let gamma : ℝ := alpha - (k : ℝ) let ux : ℝ := (x - t0) / h let uy : ℝ := (y - t0) / h have hscale_nonneg : 0 ≤ h ^ alpha * (h⁻¹) ^ k := mul_nonneg (Real.rpow_nonneg hh_pos.le alpha) (pow_nonneg (inv_nonneg.mpr hh_pos.le) k) have hpref_nonneg : 0 ≤ lam * (h ^ alpha * (h⁻¹) ^ k) := mul_nonneg hlam_nonneg hscale_nonneg have htop := hCH ux uy rw [iteratedDeriv_scaledBump (c := ζ * lam * h ^ alpha) (h := h) (t0 := t0) (_hh := hh_pos.ne') (j := k) (a := x), iteratedDeriv_scaledBump (c := ζ * lam * h ^ alpha) (h := h) (t0 := t0) (_hh := hh_pos.ne') (j := k) (a := y)] change |(ζ * lam * h ^ alpha) * (h⁻¹) ^ k * iteratedDeriv k doseBump ux - (ζ * lam * h ^ alpha) * (h⁻¹) ^ k * iteratedDeriv k doseBump uy| ≤ M * |x - y| ^ (alpha - ((⌈alpha⌉₊ - 1 : ℕ) : ℝ)) have hfactor : (ζ * lam * h ^ alpha) * (h⁻¹) ^ k * iteratedDeriv k doseBump ux - (ζ * lam * h ^ alpha) * (h⁻¹) ^ k * iteratedDeriv k doseBump uy = (ζ * lam * h ^ alpha) * (h⁻¹) ^ k * (iteratedDeriv k doseBump ux - iteratedDeriv k doseBump uy) := by ring rw [hfactor] have habs : |(ζ * lam * h ^ alpha) * (h⁻¹) ^ k * (iteratedDeriv k doseBump ux - iteratedDeriv k doseBump uy)| = lam * (h ^ alpha * (h⁻¹) ^ k) * |iteratedDeriv k doseBump ux - iteratedDeriv k doseBump uy| := by rw [abs_mul, abs_mul, abs_mul, abs_mul, hζ_abs, abs_of_nonneg hlam_nonneg, abs_of_nonneg (Real.rpow_nonneg hh_pos.le alpha), abs_of_nonneg (pow_nonneg (inv_nonneg.mpr hh_pos.le) k)] ring have hcancel : h ^ alpha * (h⁻¹) ^ k * |ux - uy| ^ gamma = |x - y| ^ gamma := by simpa [ux, uy, gamma, k] using (rpow_scaled_holder_cancel (h := h) (alpha := alpha) (t0 := t0) (x := x) (y := y) hh_pos) calc |(ζ * lam * h ^ alpha) * (h⁻¹) ^ k * (iteratedDeriv k doseBump ux - iteratedDeriv k doseBump uy)| = lam * (h ^ alpha * (h⁻¹) ^ k) * |iteratedDeriv k doseBump ux - iteratedDeriv k doseBump uy| := habs _ ≤ lam * (h ^ alpha * (h⁻¹) ^ k) * (CH * |ux - uy| ^ gamma) := mul_le_mul_of_nonneg_left htop hpref_nonneg _ = lam * CH * (h ^ alpha * (h⁻¹) ^ k * |ux - uy| ^ gamma) := by ring _ = lam * CH * |x - y| ^ gamma := by rw [hcancel] _ ≤ M * |x - y| ^ gamma := mul_le_mul_of_nonneg_right hCH_lam (Real.rpow_nonneg (abs_nonneg _) gamma) _ = M * |x - y| ^ (alpha - ((⌈alpha⌉₊ - 1 : ℕ) : ℝ)) := by simp [gamma, k]
CausalSmith.Stat.DoseResponseMinimax.doseBump_holder_gate · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/BumpHolder.lean:209
Helpers.Witness.Channel 5 declarations

The outcome Markov kernel (a,x) ↦ twoPointMean B (μ_ζ(a,x)) pushed onto the observed-unit space by y ↦ (y, a, x). This is the single conditional kernel that, composed with the shared (A,X)-marginal doseAXMeasure, reproduces the genuine joint law doseDataMeasure.

Definition (Lean source)
noncomputable def doseChannelAX (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) : Kernel (ℝ × (Fin d → ℝ)) (DoseObs d) where toFun := fun p => (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)).map (fun y => DoseObs.mk y p.1 p.2) measurable' := by refine Measure.measurable_of_measurable_coe _ ?_ intro S hS exact (measurable_twoPointMean_map_doseObs_pair (d := d) B alpha t0 lambda h zeta S hS).comp (measurable_snd.prodMk measurable_fst)
theorem doseChannelAX_apply

Applying the outcome channel at a treatment-covariate pair gives the two-point outcome law pushed forward to the observed-data space at that same pair.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
p :
ℝ × (Fin d → ℝ)
doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta p
= (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)).map (fun y => DoseObs.mk y p.1 p.2)
Proof (Lean source)
@[simp] lemma doseChannelAX_apply (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) (p : ℝ × (Fin d → ℝ)) : doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta p = (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)).map (fun y => DoseObs.mk y p.1 p.2) := rfl
CausalSmith.Stat.DoseResponseMinimax.doseChannelAX_apply · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Channel.lean:42
theorem instIsMarkovDoseChannelAX

If the two-point outcome laws are valid probability laws, then the witness outcome channel is a Markov kernel.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
IsMarkovKernel (doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma instIsMarkovDoseChannelAX {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : IsMarkovKernel (doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta) := by refine ⟨fun p => ?_⟩ rw [doseChannelAX_apply] letI : IsProbabilityMeasure (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)) := twoPointMean_isProbabilityMeasure hB (hmu p.1 p.2) exact Measure.isProbabilityMeasure_map (measurable_doseObs_mk p.1 p.2).aemeasurable
CausalSmith.Stat.DoseResponseMinimax.instIsMarkovDoseChannelAX · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Channel.lean:50
theorem doseAXMeasure_isProbabilityMeasure

If the witness covariate and treatment measures are probability measures, then their joint treatment-covariate measure is also a probability measure.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
Proof (Lean source)
lemma doseAXMeasure_isProbabilityMeasure {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) : IsProbabilityMeasure (doseAXMeasure (d := d) p0 q0) := by classical let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 have hmap : Measurable fun x : Fin d → ℝ => mA.map fun a : ℝ => (a, x) := by letI : IsProbabilityMeasure mA := hpA exact Measurable.map_prodMk_right (μ := mA) have hprob : ∀ x : Fin d → ℝ, IsProbabilityMeasure (mA.map fun a : ℝ => (a, x)) := by intro x letI : IsProbabilityMeasure mA := hpA exact Measure.isProbabilityMeasure_map measurable_prodMk_right.aemeasurable change IsProbabilityMeasure (mX.bind fun x => mA.map fun a : ℝ => (a, x)) letI : IsProbabilityMeasure mX := hpX exact isProbabilityMeasure_bind hmap.aemeasurable (Filter.Eventually.of_forall hprob)
CausalSmith.Stat.DoseResponseMinimax.doseAXMeasure_isProbabilityMeasure · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Channel.lean:65
theorem doseDataMeasure_eq_AXbind

The genuine nested X → A → Y joint law equals the single bind of the shared (A,X)-marginal against the outcome channel. This is the bridge that lets the regression, ignorability, and KL leaves work over one Measure.bind.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta
= (doseAXMeasure (d := d) p0 q0).bind (doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseDataMeasure_eq_AXbind {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} : doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta = (doseAXMeasure (d := d) p0 q0).bind (doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta) := by classical let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 let κ : ℝ × (Fin d → ℝ) → Measure (DoseObs d) := ⇑(doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta) haveI : SFinite mA := by dsimp [mA] unfold doseAMeasure infer_instance have hAXMeas : Measurable fun x : Fin d → ℝ => mA.map fun a : ℝ => (a, x) := by exact Measurable.map_prodMk_right (μ := mA) have hκMeas : Measurable κ := by exact (doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta).measurable have hinner (x : Fin d → ℝ) : (mA.map (fun a : ℝ => (a, x))).bind κ = mA.bind (fun a => κ (a, x)) := by ext s hs have hcomp : AEMeasurable (fun a : ℝ => κ (a, x)) mA := by simpa [Function.comp_def] using hκMeas.aemeasurable.comp_measurable (measurable_prodMk_right (y := x)) have hκs : AEMeasurable (fun p => κ p s) (mA.map fun a : ℝ => (a, x)) := (Measure.measurable_coe hs).comp_aemeasurable hκMeas.aemeasurable rw [Measure.bind_apply hs hκMeas.aemeasurable] rw [Measure.bind_apply hs hcomp] rw [lintegral_map' hκs measurable_prodMk_right.aemeasurable] unfold doseDataMeasure doseAXMeasure change mX.bind (fun x => mA.bind fun a => κ (a, x)) = (mX.bind fun x => mA.map fun a : ℝ => (a, x)).bind κ rw [Measure.bind_bind hAXMeas.aemeasurable hκMeas.aemeasurable] apply congrArg (Measure.bind mX) funext x exact (hinner x).symm
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_eq_AXbind · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Channel.lean:87
Helpers.Witness.Core 21 declarations Smooth treatment bump

Smooth treatment bump

A fixed smooth bump supported in (-1,1) and equal to one near zero.

Definition (Lean source)
noncomputable def doseContDiffBump : ContDiffBump (0 : ℝ) := ⟨(1 / 2 : ℝ), 1, by norm_num, by norm_num⟩
CausalSmith.Stat.DoseResponseMinimax.doseContDiffBump · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:21

The treatment bump is the fixed smooth bump function evaluated at a real argument.

Definition (Lean source)
noncomputable def doseBump (z : ℝ) : ℝ := doseContDiffBump z
theorem doseBump_zero

The treatment bump equals one at the center of the bump.

Formal statement
doseBump 0 = 1
Proof (Lean source)
lemma doseBump_zero : doseBump 0 = 1 := by unfold doseBump doseContDiffBump exact ContDiffBump.one_of_mem_closedBall _ (by simp [Metric.mem_closedBall])
CausalSmith.Stat.DoseResponseMinimax.doseBump_zero · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:30
theorem doseBump_nonneg

The treatment bump is everywhere nonnegative.

Formal statement
z :
0 ≤ doseBump z
Proof (Lean source)
lemma doseBump_nonneg (z : ℝ) : 0 ≤ doseBump z := by unfold doseBump exact doseContDiffBump.nonneg
CausalSmith.Stat.DoseResponseMinimax.doseBump_nonneg · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:35
theorem doseBump_le_one

The treatment bump is everywhere bounded above by one.

Formal statement
z :
doseBump z ≤ 1
Proof (Lean source)
lemma doseBump_le_one (z : ℝ) : doseBump z ≤ 1 := by unfold doseBump exact doseContDiffBump.le_one
CausalSmith.Stat.DoseResponseMinimax.doseBump_le_one · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:40
theorem doseBump_abs_le_one

The absolute value of the treatment bump is everywhere bounded by one.

Formal statement
z :
|doseBump z| ≤ 1
Proof (Lean source)
lemma doseBump_abs_le_one (z : ℝ) : |doseBump z| ≤ 1 := by rw [abs_of_nonneg (doseBump_nonneg z)] exact doseBump_le_one z
CausalSmith.Stat.DoseResponseMinimax.doseBump_abs_le_one · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:45
theorem doseBump_eq_zero_of_one_le_abs

The treatment bump vanishes at every point whose distance from the center is at least one in the normalized coordinate.

Formal statement
z :
hz :
1 ≤ |z|
doseBump z = 0
Proof (Lean source)
lemma doseBump_eq_zero_of_one_le_abs {z : ℝ} (hz : 1 ≤ |z|) : doseBump z = 0 := by unfold doseBump doseContDiffBump refine ContDiffBump.zero_of_le_dist _ ?_ simpa [Real.dist_eq, abs_sub_comm] using hz
CausalSmith.Stat.DoseResponseMinimax.doseBump_eq_zero_of_one_le_abs · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:50
theorem measurable_doseBump

The treatment bump is a measurable real-valued function.

Formal statement
Proof (Lean source)
@[fun_prop] lemma measurable_doseBump : Measurable doseBump := by unfold doseBump exact (doseContDiffBump.contDiff (n := ⊤)).continuous.measurable
CausalSmith.Stat.DoseResponseMinimax.measurable_doseBump · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:58

The witness conditional mean is a localized treatment bump with amplitude given by the product of the sign, scale, bandwidth power, and smoothness constant.

Definition (Lean source)
noncomputable def doseWitnessMu {d : ℕ} (alpha t0 lambda h zeta : ℝ) : ℝ → (Fin d → ℝ) → ℝ := fun a _x => zeta * lambda * h ^ alpha * doseBump ((a - t0) / h)
CausalSmith.Stat.DoseResponseMinimax.doseWitnessMu · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:66
theorem measurable_doseWitnessMu

The witness conditional mean is measurable as a function of treatment and covariates.

Formal statement
d :
alpha t0 lambda h zeta :
Measurable (fun p : ℝ × (Fin d → ℝ) => doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)
Proof (Lean source)
lemma measurable_doseWitnessMu {d : ℕ} (alpha t0 lambda h zeta : ℝ) : Measurable (fun p : ℝ × (Fin d → ℝ) => doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2) := by unfold doseWitnessMu fun_prop
CausalSmith.Stat.DoseResponseMinimax.measurable_doseWitnessMu · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:72
theorem measurable_twoPointMean_map_doseObs

For fixed covariates, the two-point outcome law pushed to observed triples varies measurably with the treatment value.

Formal statement
d :
B alpha t0 lambda h zeta :
x :
Fin d → ℝ
Measurable fun a : ℝ
=> (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x)
Proof (Lean source)
lemma measurable_twoPointMean_map_doseObs {d : ℕ} (B alpha t0 lambda h zeta : ℝ) (x : Fin d → ℝ) : Measurable fun a : ℝ => (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x) := by refine Measure.measurable_of_measurable_coe _ ?_ intro S hS unfold twoPointMean doseWitnessMu simp_rw [Measure.map_apply (measurable_doseObs_mk _ _) hS] simp only [Measure.add_apply, Measure.smul_apply] simp only [Measure.dirac_apply] simp only [smul_eq_mul] exact ((by fun_prop : Measurable fun a : ℝ => ofReal ((1 + zeta * lambda * h ^ alpha * doseBump ((a - t0) / h) / B) / 2)).mul (measurable_doseObs_support_indicator_A (d := d) B x S hS)).add ((by fun_prop : Measurable fun a : ℝ => ofReal ((1 - zeta * lambda * h ^ alpha * doseBump ((a - t0) / h) / B) / 2)).mul (measurable_doseObs_support_indicator_A (d := d) (-B) x S hS))
CausalSmith.Stat.DoseResponseMinimax.measurable_twoPointMean_map_doseObs · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:106
theorem measurable_twoPointMean_map_doseObs_pair

The probability assigned by the pushed-forward two-point outcome law to any measurable event is a measurable function of covariates and treatment.

Formal statement
d :
B alpha t0 lambda h zeta :
S :
hS :
Measurable fun p : (Fin d → ℝ) × ℝ
=> ((twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.2 p.1)).map (fun y => DoseObs.mk y p.2 p.1)) S
Proof (Lean source)
lemma measurable_twoPointMean_map_doseObs_pair {d : ℕ} (B alpha t0 lambda h zeta : ℝ) (S : Set (DoseObs d)) (hS : MeasurableSet S) : Measurable fun p : (Fin d → ℝ) × ℝ => ((twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.2 p.1)).map (fun y => DoseObs.mk y p.2 p.1)) S := by simp_rw [Measure.map_apply (measurable_doseObs_mk _ _) hS] unfold twoPointMean doseWitnessMu simp only [Measure.add_apply, Measure.smul_apply] simp only [Measure.dirac_apply] simp only [smul_eq_mul] exact ((by fun_prop : Measurable fun p : (Fin d → ℝ) × ℝ => ofReal ((1 + zeta * lambda * h ^ alpha * doseBump ((p.2 - t0) / h) / B) / 2)).mul (measurable_doseObs_support_indicator_pair (d := d) B S hS)).add ((by fun_prop : Measurable fun p : (Fin d → ℝ) × ℝ => ofReal ((1 - zeta * lambda * h ^ alpha * doseBump ((p.2 - t0) / h) / B) / 2)).mul (measurable_doseObs_support_indicator_pair (d := d) (-B) S hS))
CausalSmith.Stat.DoseResponseMinimax.measurable_twoPointMean_map_doseObs_pair · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:133

The witness covariate measure is Lebesgue measure on the unit covariate cube weighted by the covariate density.

Definition (Lean source)
noncomputable def doseXMeasure {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) : Measure (Fin d → ℝ) := (volume.restrict (cube d)).withDensity fun x => ofReal (p0 x)

The witness treatment measure is Lebesgue measure on the unit treatment interval weighted by the treatment density.

Definition (Lean source)
noncomputable def doseAMeasure (q0 : ℝ → ℝ) : Measure ℝ := (volume.restrict (Icc (0 : ℝ) 1)).withDensity fun a => ofReal (q0 a)
theorem measurable_doseOutcomeKernel

Integrating the treatment law against the two-point outcome law gives an outcome kernel that is measurable as a function of covariates.

Formal statement
d :
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
Measurable fun x : Fin d → ℝ
=> (doseAMeasure q0).bind fun a => (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x)
Proof (Lean source)
lemma measurable_doseOutcomeKernel {d : ℕ} (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) : Measurable fun x : Fin d → ℝ => (doseAMeasure q0).bind fun a => (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x) := by refine Measure.measurable_of_measurable_coe _ ?_ intro S hS rw [show (fun x : Fin d → ℝ => ((doseAMeasure q0).bind fun a => (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x)) S) = fun x => ∫⁻ a, ((twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x)) S ∂doseAMeasure q0 by funext x rw [Measure.bind_apply hS (measurable_twoPointMean_map_doseObs (d := d) B alpha t0 lambda h zeta x).aemeasurable]] haveI : SFinite (doseAMeasure q0) := by unfold doseAMeasure infer_instance exact Measurable.lintegral_prod_right' (measurable_twoPointMean_map_doseObs_pair (d := d) B alpha t0 lambda h zeta S hS)
CausalSmith.Stat.DoseResponseMinimax.measurable_doseOutcomeKernel · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:171

The joint treatment-covariate measure first samples covariates from their witness measure and then samples treatment from its witness measure.

Definition (Lean source)
noncomputable def doseAXMeasure {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) : Measure (ℝ × (Fin d → ℝ)) := (doseXMeasure p0).bind fun x => (doseAMeasure q0).map fun a => (a, x)

The witness data law samples covariates, then treatment, and then a two-point outcome distribution whose mean is the witness conditional mean.

Definition (Lean source)
noncomputable def doseDataMeasure {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) : Measure (DoseObs d) := (doseXMeasure p0).bind fun x => (doseAMeasure q0).bind fun a => (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta a x)).map (fun y => DoseObs.mk y a x)
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:210

The witness potential-outcome process returns the observed outcome at the realized treatment and otherwise returns the witness conditional mean at the queried treatment.

Definition (Lean source)
noncomputable def dosePotential {d : ℕ} (alpha t0 lambda h zeta : ℝ) : ℝ → DoseObs d → ℝ := fun a O => if O.A = a then O.Y else doseWitnessMu (d := d) alpha t0 lambda h zeta a O.X

The witness law packages the explicit data law, covariate law, conditional mean, treatment density, covariate density, and potential-outcome process into one model.

Definition (Lean source)
noncomputable def doseWitness {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) : DoseLaw d where dataMeasure := doseDataMeasure p0 q0 B alpha t0 lambda h zeta PX := doseXMeasure p0 mu := doseWitnessMu alpha t0 lambda h zeta pi := fun a _x => q0 a px := p0 pot := dosePotential alpha t0 lambda h zeta
theorem doseXMeasure_isProbabilityMeasure

If the covariate density is nonnegative on the cube and integrates to one there, then the witness covariate measure is a probability measure.

Formal statement
d :
(Fin d → ℝ) → ℝ
hp0_nonneg :
∀ x ∈ cube d, 0 ≤ p0 x
hp0_int :
(∫ x in cube d, p0 x) = 1
Proof (Lean source)
lemma doseXMeasure_isProbabilityMeasure {d : ℕ} {p0 : (Fin d → ℝ) → ℝ} (hp0_nonneg : ∀ x ∈ cube d, 0 ≤ p0 x) (hp0_int : (∫ x in cube d, p0 x) = 1) : IsProbabilityMeasure (doseXMeasure p0) := by unfold doseXMeasure refine restrict_withDensity_ofReal_isProbabilityMeasure (measurableSet_cube d) hp0_nonneg ?_ simpa using hp0_int
CausalSmith.Stat.DoseResponseMinimax.doseXMeasure_isProbabilityMeasure · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:241
theorem doseAMeasure_isProbabilityMeasure

If the treatment density is nonnegative and integrates to one on the unit interval, then the witness treatment measure is a probability measure.

Formal statement
q0 :
ℝ → ℝ
hq0_nonneg :
∀ a, 0 ≤ q0 a
hq0_int :
(∫ a in Icc (0 : ℝ) 1, q0 a) = 1
Proof (Lean source)
lemma doseAMeasure_isProbabilityMeasure {q0 : ℝ → ℝ} (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hq0_int : (∫ a in Icc (0 : ℝ) 1, q0 a) = 1) : IsProbabilityMeasure (doseAMeasure q0) := by unfold doseAMeasure refine restrict_withDensity_ofReal_isProbabilityMeasure measurableSet_Icc ?_ ?_ · intro a _ha exact hq0_nonneg a · simpa using hq0_int
CausalSmith.Stat.DoseResponseMinimax.doseAMeasure_isProbabilityMeasure · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Core.lean:252
Helpers.Witness.HolderAux 7 declarations
theorem zero_mem_cube

The all-zero covariate vector lies in the unit covariate cube in every dimension.

Formal statement
d :
(fun _ : Fin d => (0 : ℝ)) ∈ cube d
Proof (Lean source)
lemma zero_mem_cube {d : ℕ} : (fun _ : Fin d => (0 : ℝ)) ∈ cube d := by intro i; exact ⟨le_rfl, zero_le_one⟩
theorem center_mem_doseWindow

If the treatment-window radius is nonnegative, the window contains its center point.

Formal statement
t0 eps0 :
heps :
0 ≤ eps0
t0 ∈ doseWindow t0 eps0
Proof (Lean source)
lemma center_mem_doseWindow {t0 eps0 : ℝ} (heps : 0 ≤ eps0) : t0 ∈ doseWindow t0 eps0 := by constructor <;> linarith
CausalSmith.Stat.DoseResponseMinimax.center_mem_doseWindow · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/HolderAux.lean:26
theorem isCompact_cube

The unit covariate cube is compact in every finite dimension.

Formal statement
d :
Proof (Lean source)
lemma isCompact_cube (d : ℕ) : IsCompact (cube d) := by have hEq : cube d = Set.univ.pi (fun _ : Fin d => Icc (0 : ℝ) 1) := by ext x; simp [cube, Pi.le_def, forall_and] rw [hEq] exact isCompact_cube (ι := Fin d) 0 1
theorem volume_cube_lt_top

The unit covariate cube has finite Lebesgue volume in every finite dimension.

Formal statement
d :
volume (cube d) < ∞
Proof (Lean source)
lemma volume_cube_lt_top (d : ℕ) : volume (cube d) < ∞ := (isCompact_cube d).measure_lt_top
CausalSmith.Stat.DoseResponseMinimax.volume_cube_lt_top · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/HolderAux.lean:38
theorem HolderBall1D_mono_radius

A univariate function that belongs to a Hölder ball of a given radius also belongs to any larger-radius Hölder ball of the same smoothness order on the same set.

Formal statement
f :
ℝ → ℝ
order M M' :
S :
Set
h :
HolderBall1D f order M S
hMM :
M ≤ M'
HolderBall1D f order M' S
Proof (Lean source)
lemma HolderBall1D_mono_radius (f : ℝ → ℝ) {order M M' : ℝ} {S : Set ℝ} (h : HolderBall1D f order M S) (hMM : M ≤ M') : HolderBall1D f order M' S := by rcases h with ⟨hcont, hder, hhol⟩ refine ⟨hcont, fun j hj x hx => (hder j hj x hx).trans hMM, fun x hx y hy => ?_⟩ have hr : 0 ≤ |x - y| ^ (order - ((⌈order⌉₊ - 1 : ℕ) : ℝ)) := Real.rpow_nonneg (abs_nonneg _) _ exact (hhol x hx y hy).trans (mul_le_mul_of_nonneg_right hMM hr)
CausalSmith.Stat.DoseResponseMinimax.HolderBall1D_mono_radius · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/HolderAux.lean:42
theorem HolderBallND_mono_radius

A multivariate function that belongs to a Hölder ball of a given radius also belongs to any larger-radius Hölder ball of the same smoothness order on the same set.

Formal statement
d :
f :
(Fin d → ℝ) → ℝ
order M M' :
S :
Set (Fin d → ℝ)
h :
HolderBallND f order M S
hMM :
M ≤ M'
HolderBallND f order M' S
Proof (Lean source)
lemma HolderBallND_mono_radius {d : ℕ} (f : (Fin d → ℝ) → ℝ) {order M M' : ℝ} {S : Set (Fin d → ℝ)} (h : HolderBallND f order M S) (hMM : M ≤ M') : HolderBallND f order M' S := by rcases h with ⟨hcont, hder, hhol⟩ refine ⟨hcont, fun j hj x hx => (hder j hj x hx).trans hMM, fun x hx y hy => ?_⟩ have hr : 0 ≤ ‖x - y‖ ^ (order - ((⌈order⌉₊ - 1 : ℕ) : ℝ)) := Real.rpow_nonneg (norm_nonneg _) _ exact (hhol x hx y hy).trans (mul_le_mul_of_nonneg_right hMM hr)
CausalSmith.Stat.DoseResponseMinimax.HolderBallND_mono_radius · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/HolderAux.lean:52
theorem HolderBallND_const

A constant multivariate function belongs to a Hölder ball whenever the absolute size of the constant is at most the ball radius and the radius is nonnegative.

Formal statement
d :
c order M :
S :
Set (Fin d → ℝ)
hc :
|c| ≤ M
hM :
0 ≤ M
HolderBallND (fun _ : Fin d → ℝ => c) order M S
Proof (Lean source)
lemma HolderBallND_const {d : ℕ} (c order M : ℝ) (S : Set (Fin d → ℝ)) (hc : |c| ≤ M) (hM : 0 ≤ M) : HolderBallND (fun _ : Fin d → ℝ => c) order M S := by refine ⟨contDiffOn_const, fun j hj x hx => ?_, fun x hx y hy => ?_⟩ · cases j with | zero => simpa [norm_iteratedFDeriv_zero] using hc | succ j => simpa [iteratedFDeriv_succ_const] using hM · have hconst : iteratedFDeriv ℝ (⌈order⌉₊ - 1) (fun _ : Fin d → ℝ => c) x = iteratedFDeriv ℝ (⌈order⌉₊ - 1) (fun _ : Fin d → ℝ => c) y := by cases ⌈order⌉₊ - 1 with | zero => simp [iteratedFDeriv_zero_eq_comp] | succ k => simp [iteratedFDeriv_succ_const] rw [hconst, sub_self, norm_zero] exact mul_nonneg hM (Real.rpow_nonneg (norm_nonneg _) _)
CausalSmith.Stat.DoseResponseMinimax.HolderBallND_const · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/HolderAux.lean:63
Helpers.Witness.KL 4 declarations
theorem doseBump_sq_integral_le

Bump-support concentration: the doseAMeasure-integral of ψ((a−t_0)/h)² is at most 2(M−η_0)·h, because ψ is supported in (t_0−h, t_0+h) ⊆ window (for 0 < h ≤ ε_0) where the treatment density q0 is bounded by M−η_0.

Formal statement
q0 :
ℝ → ℝ
M eta0 t0 eps0 h :
hh :
0 < h
hhe :
h ≤ eps0
hwin :
doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1
hq0_nonneg :
∀ a, 0 ≤ q0 a
hq0_bd :
∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0
(∫ a, doseBump ((a - t0) / h) ^ 2 ∂(doseAMeasure q0)) ≤ 2 * (M - eta0) * h
Proof (Lean source)
lemma doseBump_sq_integral_le {q0 : ℝ → ℝ} {M eta0 t0 eps0 h : ℝ} (hh : 0 < h) (hhe : h ≤ eps0) (hwin : doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1) (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hq0_bd : ∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0) : (∫ a, doseBump ((a - t0) / h) ^ 2 ∂(doseAMeasure q0)) ≤ 2 * (M - eta0) * h := by classical have _hwin_used := hwin let f : ℝ → ℝ := fun a => doseBump ((a - t0) / h) ^ 2 have hMeta_nonneg := M_sub_eta0_nonneg_of_q0_window (q0 := q0) (M := M) (eta0 := eta0) (t0 := t0) (eps0 := eps0) (h := h) hh hhe hq0_nonneg hq0_bd have hR_nonneg : 0 ≤ 2 * (M - eta0) * h := by nlinarith by_cases hfint : Integrable f (doseAMeasure q0) · have hf_nonneg : ∀ᵐ a ∂(doseAMeasure q0), 0 ≤ f a := Filter.Eventually.of_forall fun a => sq_nonneg _ have hlin := doseBump_sq_lintegral_le (q0 := q0) (M := M) (eta0 := eta0) (t0 := t0) (eps0 := eps0) (h := h) hh hhe hq0_nonneg hq0_bd have hof : ofReal (∫ a, f a ∂(doseAMeasure q0)) ≤ ofReal (2 * (M - eta0) * h) := by rw [ofReal_integral_eq_lintegral_ofReal hfint hf_nonneg] exact hlin exact (ENNReal.ofReal_le_ofReal_iff hR_nonneg).mp hof · rw [show (∫ a, doseBump ((a - t0) / h) ^ 2 ∂(doseAMeasure q0)) = ∫ a, f a ∂(doseAMeasure q0) by rfl] rw [integral_undef hfint] exact hR_nonneg
CausalSmith.Stat.DoseResponseMinimax.doseBump_sq_integral_le · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/KL.lean:247
theorem doseWitness_kl_single_le

Single-observation KL budget: the joint KL between the two witness data laws is at most 16 λ² (M−η_0) / B² · h^{2α+1}. GENUINE and bump-driven (NONZERO): it is the (A,X)-integral of the per-fibre two-point-channel KL, not a Dirac collapse.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B M alpha lambda eta0 t0 eps0 h :
hB :
0 < B
halpha :
0 < alpha
hh :
0 < h
hhle :
h ≤ 1
hhe :
h ≤ eps0
hwin :
doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1
hp0_int :
(∫ x in cube d, p0 x) = 1
hlam_nonneg :
0 ≤ lambda
hlam_le :
lambda ≤ B / 2
hq0_nonneg :
∀ a, 0 ≤ q0 a
hq0_bd :
∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0
klDiv (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1)
ofReal (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1))
Proof (Lean source)
lemma doseWitness_kl_single_le {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B M alpha lambda eta0 t0 eps0 h : ℝ} (hB : 0 < B) (halpha : 0 < alpha) (hh : 0 < h) (hhle : h ≤ 1) (hhe : h ≤ eps0) (hwin : doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hp0_int : (∫ x in cube d, p0 x) = 1) (hlam_nonneg : 0 ≤ lambda) (hlam_le : lambda ≤ B / 2) (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hq0_bd : ∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0) : klDiv (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) ≤ ofReal (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1)) := by classical have _hp0_int_used := hp0_int let m : Measure (ℝ × (Fin d → ℝ)) := doseAXMeasure (d := d) p0 q0 let κ : Kernel (ℝ × (Fin d → ℝ)) (DoseObs d) := doseChannelAX (d := d) p0 q0 B alpha t0 lambda h (-1) let η : Kernel (ℝ × (Fin d → ℝ)) (DoseObs d) := doseChannelAX (d := d) p0 q0 B alpha t0 lambda h 1 let proj : DoseObs d → ℝ × (Fin d → ℝ) := fun O => (O.A, O.X) let K : ℝ := 8 * lambda ^ 2 * h ^ (2 * alpha) / B ^ 2 have hm_prob : IsProbabilityMeasure m := doseAXMeasure_isProbabilityMeasure (d := d) hpX hpA letI : IsProbabilityMeasure m := hm_prob have hmu_neg_B : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B := by intro a x exact doseWitnessMu_abs_le_B (d := d) (by norm_num) halpha hh hhle hlam_nonneg hlam_le hB a x have hmu_pos_B : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B := by intro a x exact doseWitnessMu_abs_le_B (d := d) (by norm_num) halpha hh hhle hlam_nonneg hlam_le hB a x have hmu_neg_half : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B / 2 := by intro a x exact doseWitnessMu_abs_le_half (d := d) (by norm_num) halpha hh hhle hlam_nonneg hlam_le a x have hmu_pos_half : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B / 2 := by intro a x exact doseWitnessMu_abs_le_half (d := d) (by norm_num) halpha hh hhle hlam_nonneg hlam_le a x letI : IsMarkovKernel κ := by dsimp [κ] exact instIsMarkovDoseChannelAX (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := -1) hB hmu_neg_B letI : IsMarkovKernel η := by dsimp [η] exact instIsMarkovDoseChannelAX (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := 1) hB hmu_pos_B have hproj : Measurable proj := measurable_doseObs_A.prod measurable_doseObs_X have hgraph : MeasurableSet {p : (ℝ × (Fin d → ℝ)) × DoseObs d | p.1 = proj p.2} := by exact measurableSet_eq_fun measurable_fst (hproj.comp measurable_snd) have hκ_fib : ∀ b, (κ b) {ω | proj ω = b}ᶜ = 0 := by intro b dsimp [κ, proj] simpa using doseChannelAX_fibre_support (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := -1) b have hη_fib : ∀ b, (η b) {ω | proj ω = b}ᶜ = 0 := by intro b dsimp [η, proj] simpa using doseChannelAX_fibre_support (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := 1) b have hκη : ∀ b, κ b ≪ η b := by intro b dsimp [κ, η] exact (twoPointMean_ac_of_half hB (hmu_neg_half b.1 b.2) (hmu_pos_half b.1 b.2)).map (measurable_doseObs_mk b.1 b.2) haveI : CountablyGenerated (DoseObs d) := by change @CountablyGenerated (DoseObs d) (comap (fun O : DoseObs d => (O.Y, O.A, O.X)) inferInstance) exact MeasurableSpace.CountablyGenerated.comap (fun O : DoseObs d => (O.Y, O.A, O.X)) haveI : CountableOrCountablyGenerated (ℝ × (Fin d → ℝ)) (DoseObs d) := ⟨Or.inr inferInstance⟩ have hchain : klDiv (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) = ∫⁻ b, klDiv (κ b) (η b) ∂m := by rw [doseDataMeasure_eq_AXbind, doseDataMeasure_eq_AXbind] exact klDiv_bind_eq_of_base_recording (m := m) (κ := κ) (η := η) (proj := proj) hproj hgraph (Filter.Eventually.of_forall hκ_fib) (Filter.Eventually.of_forall hη_fib) (Filter.Eventually.of_forall hκη) have hfiber_bound : ∀ b, klDiv (κ b) (η b) ≤ ofReal (K * doseBump ((b.1 - t0) / h) ^ 2) := by intro b let u : ℝ := doseWitnessMu (d := d) alpha t0 lambda h (-1) b.1 b.2 let v : ℝ := doseWitnessMu (d := d) alpha t0 lambda h 1 b.1 b.2 have hmap : klDiv (κ b) (η b) = klDiv (twoPointMean B u) (twoPointMean B v) := by dsimp [κ, η, u, v] haveI : IsProbabilityMeasure (twoPointMean B u) := twoPointMean_isProbabilityMeasure hB (hmu_neg_B b.1 b.2) haveI : IsProbabilityMeasure (twoPointMean B v) := twoPointMean_isProbabilityMeasure hB (hmu_pos_B b.1 b.2) exact klDiv_map_measurableEmbedding (measurableEmbedding_doseObs_mk (d := d) b.1 b.2) have hgap : 2 * (u - v) ^ 2 / B ^ 2 = K * doseBump ((b.1 - t0) / h) ^ 2 := by dsimp [u, v, K] rw [doseWitnessMu, doseWitnessMu] have hp : (h ^ alpha) ^ 2 = h ^ (2 * alpha) := by calc (h ^ alpha) ^ 2 = h ^ (alpha * 2) := (Real.rpow_mul_natCast hh.le alpha 2).symm _ = h ^ (2 * alpha) := by ring_nf rw [show ((-1 : ℝ) * lambda * h ^ alpha * doseBump ((b.1 - t0) / h)) - (1 * lambda * h ^ alpha * doseBump ((b.1 - t0) / h)) = -2 * lambda * h ^ alpha * doseBump ((b.1 - t0) / h) by ring] rw [show (-2 * lambda * h ^ alpha * doseBump ((b.1 - t0) / h)) ^ 2 = 4 * lambda ^ 2 * (h ^ alpha) ^ 2 * doseBump ((b.1 - t0) / h) ^ 2 by ring] rw [hp] ring calc klDiv (κ b) (η b) = klDiv (twoPointMean B u) (twoPointMean B v) := hmap _ ≤ ofReal (2 * (u - v) ^ 2 / B ^ 2) := by refine le_trans (bernoulli_mean_channel_kl B u v hB (hmu_neg_half b.1 b.2) (hmu_pos_half b.1 b.2)) (ENNReal.ofReal_le_ofReal ?_) rw [mul_div_assoc] have h0 : (0 : ℝ) ≤ (u - v) ^ 2 / B ^ 2 := by positivity linarith _ = ofReal (K * doseBump ((b.1 - t0) / h) ^ 2) := by rw [hgap] have hK_nonneg : 0 ≤ K := by dsimp [K] positivity have hbump_meas_A : Measurable fun a : ℝ => doseBump ((a - t0) / h) ^ 2 := by exact (measurable_doseBump.comp (by fun_prop : Measurable fun a : ℝ => (a - t0) / h)).pow_const 2 have hbump_meas_m : AEStronglyMeasurable (fun b : ℝ × (Fin d → ℝ) => doseBump ((b.1 - t0) / h) ^ 2) m := (hbump_meas_A.comp measurable_fst).aestronglyMeasurable have hKb_int : Integrable (fun b : ℝ × (Fin d → ℝ) => K * doseBump ((b.1 - t0) / h) ^ 2) m := by refine Integrable.of_bound (((hbump_meas_A.comp measurable_fst).const_mul K).aestronglyMeasurable) K ?_ refine Filter.Eventually.of_forall fun b => ?_ have hb : doseBump ((b.1 - t0) / h) ^ 2 ≤ 1 := by exact (sq_le_one_iff_abs_le_one _).mpr (doseBump_abs_le_one ((b.1 - t0) / h)) have hb0 : 0 ≤ doseBump ((b.1 - t0) / h) ^ 2 := sq_nonneg _ rw [Real.norm_of_nonneg (mul_nonneg hK_nonneg hb0)] nlinarith have hKb_nonneg : ∀ᵐ b ∂m, 0 ≤ K * doseBump ((b.1 - t0) / h) ^ 2 := Filter.Eventually.of_forall fun b => mul_nonneg hK_nonneg (sq_nonneg _) have hlin_K : (∫⁻ b, ofReal (K * doseBump ((b.1 - t0) / h) ^ 2) ∂m) = ofReal (∫ b, K * doseBump ((b.1 - t0) / h) ^ 2 ∂m) := by rw [ofReal_integral_eq_lintegral_ofReal hKb_int hKb_nonneg] have hbump_int_m : ∫ b, doseBump ((b.1 - t0) / h) ^ 2 ∂m = ∫ a, doseBump ((a - t0) / h) ^ 2 ∂(doseAMeasure q0) := by have hmapint := integral_map (μ := m) (φ := fun b : ℝ × (Fin d → ℝ) => b.1) (f := fun a : ℝ => doseBump ((a - t0) / h) ^ 2) measurable_fst.aemeasurable hbump_meas_A.aestronglyMeasurable rw [doseAXMeasure_map_fst (d := d) (p0 := p0) (q0 := q0) hpX] at hmapint exact hmapint.symm have hreal_int : ∫ b, K * doseBump ((b.1 - t0) / h) ^ 2 ∂m ≤ K * (2 * (M - eta0) * h) := by rw [integral_const_mul] rw [hbump_int_m] exact mul_le_mul_of_nonneg_left (doseBump_sq_integral_le (q0 := q0) (M := M) (eta0 := eta0) (t0 := t0) (eps0 := eps0) (h := h) hh hhe hwin hq0_nonneg hq0_bd) hK_nonneg calc klDiv (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) = ∫⁻ b, klDiv (κ b) (η b) ∂m := hchain _ ≤ ∫⁻ b, ofReal (K * doseBump ((b.1 - t0) / h) ^ 2) ∂m := lintegral_mono hfiber_bound _ = ofReal (∫ b, K * doseBump ((b.1 - t0) / h) ^ 2 ∂m) := hlin_K _ ≤ ofReal (K * (2 * (M - eta0) * h)) := ENNReal.ofReal_le_ofReal hreal_int _ = ofReal (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1)) := by congr 1 dsimp [K] have hp : h ^ (2 * alpha) * h = h ^ (2 * alpha + 1) := by calc h ^ (2 * alpha) * h = h ^ (2 * alpha) * h ^ (1 : ℝ) := by rw [Real.rpow_one] _ = h ^ (2 * alpha + 1) := by rw [← Real.rpow_add hh] rw [← hp] field_simp [ne_of_gt hB] ring
CausalSmith.Stat.DoseResponseMinimax.doseWitness_kl_single_le · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/KL.lean:279
theorem doseWitness_single_ac_and_int

The two single-observation witness laws are mutually absolutely continuous and have integrable log-likelihood ratio (each fibre channel has positive mass on both atoms {B,−B}, so the rn-derivative is bounded). These are the hypotheses of productKL_tensorization.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha lambda t0 h :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B / 2
hmu' :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B / 2
(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1) ≪ doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) ∧
(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1 ≪ doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) ∧
Integrable (llr (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1))
Proof (Lean source)
lemma doseWitness_single_ac_and_int {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha lambda t0 h : ℝ} (hB : 0 < B) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B / 2) (hmu' : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B / 2) : (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1) ≪ doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) ∧ (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1 ≪ doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) ∧ Integrable (llr (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) := by have hKL_neg_pos : klDiv (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) ≠ ∞ := doseWitness_kl_ne_top_of_half (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (lambda := lambda) (t0 := t0) (h := h) (zeta₁ := -1) (zeta₂ := 1) hB hpX hpA hmu' hmu have hKL_pos_neg : klDiv (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) ≠ ∞ := doseWitness_kl_ne_top_of_half (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (lambda := lambda) (t0 := t0) (h := h) (zeta₁ := 1) (zeta₂ := -1) hB hpX hpA hmu hmu' have hneg_pos := InformationTheory.klDiv_ne_top_iff.mp hKL_neg_pos have hpos_neg := InformationTheory.klDiv_ne_top_iff.mp hKL_pos_neg exact ⟨hneg_pos.1, hpos_neg.1, hneg_pos.2⟩
CausalSmith.Stat.DoseResponseMinimax.doseWitness_single_ac_and_int · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/KL.lean:604
theorem doseWitness_kl_nfold_le

n-fold KL budget via product tensorization: the KL between the n-fold product witness laws is at most n · (single-obs budget).

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B M alpha lambda eta0 t0 eps0 h :
n :
hB :
0 < B
halpha :
0 < alpha
hh :
0 < h
hhle :
h ≤ 1
hhe :
h ≤ eps0
hwin :
doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1
hp0_int :
(∫ x in cube d, p0 x) = 1
hlam_nonneg :
0 ≤ lambda
hlam_le :
lambda ≤ B / 2
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B / 2
hmu' :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B / 2
hq0_nonneg :
∀ a, 0 ≤ q0 a
hq0_bd :
∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0
klDiv (Measure.pi fun _ : Fin n => doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (Measure.pi fun _ : Fin n => doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1)
ofReal ((n : ℝ) * (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1)))
Proof (Lean source)
lemma doseWitness_kl_nfold_le {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B M alpha lambda eta0 t0 eps0 h : ℝ} (n : ℕ) (hB : 0 < B) (halpha : 0 < alpha) (hh : 0 < h) (hhle : h ≤ 1) (hhe : h ≤ eps0) (hwin : doseWindow t0 eps0 ⊆ Ioo (0 : ℝ) 1) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hp0_int : (∫ x in cube d, p0 x) = 1) (hlam_nonneg : 0 ≤ lambda) (hlam_le : lambda ≤ B / 2) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B / 2) (hmu' : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B / 2) (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hq0_bd : ∀ a ∈ doseWindow t0 eps0, q0 a ≤ M - eta0) : klDiv (Measure.pi fun _ : Fin n => doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (Measure.pi fun _ : Fin n => doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) ≤ ofReal ((n : ℝ) * (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1))) := by classical let μ : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1) let ν : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1 let C : ℝ := 16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1) have hmu_neg_B : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (-1 : ℝ) a x| ≤ B := by intro a x exact (hmu' a x).trans (by linarith [hB]) have hmu_pos_B : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h (1 : ℝ) a x| ≤ B := by intro a x exact (hmu a x).trans (by linarith [hB]) haveI : IsProbabilityMeasure μ := by dsimp [μ] exact doseDataMeasure_isProbabilityMeasure (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := -1) hB hpX hpA hmu_neg_B haveI : IsProbabilityMeasure ν := by dsimp [ν] exact doseDataMeasure_isProbabilityMeasure (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := 1) hB hpX hpA hmu_pos_B have hac_int := doseWitness_single_ac_and_int (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (lambda := lambda) (t0 := t0) (h := h) hB hpX hpA hmu hmu' have hac : μ ≪ ν := by simpa [μ, ν] using hac_int.1 have hac' : ν ≪ μ := by simpa [μ, ν] using hac_int.2.1 have hint : Integrable (llr μ ν) μ := by simpa [μ, ν] using hac_int.2.2 have htensor : (klDiv (Measure.pi fun _ : Fin n => μ) (Measure.pi fun _ : Fin n => ν)).toReal ≤ (n : ℝ) * (klDiv μ ν).toReal := (productKL_tensorization n μ ν hac hint).apply have hsingle : klDiv μ ν ≤ ofReal C := by dsimp [μ, ν, C] exact doseWitness_kl_single_le (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (lambda := lambda) (eta0 := eta0) (t0 := t0) (eps0 := eps0) (h := h) hB halpha hh hhle hhe hwin hpX hpA hp0_int hlam_nonneg hlam_le hq0_nonneg hq0_bd have hMeta_nonneg := M_sub_eta0_nonneg_of_q0_window (q0 := q0) (M := M) (eta0 := eta0) (t0 := t0) (eps0 := eps0) (h := h) hh hhe hq0_nonneg hq0_bd have hC_nonneg : 0 ≤ C := by dsimp [C] positivity have hsingle_toReal : (klDiv μ ν).toReal ≤ C := by have hmono := ENNReal.toReal_mono (by exact ENNReal.ofReal_ne_top) hsingle simpa [ENNReal.toReal_ofReal hC_nonneg] using hmono have hprod_toReal : (klDiv (Measure.pi fun _ : Fin n => μ) (Measure.pi fun _ : Fin n => ν)).toReal ≤ (n : ℝ) * C := by calc (klDiv (Measure.pi fun _ : Fin n => μ) (Measure.pi fun _ : Fin n => ν)).toReal ≤ (n : ℝ) * (klDiv μ ν).toReal := htensor _ ≤ (n : ℝ) * C := mul_le_mul_of_nonneg_left hsingle_toReal (Nat.cast_nonneg n) have hprod_ne_top : klDiv (Measure.pi fun _ : Fin n => μ) (Measure.pi fun _ : Fin n => ν) ≠ ∞ := by exact InformationTheory.klDiv_ne_top (pi_iid_absolutelyContinuous μ ν hac n) (pi_iid_llr_integrable μ ν hac hint n) calc klDiv (Measure.pi fun _ : Fin n => doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h (-1)) (Measure.pi fun _ : Fin n => doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h 1) = klDiv (Measure.pi fun _ : Fin n => μ) (Measure.pi fun _ : Fin n => ν) := by rfl _ = ofReal (klDiv (Measure.pi fun _ : Fin n => μ) (Measure.pi fun _ : Fin n => ν)).toReal := by exact (ENNReal.ofReal_toReal hprod_ne_top).symm _ ≤ ofReal ((n : ℝ) * C) := ENNReal.ofReal_le_ofReal hprod_toReal _ = ofReal ((n : ℝ) * (16 * lambda ^ 2 * (M - eta0) / B ^ 2 * h ^ (2 * alpha + 1))) := by rfl
CausalSmith.Stat.DoseResponseMinimax.doseWitness_kl_nfold_le · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/KL.lean:641
Helpers.Witness.Measure 6 declarations
theorem doseDataMeasure_isProbabilityMeasure

If the component laws are probability measures and the two-point means are bounded inside the outcome range, then the witness data law is a probability measure.

Formal statement
d :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
IsProbabilityMeasure (doseDataMeasure p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseDataMeasure_isProbabilityMeasure {d : ℕ} {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : IsProbabilityMeasure (doseDataMeasure p0 q0 B alpha t0 lambda h zeta) := by classical let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 let mu : ℝ → (Fin d → ℝ) → ℝ := doseWitnessMu alpha t0 lambda h zeta have hmapprob : ∀ x a, IsProbabilityMeasure ((twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x)) := by intro x a letI : IsProbabilityMeasure (twoPointMean B (mu a x)) := twoPointMean_isProbabilityMeasure hB (hmu a x) exact Measure.isProbabilityMeasure_map (measurable_doseObs_mk a x).aemeasurable have hmap : ∀ x, Measurable fun a : ℝ => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x) := by intro x simpa [mu] using measurable_twoPointMean_map_doseObs (d := d) B alpha t0 lambda h zeta x have hinner : ∀ x, IsProbabilityMeasure (mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x)) := by intro x letI : IsProbabilityMeasure mA := hpA exact isProbabilityMeasure_bind (hmap x).aemeasurable (Filter.Eventually.of_forall fun a => hmapprob x a) have hker : Measurable fun x => mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x) := by simpa [mu] using measurable_doseOutcomeKernel (d := d) q0 B alpha t0 lambda h zeta change IsProbabilityMeasure (mX.bind fun x => mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x)) letI : IsProbabilityMeasure mX := hpX exact isProbabilityMeasure_bind hker.aemeasurable (Filter.Eventually.of_forall fun x => hinner x)
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_isProbabilityMeasure · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Measure.lean:19
theorem doseDataMeasure_map_X

Under the valid two-point outcome construction, marginalizing the witness data law to covariates recovers the witness covariate measure.

Formal statement
d :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
(doseDataMeasure p0 q0 B alpha t0 lambda h zeta).map (fun O : DoseObs d => O.X)
Proof (Lean source)
lemma doseDataMeasure_map_X {d : ℕ} {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : (doseDataMeasure p0 q0 B alpha t0 lambda h zeta).map (fun O : DoseObs d => O.X) = doseXMeasure p0 := by classical let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 let mu : ℝ → (Fin d → ℝ) → ℝ := doseWitnessMu alpha t0 lambda h zeta have hκ1 : Measurable fun _x : Fin d → ℝ => mA := measurable_const have hp1 : ∀ _x : Fin d → ℝ, IsProbabilityMeasure mA := fun _ => hpA have hκ2 : Measurable fun p : (Fin d → ℝ) × ℝ => twoPointMean B (mu p.2 p.1) := by unfold mu doseWitnessMu fun_prop have hp2 : ∀ x a, IsProbabilityMeasure (twoPointMean B (mu a x)) := by intro x a exact twoPointMean_isProbabilityMeasure hB (hmu a x) have hg : ∀ (x : Fin d → ℝ) (a : ℝ), Measurable (fun y : ℝ => DoseObs.mk y a x) := by intro x a exact measurable_doseObs_mk a x have hmap : ∀ x, Measurable fun a : ℝ => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x) := by intro x simpa [mu] using measurable_twoPointMean_map_doseObs (d := d) B alpha t0 lambda h zeta x have hker : Measurable fun x => mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x) := by simpa [mu] using measurable_doseOutcomeKernel (d := d) q0 B alpha t0 lambda h zeta have h := map_bind_bind_map_proj (m := mX) (κ₁ := fun _x : Fin d → ℝ => mA) (κ₂ := fun x a => twoPointMean B (mu a x)) (g := fun x a y => DoseObs.mk y a x) (π := fun O : DoseObs d => O.X) hp1 hp2 hg hmap hker measurable_doseObs_X (by intro x a y; rfl) simpa [doseDataMeasure, mX, mA, mu] using h
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_map_X · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Measure.lean:65
theorem doseWitness_pxDens

Under the stated outcome and treatment-law assumptions, the witness covariate density is tied to the covariate marginal of the witness data law.

Formal statement
d :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
PxIsXDensity (doseWitness p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseWitness_pxDens {d : ℕ} {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : PxIsXDensity (doseWitness p0 q0 B alpha t0 lambda h zeta) := by unfold PxIsXDensity doseWitness doseXMeasure exact doseDataMeasure_map_X (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpA hmu
CausalSmith.Stat.DoseResponseMinimax.doseWitness_pxDens · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Measure.lean:109
theorem doseWitness_consistency

The witness potential-outcome process is consistent with the observed outcome at the realized treatment for every observation.

Formal statement
d :
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
Consistency (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseWitness_consistency {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) : Consistency (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) := by exact Filter.Eventually.of_forall fun O => by simp [doseWitness, dosePotential]
CausalSmith.Stat.DoseResponseMinimax.doseWitness_consistency · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Measure.lean:124
theorem doseDataMeasure_ae_Y_mem_Icc

If the two-point outcome support is contained in the target bound, then the witness data law almost surely has outcomes inside that bounded interval.

Formal statement
d :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B M alpha t0 lambda h zeta :
hBM :
|B| ≤ M
∀ᵐ O ∂doseDataMeasure p0 q0 B alpha t0 lambda h zeta, O.Y ∈ Icc (-M) M
Proof (Lean source)
lemma doseDataMeasure_ae_Y_mem_Icc {d : ℕ} {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B M alpha t0 lambda h zeta : ℝ} (hBM : |B| ≤ M) : ∀ᵐ O ∂doseDataMeasure p0 q0 B alpha t0 lambda h zeta, O.Y ∈ Icc (-M) M := by classical let Sbad : Set (DoseObs d) := {O | O.Y ∉ Icc (-M) M} have hSbad : MeasurableSet Sbad := by unfold Sbad exact measurable_doseObs_Y measurableSet_Icc.compl rw [ae_iff] change (doseDataMeasure p0 q0 B alpha t0 lambda h zeta) Sbad = 0 let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 let mu : ℝ → (Fin d → ℝ) → ℝ := doseWitnessMu alpha t0 lambda h zeta have hmap : ∀ x, Measurable fun a : ℝ => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x) := by intro x simpa [mu] using measurable_twoPointMean_map_doseObs (d := d) B alpha t0 lambda h zeta x have hker : Measurable fun x => mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x) := by simpa [mu] using measurable_doseOutcomeKernel (d := d) q0 B alpha t0 lambda h zeta have hinner_zero : ∀ x a, ((twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x)) Sbad = 0 := by intro x a rw [Measure.map_apply (measurable_doseObs_mk a x) hSbad] simpa [Sbad, twoPointMean] using twoPointMean_bad_support_zero (B := B) (M := M) (ofReal ((1 + mu a x / B) / 2)) (ofReal ((1 - mu a x / B) / 2)) hBM have hmid_zero : ∀ x, (mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x)) Sbad = 0 := by intro x rw [Measure.bind_apply hSbad (hmap x).aemeasurable] simp [hinner_zero x] unfold doseDataMeasure change (mX.bind fun x => mA.bind fun a => (twoPointMean B (mu a x)).map (fun y => DoseObs.mk y a x)) Sbad = 0 rw [Measure.bind_apply hSbad hker.aemeasurable] simp [hmid_zero]
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_ae_Y_mem_Icc · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Measure.lean:134
theorem doseWitness_bdd

If the two-point outcome support is contained in the target bound, then the witness law satisfies the bounded-outcome condition at that bound.

Formal statement
d :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B M alpha t0 lambda h zeta :
hBM :
|B| ≤ M
BoundedOutcome (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) M
Proof (Lean source)
lemma doseWitness_bdd {d : ℕ} {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B M alpha t0 lambda h zeta : ℝ} (hBM : |B| ≤ M) : BoundedOutcome (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) M := by simpa [BoundedOutcome, doseWitness] using (doseDataMeasure_ae_Y_mem_Icc (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hBM).mono (fun O hO => abs_le.mpr hO)
Helpers.Witness.Membership 4 declarations
theorem iidSample_nonempty

Generic existence of an i.i.d. sample with a prescribed probability law. Discharges the i.i.d.-sampling existential of IidSampling; this is exactly Causalean.Stat.HasIIDSample, which every probability measure satisfies.

Formal statement
∃ (Ω : Type) (mΩ : MeasurableSpace Ω) (μ : @Measure Ω mΩ),
Nonempty (@IIDSample Ω X mΩ _ μ P)
Proof (Lean source)
lemma iidSample_nonempty {X : Type} [MeasurableSpace X] (P : Measure X) [IsProbabilityMeasure P] : ∃ (Ω : Type) (mΩ : MeasurableSpace Ω) (μ : @Measure Ω mΩ), Nonempty (@IIDSample Ω X mΩ _ μ P) := hasIIDSample_of_isProbabilityMeasure P
CausalSmith.Stat.DoseResponseMinimax.iidSample_nonempty · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Membership.lean:26
theorem doseDataMeasure_ae_X_mem_cube

The genuine witness's data law puts the covariate X in the cube [0,1]^d a.s.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hp0_nonneg :
∀ x ∈ cube d, 0 ≤ p0 x
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
∀ᵐ O ∂(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta), O.X ∈ cube d
Proof (Lean source)
lemma doseDataMeasure_ae_X_mem_cube {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hp0_nonneg : ∀ x ∈ cube d, 0 ≤ p0 x) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : ∀ᵐ O ∂(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta), O.X ∈ cube d := by classical have _hp0_nonneg := hp0_nonneg let μ : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta let Sbad : Set (DoseObs d) := {O | O.X ∉ cube d} have hSbad : MeasurableSet Sbad := by dsimp [Sbad] exact (measurableSet_cube d).compl.preimage measurable_doseObs_X rw [ae_iff] change μ Sbad = 0 have hpre : Sbad = (fun O : DoseObs d => O.X) ⁻¹' (cube d)ᶜ := by rfl rw [hpre] rw [← Measure.map_apply measurable_doseObs_X (measurableSet_cube d).compl] rw [doseDataMeasure_map_X (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpA hmu] unfold doseXMeasure rw [withDensity_apply _ (measurableSet_cube d).compl] have hzero : (volume.restrict (cube d)) ((cube d)ᶜ) = 0 := by rw [Measure.restrict_apply (measurableSet_cube d).compl] simp exact setLIntegral_measure_zero ((cube d)ᶜ) (fun x => ofReal (p0 x)) hzero
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_ae_X_mem_cube · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Membership.lean:35
theorem doseDataMeasure_ae_A_mem_Icc

The genuine witness's data law puts the treatment A in [0,1] a.s.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hq0_nonneg :
∀ a, 0 ≤ q0 a
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
∀ᵐ O ∂(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta), O.A ∈ Icc (0 : ℝ) 1
Proof (Lean source)
lemma doseDataMeasure_ae_A_mem_Icc {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : ∀ᵐ O ∂(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta), O.A ∈ Icc (0 : ℝ) 1 := by classical have _hq0_nonneg := hq0_nonneg let μ : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta let Sbad : Set (DoseObs d) := {O | O.A ∉ Icc (0 : ℝ) 1} have hSbad : MeasurableSet Sbad := by dsimp [Sbad] exact measurableSet_Icc.compl.preimage measurable_doseObs_A rw [ae_iff] change μ Sbad = 0 have hpre : Sbad = (fun O : DoseObs d => O.A) ⁻¹' (Icc (0 : ℝ) 1)ᶜ := by rfl rw [hpre] rw [← Measure.map_apply measurable_doseObs_A measurableSet_Icc.compl] have hmapA : (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta).map (fun O : DoseObs d => O.A) = doseAMeasure q0 := by let mAX : Measure (ℝ × (Fin d → ℝ)) := doseAXMeasure (d := d) p0 q0 let κ : Kernel (ℝ × (Fin d → ℝ)) (DoseObs d) := doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta ext s hs have hsA : MeasurableSet ((fun O : DoseObs d => O.A) ⁻¹' s) := hs.preimage measurable_doseObs_A have hsfst : MeasurableSet ((fun p : ℝ × (Fin d → ℝ) => p.1) ⁻¹' s) := hs.preimage measurable_fst rw [Measure.map_apply measurable_doseObs_A hs] rw [doseDataMeasure_eq_AXbind] change (mAX.bind κ) ((fun O : DoseObs d => O.A) ⁻¹' s) = doseAMeasure q0 s rw [Measure.bind_apply hsA κ.measurable.aemeasurable] have hinner : (fun p : ℝ × (Fin d → ℝ) => κ p ((fun O : DoseObs d => O.A) ⁻¹' s)) = indicator ((fun p : ℝ × (Fin d → ℝ) => p.1) ⁻¹' s) (fun _ => (1 : ℝ≥0∞)) := by funext p rw [show κ p = (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)).map (fun y => DoseObs.mk y p.1 p.2) by rfl] rw [Measure.map_apply (measurable_doseObs_mk p.1 p.2) hsA] by_cases hp : p.1 ∈ s · have hpre : (fun y : ℝ => DoseObs.mk y p.1 p.2) ⁻¹' ((fun O : DoseObs d => O.A) ⁻¹' s) = univ := by ext y simp [hp] rw [hpre] haveI : IsProbabilityMeasure (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)) := twoPointMean_isProbabilityMeasure hB (hmu p.1 p.2) simp [indicator, hp] · have hpre : (fun y : ℝ => DoseObs.mk y p.1 p.2) ⁻¹' ((fun O : DoseObs d => O.A) ⁻¹' s) = ∅ := by ext y simp [hp] rw [hpre] simp [indicator, hp] rw [hinner, lintegral_indicator hsfst, lintegral_const] simp only [one_mul] rw [Measure.restrict_apply MeasurableSet.univ] simp only [Set.univ_inter] have hmapfst := doseAXMeasure_map_fst (d := d) (p0 := p0) (q0 := q0) hpX rw [← hmapfst, Measure.map_apply measurable_fst hs] rw [hmapA] unfold doseAMeasure rw [withDensity_apply _ measurableSet_Icc.compl] have hzero : (volume.restrict (Icc (0 : ℝ) 1)) ((Icc (0 : ℝ) 1)ᶜ) = 0 := by rw [Measure.restrict_apply measurableSet_Icc.compl] simp exact setLIntegral_measure_zero ((Icc (0 : ℝ) 1)ᶜ) (fun a => ofReal (q0 a)) hzero
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_ae_A_mem_Icc · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Membership.lean:66
theorem doseWitness_mem_class

The genuine two-point witness lies in the anisotropic Hölder dose-response class. Only the treatment regression is perturbed (by the bump), the slack baseline (p_0, q_0) is frozen, and the two semantic ties hold for the genuine joint law.

Formal statement
alpha beta s M c0 eps0 t0 eta0 B lambda h zeta :
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
heta :
0 < eta0
hB :
0 < B
hBM :
B ≤ M
hp0_nonneg :
∀ x ∈ cube d, 0 ≤ p0 x
hp0_int :
(∫ x in cube d, p0 x) = 1
hpxH :
HolderBallND p0 s (M - eta0) (cube d)
hpxbd :
∀ x ∈ cube d, p0 x ≤ M - eta0
hq0_nonneg :
∀ a, 0 ≤ q0 a
hq0_int :
(∫ a in Icc (0 : ℝ) 1, q0 a) = 1
hqH :
HolderBall1D q0 beta (M - eta0) (doseWindow t0 eps0)
hqpos :
∀ a ∈ doseWindow t0 eps0, c0 + eta0 ≤ q0 a
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
hMuHolder :
HolderBall1D (fun a => zeta * lambda * h ^ alpha * doseBump ((a - t0) / h)) alpha M (doseWindow t0 eps0)
:
zeta = -1 ∨ zeta = 1
hhpos :
0 < h
hhle :
h ≤ 1
HolderDoseClass d alpha beta s M c0 eps0 t0 (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseWitness_mem_class {alpha beta s M c0 eps0 t0 eta0 B lambda h zeta : ℝ} {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (heta : 0 < eta0) (hB : 0 < B) (hBM : B ≤ M) (hp0_nonneg : ∀ x ∈ cube d, 0 ≤ p0 x) (hp0_int : (∫ x in cube d, p0 x) = 1) (hpxH : HolderBallND p0 s (M - eta0) (cube d)) (hpxbd : ∀ x ∈ cube d, p0 x ≤ M - eta0) (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hq0_int : (∫ a in Icc (0 : ℝ) 1, q0 a) = 1) (hqH : HolderBall1D q0 beta (M - eta0) (doseWindow t0 eps0)) (hqpos : ∀ a ∈ doseWindow t0 eps0, c0 + eta0 ≤ q0 a) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) (hMuHolder : HolderBall1D (fun a => zeta * lambda * h ^ alpha * doseBump ((a - t0) / h)) alpha M (doseWindow t0 eps0)) (hζ : zeta = -1 ∨ zeta = 1) (hhpos : 0 < h) (hhle : h ≤ 1) : HolderDoseClass d alpha beta s M c0 eps0 t0 (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) := by classical rcases hreg with ⟨hα, hβ, hs, hM, hc0, ht0, heps, hinterior⟩ have _hζ := hζ have _hhpos := hhpos have _hhle := hhle have hpX : IsProbabilityMeasure (doseXMeasure p0) := doseXMeasure_isProbabilityMeasure (d := d) (p0 := p0) hp0_nonneg hp0_int have hpA : IsProbabilityMeasure (doseAMeasure q0) := doseAMeasure_isProbabilityMeasure (q0 := q0) hq0_nonneg hq0_int have hBMabs : |B| ≤ M := by rw [abs_of_pos hB] exact hBM refine { iid := ?_ consistency := doseWitness_consistency (d := d) p0 q0 B alpha t0 lambda h zeta ignorability := doseWitness_ignorability (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpX hpA hmu bdd := doseWitness_bdd (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hBMabs interior := hinterior positivity := ?_ muT := ?_ piT := ?_ muX := ?_ piX := ?_ pxH := ?_ muReg := doseWitness_muReg (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hBMabs hpX hpA hmu pxDens := doseWitness_pxDens (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpA hmu -- Genuinely-new obligation from the `PiIsCondTreatmentDensity` tie of -- `HolderDoseClass`: (i) the range conjunct `0 ≤ π_P` on `[0,1]×cube` (immediate -- from `hq0_nonneg`, since the witness `pi a x = q0 a ≥ 0`), and (ii) the joint -- `(A,X)` law factorizes as `q0(a)·p0(x)` (A drawn independently of X with density -- q0, so the conditional density of A given X is q0 = the witness `pi` field, and -- `px = p0`). Left to the proof loop as the single new gap. piCond := doseWitness_piCond (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hq0_nonneg hp0_int hq0_int hmu } · have hprob : IsProbabilityMeasure ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).dataMeasure) := by simpa [doseWitness] using doseDataMeasure_isProbabilityMeasure (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpX hpA hmu have hA : ∀ᵐ O ∂((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).dataMeasure), O.A ∈ Icc (0 : ℝ) 1 := by simpa [doseWitness] using doseDataMeasure_ae_A_mem_Icc (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hq0_nonneg hpX hmu have hX : ∀ᵐ O ∂((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).dataMeasure), O.X ∈ cube d := by simpa [doseWitness] using doseDataMeasure_ae_X_mem_cube (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hp0_nonneg hpA hmu letI : IsProbabilityMeasure ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).dataMeasure) := hprob exact ⟨hprob, hA, hX, iidSample_nonempty ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).dataMeasure)⟩ · intro a ha x hx have hle : c0 ≤ q0 a := by linarith [hqpos a ha, heta] simpa [doseWitness] using hle · intro x hx simpa [doseWitness, doseWitnessMu] using hMuHolder · intro x hx simpa [doseWitness] using HolderBall1D_mono_radius (fun a => q0 a) hqH (by linarith) · have hconst : (fun x : Fin d → ℝ => (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).mu t0 x) = fun _ => zeta * lambda * h ^ alpha := by funext x simp [doseWitness, doseWitnessMu, doseBump_zero] change HolderBallND (fun x : Fin d → ℝ => (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).mu t0 x) s M (cube d) rw [hconst] refine HolderBallND_const (d := d) (zeta * lambda * h ^ alpha) s M (cube d) ?_ hM.le have hmu0 := hmu t0 (fun _ : Fin d => (0 : ℝ)) have hz : |zeta * lambda * h ^ alpha| ≤ B := by simpa [doseWitnessMu, doseBump_zero] using hmu0 exact hz.trans hBM · have ht0win : t0 ∈ doseWindow t0 eps0 := center_mem_doseWindow heps.1.le have hq0_eta : |q0 t0| ≤ M - eta0 := by have hder := hqH.2.1 0 (by simp) t0 ht0win simpa using hder have hq0M : |q0 t0| ≤ M := hq0_eta.trans (by linarith) change HolderBallND (fun x : Fin d → ℝ => (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pi t0 x) s M (cube d) exact HolderBallND_const (d := d) (q0 t0) s M (cube d) hq0M hM.le · refine ⟨?_, ?_, ?_⟩ · exact HolderBallND_mono_radius p0 hpxH (by linarith) · intro x hx exact hp0_nonneg x hx · intro x hx exact (hpxbd x hx).trans (by linarith)
CausalSmith.Stat.DoseResponseMinimax.doseWitness_mem_class · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Membership.lean:147
Helpers.Witness.PiCond 4 declarations
theorem doseDataMeasure_map_AX

Under a valid two-point outcome construction, marginalizing the witness data law to treatment and covariates gives exactly the witness treatment-covariate measure.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta).map (fun O : DoseObs d => (O.A, O.X))
= doseAXMeasure (d := d) p0 q0
Proof (Lean source)
lemma doseDataMeasure_map_AX {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta).map (fun O : DoseObs d => (O.A, O.X)) = doseAXMeasure (d := d) p0 q0 := by classical let mAX : Measure (ℝ × (Fin d → ℝ)) := doseAXMeasure (d := d) p0 q0 let κ : Kernel (ℝ × (Fin d → ℝ)) (DoseObs d) := doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta let π : DoseObs d → ℝ × (Fin d → ℝ) := fun O => (O.A, O.X) have hπ : Measurable π := measurable_doseObs_A.prod measurable_doseObs_X ext s hs have hpre : MeasurableSet (π ⁻¹' s) := hs.preimage hπ rw [Measure.map_apply hπ hs] rw [doseDataMeasure_eq_AXbind] change (mAX.bind κ) (π ⁻¹' s) = mAX s rw [Measure.bind_apply hpre κ.measurable.aemeasurable] have hinner : (fun p : ℝ × (Fin d → ℝ) => κ p (π ⁻¹' s)) = indicator s (fun _ => (1 : ℝ≥0∞)) := by funext p rw [show κ p = (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)).map (fun y => DoseObs.mk y p.1 p.2) by rfl] rw [Measure.map_apply (measurable_doseObs_mk p.1 p.2) hpre] by_cases hp : p ∈ s · have hpre_univ : (fun y : ℝ => DoseObs.mk y p.1 p.2) ⁻¹' (π ⁻¹' s) = univ := by ext y simp [π, hp] rw [hpre_univ] haveI : IsProbabilityMeasure (twoPointMean B (doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2)) := twoPointMean_isProbabilityMeasure hB (hmu p.1 p.2) simp [indicator, hp] · have hpre_empty : (fun y : ℝ => DoseObs.mk y p.1 p.2) ⁻¹' (π ⁻¹' s) = ∅ := by ext y simp [π, hp] rw [hpre_empty] simp [indicator, hp] rw [hinner, lintegral_indicator hs, lintegral_const] simp only [one_mul] rw [Measure.restrict_apply MeasurableSet.univ] simp
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_map_AX · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/PiCond.lean:19
theorem doseAXMeasure_eq_prod

The witness treatment-covariate measure is the product of the treatment measure and the covariate measure.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
doseAXMeasure (d := d) p0 q0 = (doseAMeasure q0).prod (doseXMeasure p0)
Proof (Lean source)
lemma doseAXMeasure_eq_prod {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} : doseAXMeasure (d := d) p0 q0 = (doseAMeasure q0).prod (doseXMeasure p0) := by classical let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 haveI : SFinite mA := by dsimp [mA] unfold doseAMeasure infer_instance haveI : SFinite mX := by dsimp [mX] unfold doseXMeasure infer_instance ext s hs have hmap : Measurable fun x : Fin d → ℝ => mA.map fun a : ℝ => (a, x) := by exact Measurable.map_prodMk_right (μ := mA) unfold doseAXMeasure change (mX.bind (fun x => mA.map fun a : ℝ => (a, x))) s = mA.prod mX s rw [Measure.bind_apply hs hmap.aemeasurable] simp_rw [Measure.map_apply measurable_prodMk_right hs] exact (Measure.prod_apply_symm (μ := mA) (ν := mX) hs).symm
CausalSmith.Stat.DoseResponseMinimax.doseAXMeasure_eq_prod · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/PiCond.lean:69
theorem doseAXMeasure_density

If the treatment density is nonnegative and both component densities integrate to one, then the joint treatment-covariate measure has product density.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
hq0_nonneg :
∀ a, 0 ≤ q0 a
hp0_int :
(∫ x in cube d, p0 x) = 1
hq0_int :
(∫ a in Icc (0 : ℝ) 1, q0 a) = 1
doseAXMeasure (d := d) p0 q0
= ((volume.restrict (Icc (0 : ℝ) 1)).prod (volume.restrict (cube d))).withDensity (fun p => ofReal (q0 p.1 * p0 p.2))
Proof (Lean source)
lemma doseAXMeasure_density {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hp0_int : (∫ x in cube d, p0 x) = 1) (hq0_int : (∫ a in Icc (0 : ℝ) 1, q0 a) = 1) : doseAXMeasure (d := d) p0 q0 = ((volume.restrict (Icc (0 : ℝ) 1)).prod (volume.restrict (cube d))).withDensity (fun p => ofReal (q0 p.1 * p0 p.2)) := by classical rw [doseAXMeasure_eq_prod (d := d) (p0 := p0) (q0 := q0)] let μA : Measure ℝ := volume.restrict (Icc (0 : ℝ) 1) let μX : Measure (Fin d → ℝ) := volume.restrict (cube d) have hq_intg : Integrable q0 μA := by refine Integrable.of_integral_ne_zero ?_ intro hzero simp [μA, hzero] at hq0_int have hp_intg : Integrable p0 μX := by refine Integrable.of_integral_ne_zero ?_ intro hzero simp [μX, hzero] at hp0_int have hq_ae : AEMeasurable (fun a => ofReal (q0 a)) μA := hq_intg.aemeasurable.ennreal_ofReal have hp_ae : AEMeasurable (fun x => ofReal (p0 x)) μX := hp_intg.aemeasurable.ennreal_ofReal unfold doseAMeasure doseXMeasure change (μA.withDensity (fun a => ofReal (q0 a))).prod (μX.withDensity (fun x => ofReal (p0 x))) = (μA.prod μX).withDensity (fun p => ofReal (q0 p.1 * p0 p.2)) rw [prod_withDensity₀ hq_ae hp_ae] apply withDensity_congr_ae exact Filter.Eventually.of_forall fun p => by exact (ENNReal.ofReal_mul (hq0_nonneg p.1)).symm
CausalSmith.Stat.DoseResponseMinimax.doseAXMeasure_density · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/PiCond.lean:94
theorem doseWitness_piCond

Under the stated positivity, normalization, and bounded-mean assumptions, the witness treatment density is a valid conditional treatment density for the witness law.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hq0_nonneg :
∀ a, 0 ≤ q0 a
hp0_int :
(∫ x in cube d, p0 x) = 1
hq0_int :
(∫ a in Icc (0 : ℝ) 1, q0 a) = 1
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
PiIsCondTreatmentDensity (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseWitness_piCond {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hq0_nonneg : ∀ a, 0 ≤ q0 a) (hp0_int : (∫ x in cube d, p0 x) = 1) (hq0_int : (∫ a in Icc (0 : ℝ) 1, q0 a) = 1) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : PiIsCondTreatmentDensity (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) := by classical unfold PiIsCondTreatmentDensity doseWitness refine ⟨?_, ?_⟩ · intro a _ha _x _hx exact hq0_nonneg a · rw [doseDataMeasure_map_AX (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hmu] exact doseAXMeasure_density (d := d) (p0 := p0) (q0 := q0) hq0_nonneg hp0_int hq0_int
CausalSmith.Stat.DoseResponseMinimax.doseWitness_piCond · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/PiCond.lean:129
Helpers.Witness.Regression 4 declarations
theorem doseAXMeasure_map_fst

The A-marginal of the shared (A,X)-law is doseAMeasure q0.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
(doseAXMeasure (d := d) p0 q0).map (fun p => p.1) = doseAMeasure q0
Proof (Lean source)
lemma doseAXMeasure_map_fst {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} (hpX : IsProbabilityMeasure (doseXMeasure p0)) : (doseAXMeasure (d := d) p0 q0).map (fun p => p.1) = doseAMeasure q0 := by classical let mX : Measure (Fin d → ℝ) := doseXMeasure p0 let mA : Measure ℝ := doseAMeasure q0 haveI : SFinite mA := by dsimp [mA] unfold doseAMeasure infer_instance ext s hs have hpre : MeasurableSet ((fun p : ℝ × (Fin d → ℝ) => p.1) ⁻¹' s) := hs.preimage measurable_fst have hmap : Measurable fun x : Fin d → ℝ => mA.map fun a : ℝ => (a, x) := by exact Measurable.map_prodMk_right (μ := mA) rw [Measure.map_apply measurable_fst hs] unfold doseAXMeasure change (mX.bind (fun x => mA.map fun a : ℝ => (a, x))) ((fun p : ℝ × (Fin d → ℝ) => p.1) ⁻¹' s) = mA s rw [Measure.bind_apply hpre hmap.aemeasurable] have hinner : (fun x : Fin d → ℝ => (mA.map fun a : ℝ => (a, x)) ((fun p : ℝ × (Fin d → ℝ) => p.1) ⁻¹' s)) = fun _ => mA s := by funext x rw [Measure.map_apply measurable_prodMk_right hpre] rfl rw [hinner, lintegral_const] simp [mX, hpX.measure_univ]
CausalSmith.Stat.DoseResponseMinimax.doseAXMeasure_map_fst · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Regression.lean:25
theorem doseDataMeasure_A_singleton_null

The realized-treatment level is a.s. not equal to any fixed level a: the treatment has a Lebesgue density q0, so {O | O.A = a} is doseDataMeasure-null.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
a :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
(doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta) {O | O.A = a} = 0
Proof (Lean source)
lemma doseDataMeasure_A_singleton_null {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (a : ℝ) (hB : 0 < B) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : (doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta) {O | O.A = a} = 0 := by classical have _hpA_univ : (doseAMeasure q0) univ = 1 := hpA.measure_univ let μ : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta have hmapA := doseDataMeasure_map_A (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpX hmu have hpre : (fun O : DoseObs d => O.A) ⁻¹' ({a} : Set ℝ) = {O | O.A = a} := by ext O simp rw [← hpre] rw [← Measure.map_apply measurable_doseObs_A (measurableSet_singleton a)] rw [hmapA] exact doseAMeasure_singleton_null q0 a
CausalSmith.Stat.DoseResponseMinimax.doseDataMeasure_A_singleton_null · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Regression.lean:278
theorem doseWitness_muReg

Semantic tie 1 (genuine regression). Under the genuine joint law, the conditional mean of Y given (A,X) equals μ_ζ(A,X), because the outcome channel twoPointMean B (μ_ζ(a,x)) has mean exactly μ_ζ(a,x). This forbids the Dirac/ decoupled laundering: μ is the real regression of the data law.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B M alpha t0 lambda h zeta :
hB :
0 < B
hBM :
|B| ≤ M
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
MuIsRegression (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseWitness_muReg {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B M alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hBM : |B| ≤ M) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : MuIsRegression (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) := by classical let μ : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta let g : DoseObs d → ℝ := fun O => doseWitnessMu (d := d) alpha t0 lambda h zeta O.A O.X let mAXobs : MeasurableSpace (DoseObs d) := comap (fun O : DoseObs d => (O.A, O.X)) inferInstance haveI : IsProbabilityMeasure μ := doseDataMeasure_isProbabilityMeasure (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hpX hpA hmu have hmAX : mAXobs ≤ instMeasurableSpaceDoseObs := by dsimp [mAXobs] exact (measurable_doseObs_A.prodMk measurable_doseObs_X).comap_le have hYbd : ∀ᵐ O ∂μ, |O.Y| ≤ M := by simpa [μ] using (doseDataMeasure_ae_Y_mem_Icc (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hBM).mono (fun O hO => abs_le.mpr hO) have hYint : Integrable (fun O : DoseObs d => O.Y) μ := by exact @integrable_of_measurable_ae_bounded (DoseObs d) instMeasurableSpaceDoseObs μ inferInstance (fun O : DoseObs d => O.Y) measurable_doseObs_Y M hYbd have hg_meas_default : @Measurable (DoseObs d) ℝ instMeasurableSpaceDoseObs inferInstance g := by dsimp [g] exact (measurable_doseWitnessMu (d := d) alpha t0 lambda h zeta).comp (measurable_doseObs_A.prodMk measurable_doseObs_X) have hgInt : Integrable g μ := by refine @integrable_of_measurable_ae_bounded (DoseObs d) instMeasurableSpaceDoseObs μ inferInstance g hg_meas_default B ?_ exact Filter.Eventually.of_forall fun O => hmu O.A O.X have hg_int_finite : ∀ s : Set (DoseObs d), MeasurableSet[mAXobs] s → μ s < ∞ → IntegrableOn g s μ := by intro s _hs _hfin exact hgInt.integrableOn have hg_rel_meas : Measurable[mAXobs] g := by have hpair : Measurable[mAXobs] (fun O : DoseObs d => (O.A, O.X)) := Measurable.of_comap_le le_rfl have hr : Measurable fun p : ℝ × (Fin d → ℝ) => doseWitnessMu (d := d) alpha t0 lambda h zeta p.1 p.2 := measurable_doseWitnessMu (d := d) alpha t0 lambda h zeta exact hr.comp hpair have hgm : AEStronglyMeasurable[mAXobs] g μ := hg_rel_meas.aestronglyMeasurable have hg_eq : ∀ s : Set (DoseObs d), MeasurableSet[mAXobs] s → μ s < ∞ → ∫ x in s, g x ∂μ = ∫ x in s, x.Y ∂μ := by intro s hs _hfin rcases (MeasurableSpace.measurableSet_comap.mp hs) with ⟨T, hT, hTs⟩ have hpre := doseRegression_setIntegral_preimage_eq (d := d) (p0 := p0) (q0 := q0) (B := B) (M := M) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) hB hBM hpX hpA hmu T hT rw [← hTs] simpa [μ, g] using hpre unfold MuIsRegression doseWitness change μ[(fun O : DoseObs d => O.Y) | mAXobs] =ᵐ[μ] g exact (ae_eq_condExp_of_forall_setIntegral_eq hmAX hYint hg_int_finite hg_eq hgm).symm
theorem doseWitness_ignorability

Semantic tie 2 (ignorability). The potential outcome Y(a) equals the regression mean μ_ζ(a,X) almost surely (the realized A hits the fixed level a only on a q0-null set), so Y(a) is X-measurable and Y(a) ⟂ A | X.

Formal statement
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hB :
0 < B
hmu :
∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B
NoUnmeasuredConfounding (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta)
Proof (Lean source)
lemma doseWitness_ignorability {p0 : (Fin d → ℝ) → ℝ} {q0 : ℝ → ℝ} {B alpha t0 lambda h zeta : ℝ} (hB : 0 < B) (hpX : IsProbabilityMeasure (doseXMeasure p0)) (hpA : IsProbabilityMeasure (doseAMeasure q0)) (hmu : ∀ a x, |doseWitnessMu (d := d) alpha t0 lambda h zeta a x| ≤ B) : NoUnmeasuredConfounding (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) := by classical intro a _ha have hpot_meas : Measurable (dosePotential (d := d) alpha t0 lambda h zeta a) := by unfold dosePotential refine Measurable.ite (measurableSet_eq_fun (measurable_doseObs_A (d := d)) measurable_const) measurable_doseObs_Y ?_ unfold doseWitnessMu fun_prop refine ⟨hpot_meas, ?_⟩ intro f hf hfb rcases hfb with ⟨Mf, hMf⟩ let μ : Measure (DoseObs d) := doseDataMeasure (d := d) p0 q0 B alpha t0 lambda h zeta let u : DoseObs d → ℝ := fun O => f (doseWitnessMu (d := d) alpha t0 lambda h zeta a O.X) haveI : IsProbabilityMeasure μ := by let mAX : Measure (ℝ × (Fin d → ℝ)) := doseAXMeasure (d := d) p0 q0 let κ : Kernel (ℝ × (Fin d → ℝ)) (DoseObs d) := doseChannelAX (d := d) p0 q0 B alpha t0 lambda h zeta haveI : IsProbabilityMeasure mAX := doseAXMeasure_isProbabilityMeasure (d := d) hpX hpA haveI : IsMarkovKernel κ := instIsMarkovDoseChannelAX (d := d) hB hmu dsimp [μ] rw [doseDataMeasure_eq_AXbind] change IsProbabilityMeasure (mAX.bind κ) exact isProbabilityMeasure_bind κ.measurable.aemeasurable (Filter.Eventually.of_forall fun p => by infer_instance) let mAXobs : MeasurableSpace (DoseObs d) := comap (fun O : DoseObs d => (O.A, O.X)) inferInstance let mXobs : MeasurableSpace (DoseObs d) := comap (fun O : DoseObs d => O.X) inferInstance have hmAX : mAXobs ≤ instMeasurableSpaceDoseObs := by dsimp [mAXobs] exact (measurable_doseObs_A.prod measurable_doseObs_X).comap_le have hmX : mXobs ≤ instMeasurableSpaceDoseObs := by dsimp [mXobs] exact measurable_doseObs_X.comap_le have hu_meas_X : Measurable[mXobs] u := by have hX : Measurable[mXobs] (fun O : DoseObs d => O.X) := Measurable.of_comap_le le_rfl have hr : Measurable fun x : Fin d → ℝ => f (doseWitnessMu (d := d) alpha t0 lambda h zeta a x) := by unfold doseWitnessMu fun_prop exact hr.comp hX have hu_meas_AX : Measurable[mAXobs] u := by have hpair : Measurable[mAXobs] (fun O : DoseObs d => (O.A, O.X)) := Measurable.of_comap_le le_rfl have hr : Measurable fun p : ℝ × (Fin d → ℝ) => f (doseWitnessMu (d := d) alpha t0 lambda h zeta a p.2) := by unfold doseWitnessMu fun_prop exact hr.comp hpair have hu_meas_default : @Measurable (DoseObs d) ℝ instMeasurableSpaceDoseObs inferInstance u := by have hmu_a : @Measurable (DoseObs d) ℝ instMeasurableSpaceDoseObs inferInstance (fun O : DoseObs d => doseWitnessMu (d := d) alpha t0 lambda h zeta a O.X) := by unfold doseWitnessMu fun_prop exact hf.comp hmu_a have hu_int : Integrable u μ := by exact @integrable_of_measurable_ae_bounded (DoseObs d) instMeasurableSpaceDoseObs μ inferInstance u hu_meas_default (max Mf 0) (Filter.Eventually.of_forall fun O => (hMf _).trans (le_max_left Mf 0)) have huAX : AEStronglyMeasurable[mAXobs] u μ := hu_meas_AX.aestronglyMeasurable have huX : AEStronglyMeasurable[mXobs] u μ := hu_meas_X.aestronglyMeasurable have hnull := doseDataMeasure_A_singleton_null (d := d) (p0 := p0) (q0 := q0) (B := B) (alpha := alpha) (t0 := t0) (lambda := lambda) (h := h) (zeta := zeta) a hB hpX hpA hmu have hAne : ∀ᵐ O ∂μ, O.A ≠ a := by rw [ae_iff] simpa [μ] using hnull have hpot_eq : (fun O : DoseObs d => f ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pot a O)) =ᵐ[μ] u := by filter_upwards [hAne] with O hO simp [doseWitness, dosePotential, u, hO] have hpot_int : Integrable (fun O : DoseObs d => f ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pot a O)) μ := by exact hu_int.congr hpot_eq.symm refine ⟨hpot_int, ?_⟩ change μ[(fun O : DoseObs d => f ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pot a O)) | mAXobs] =ᵐ[μ] μ[(fun O : DoseObs d => f ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pot a O)) | mXobs] calc μ[(fun O : DoseObs d => f ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pot a O)) | mAXobs] =ᵐ[μ] μ[u | mAXobs] := condExp_congr_ae hpot_eq _ =ᵐ[μ] u := condExp_of_aestronglyMeasurable' hmAX huAX hu_int _ =ᵐ[μ] μ[u | mXobs] := (condExp_of_aestronglyMeasurable' hmX huX hu_int).symm _ =ᵐ[μ] μ[(fun O : DoseObs d => f ((doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta).pot a O)) | mXobs] := (condExp_congr_ae hpot_eq).symm
CausalSmith.Stat.DoseResponseMinimax.doseWitness_ignorability · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Regression.lean:372
Helpers.Witness.Theta 2 declarations
theorem doseWitness_theta

For a normalized covariate density, the witness target value at the center treatment equals the signed bump amplitude.

Formal statement
d :
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h zeta :
hp0_int :
(∫ x in cube d, p0 x) = 1
thetaFunctional (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) t0
= zeta * lambda * h ^ alpha
Proof (Lean source)
lemma doseWitness_theta {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h zeta : ℝ) (hp0_int : (∫ x in cube d, p0 x) = 1) : thetaFunctional (doseWitness (d := d) p0 q0 B alpha t0 lambda h zeta) t0 = zeta * lambda * h ^ alpha := by rw [thetaFunctional] change (∫ x in cube d, (zeta * lambda * h ^ alpha * doseBump ((t0 - t0) / h)) * p0 x) = zeta * lambda * h ^ alpha simp only [sub_self, zero_div, doseBump_zero, mul_one] rw [integral_const_mul, hp0_int, mul_one]
CausalSmith.Stat.DoseResponseMinimax.doseWitness_theta · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Theta.lean:17
theorem doseWitness_theta_sep

For a normalized covariate density, the separation between the positive and negative witness target values is twice the bump amplitude without the sign.

Formal statement
d :
p0 :
(Fin d → ℝ) → ℝ
q0 :
ℝ → ℝ
B alpha t0 lambda h :
hp0_int :
(∫ x in cube d, p0 x) = 1
thetaFunctional (doseWitness (d := d) p0 q0 B alpha t0 lambda h 1) t0
- thetaFunctional (doseWitness (d := d) p0 q0 B alpha t0 lambda h (-1)) t0
= 2 * lambda * h ^ alpha
Proof (Lean source)
lemma doseWitness_theta_sep {d : ℕ} (p0 : (Fin d → ℝ) → ℝ) (q0 : ℝ → ℝ) (B alpha t0 lambda h : ℝ) (hp0_int : (∫ x in cube d, p0 x) = 1) : thetaFunctional (doseWitness (d := d) p0 q0 B alpha t0 lambda h 1) t0 - thetaFunctional (doseWitness (d := d) p0 q0 B alpha t0 lambda h (-1)) t0 = 2 * lambda * h ^ alpha := by rw [doseWitness_theta (d := d) p0 q0 B alpha t0 lambda h 1 hp0_int, doseWitness_theta (d := d) p0 q0 B alpha t0 lambda h (-1) hp0_int] ring
CausalSmith.Stat.DoseResponseMinimax.doseWitness_theta_sep · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/Helpers/Witness/Theta.lean:32
T_CertifiedPartialBetaFrontier 1 declarations
theorem certifiedPartialBetaFrontier

Under baseline-submodel slack, every fixed beta > 0 has the oracle lower floor eventually. In the smooth-covariate regime the floor matches the published rho_n exponent; in the deficient regime the published comparator has a strictly smaller exponent and no same-class upper endpoint is asserted.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ c : ℝ,
0 < c ∧
(∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0) ∧
(∀ n : ℕ, 1 ≤ n → ((d : ℝ) ≤ 4 * s → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))) ∧ (4 * s < (d : ℝ) → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1)))
Proof (Lean source)
theorem certifiedPartialBetaFrontier {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ c : ℝ, 0 < c ∧ (∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0) ∧ (∀ n : ℕ, 1 ≤ n → ((d : ℝ) ≤ 4 * s → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))) ∧ (4 * s < (d : ℝ) → publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1))) := by exact certified_beta_frontier_bracket alpha beta s M c0 eps0 t0 halpha hbeta hs hreg hslack
CausalSmith.Stat.DoseResponseMinimax.certifiedPartialBetaFrontier · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/T_CertifiedPartialBetaFrontier.lean:18
T_FrontierBracketDeficient 1 declarations
theorem frontier_bracket_deficient Theorem 3 in the paper ↗

Certified deficient-covariate regime theorem. Assume the strict-slack baseline. For every β > 0 and every 0 < s < d/4 (4s < d) there is c > 0 such that, for all sufficiently large n, R_n ≥ c n^{-2α/(2α+1)}, while ρ_n = n^{-2/(1+d/(4s)+1/α)} has a strictly smaller exponent. The same-class upper endpoint C ρ_n is NOT discharged.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hsd :
4 * s < (d : ℝ)
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))
minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ∧
publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧
2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1)
Proof (Lean source)
theorem frontier_bracket_deficient {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hsd : 4 * s < (d : ℝ)) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ∧ publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha))) ∧ 2 / (1 + (d : ℝ) / (4 * s) + 1 / alpha) < 2 * alpha / (2 * alpha + 1) := by rcases oracle_dose_regression_lower_all_beta alpha beta s M c0 eps0 t0 halpha hbeta hs hreg hslack with ⟨c, hc, hfloor⟩ refine ⟨c, hc, ?_⟩ filter_upwards [hfloor, Filter.eventually_ge_atTop (1 : ℕ)] with n hn hge rcases rho_deficient_regime_algebra n alpha s d halpha hs hsd hge with ⟨hrho, hexp⟩ exact ⟨hn, hrho, hexp⟩
CausalSmith.Stat.DoseResponseMinimax.frontier_bracket_deficient · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/T_FrontierBracketDeficient.lean:19
T_OracleRegimeReduction 1 declarations
theorem oracle_regime_reduction Proposition 1 in the paper ↗

Oracle regime reduction. Under the assumptions of sharp_pointwise_lower_bound, if s ≥ d/4 (d ≤ 4s) then ρ_n = n^{-2α/(2α+1)} and hence R_n ≥ c n^{-2α/(2α+1)} = c ρ_n for some c > 0. The certified lower floor reduces to the classical interior pointwise nonparametric regression barrier.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hsd :
(d : ℝ) ≤ 4 * s
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ∧
c * publishedHoifRate n alpha s d
minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0
Proof (Lean source)
theorem oracle_regime_reduction {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hsd : (d : ℝ) ≤ 4 * s) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, publishedHoifRate n alpha s d = (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ∧ c * publishedHoifRate n alpha s d ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 := by rcases sharp_pointwise_lower_bound alpha beta s M c0 eps0 t0 halpha hbeta hs hreg hslack with ⟨c, hc, hfloor⟩ refine ⟨c, hc, ?_⟩ filter_upwards [hfloor, Filter.eventually_ge_atTop (1 : ℕ)] with n hn hge have hrho := rho_oracle_regime_algebra n alpha s d halpha hs hsd hge constructor · exact hrho · rw [hrho] exact hn
CausalSmith.Stat.DoseResponseMinimax.oracle_regime_reduction · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/T_OracleRegimeReduction.lean:20
T_SharpMinimaxSmoothCovariate 1 declarations
theorem sharp_minimax_smooth_covariate Theorem 2 in the paper ↗

Certified smooth-covariate regime theorem. Assume the strict-slack baseline. For every β > 0 and every s ≥ d/4 (d ≤ 4s) there is c > 0 such that, for all sufficiently large n, R_n ≥ c n^{-2α/(2α+1)} = c ρ_n. The certified lower floor lands on the same exponent as ρ_n; NO same-class upper bound is claimed.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hsd :
(d : ℝ) ≤ 4 * s
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))
minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ∧
(n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) = publishedHoifRate n alpha s d
Proof (Lean source)
theorem sharp_minimax_smooth_covariate {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hsd : (d : ℝ) ≤ 4 * s) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 ∧ (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) = publishedHoifRate n alpha s d := by rcases sharp_pointwise_lower_bound alpha beta s M c0 eps0 t0 halpha hbeta hs hreg hslack with ⟨c, hc, hfloor⟩ refine ⟨c, hc, ?_⟩ filter_upwards [hfloor, Filter.eventually_ge_atTop (1 : ℕ)] with n hn hge have hrho := rho_oracle_regime_algebra n alpha s d halpha hs hsd hge exact ⟨hn, hrho.symm⟩
CausalSmith.Stat.DoseResponseMinimax.sharp_minimax_smooth_covariate · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/T_SharpMinimaxSmoothCovariate.lean:19
T_SharpPointwiseLowerBound 1 declarations
theorem sharp_pointwise_lower_bound Theorem 1 in the paper ↗

Certified kernel converse. Assume the strict-slack baseline. For every β > 0 there is c > 0, depending only on the fixed model radii and the slack baseline, such that for all sufficiently large n, R_n(P_{α,β,s}(M,c_0,ε_0,t_0), t_0) ≥ c n^{-2α/(2α+1)} — the classical interior treatment-regression pointwise rate, uniformly over every β > 0.

Formal statement
d :
alpha beta s M c0 eps0 t0 :
halpha :
0 < alpha
hbeta :
0 < beta
hs :
0 < s
hreg :
RegimeConstants alpha beta s M c0 eps0 t0
hslack :
BaselineSubmodelSlack d beta s M c0 eps0 t0
∃ c : ℝ,
0 < c ∧
∀ᶠ n : ℕ in atTop,
c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1)))
minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0
Proof (Lean source)
theorem sharp_pointwise_lower_bound {d : ℕ} (alpha beta s M c0 eps0 t0 : ℝ) (halpha : 0 < alpha) (hbeta : 0 < beta) (hs : 0 < s) (hreg : RegimeConstants alpha beta s M c0 eps0 t0) (hslack : BaselineSubmodelSlack d beta s M c0 eps0 t0) : ∃ c : ℝ, 0 < c ∧ ∀ᶠ n : ℕ in atTop, c * (n : ℝ) ^ (-(2 * alpha / (2 * alpha + 1))) ≤ minimaxRisk M n (HolderDoseClass d alpha beta s M c0 eps0 t0) t0 := by exact oracle_dose_regression_lower_all_beta alpha beta s M c0 eps0 t0 halpha hbeta hs hreg hslack
CausalSmith.Stat.DoseResponseMinimax.sharp_pointwise_lower_bound · CausalSmith/Stat/STAT_DoseResponseMinimax_Research/T_SharpPointwiseLowerBound.lean:19