PO.ID.Partial.Sensitivity.MSM
Marginal Sensitivity Model bounds: treated/control-arm feasible weights, cutoff construction, calibrated sharp upper and lower bounds, and ATE interval assembly.
Setup 11 core · 6 supporting This file sets up the Marginal Sensitivity Model of Tan (2006) / Zhao–Small–Bhattacharya (2019) over the potential-outcome backdoor system POBackdoorSystem. ★ candMean_completeProp_eq_Y1mean★ Y1mean_mem_Icc★ MSMSet_one_eq
Marginal Sensitivity Model (MSM) for the treated mean E[Y(1)]
This file sets up the Marginal Sensitivity Model of Tan (2006) / Zhao–Small–Bhattacharya
(2019) over the potential-outcome backdoor system POBackdoorSystem.
Unconfoundedness identifies E[Y(1)] by inverse-probability weighting against the
observed propensity score e(X) = P[D=1 | σ(X)]. The MSM relaxes unconfoundedness
by allowing the complete propensity e₀(X, Y(1)) = P[D=1 | σ(X, Y(1))] to differ
from e(X), with the discrepancy controlled by a sensitivity parameter Λ ≥ 1
through the odds ratio:
1/Λ ≤ OR(e₀(X, Y(1)), e(X)) ≤ Λ.
The MSM ambiguity set MSMSet Λ collects all candidate complete propensities
satisfying this odds-ratio bound (and a.e. interiority 0 < · < 1). The candidate
IPW mean candMean ẽ = E[A·Y/ẽ] traced over this uncalibrated ZSB ambiguity set
produces the valid interval [msmLower Λ, msmUpper Λ], which contains the estimand
E[Y(1)]. The calibrated Dorn-Guo sharp set is formalized separately.
This file states the definitions and the structural theorems (IPW/tower bridge,
membership of the truth, the interval bound, monotonicity in Λ, and the Λ = 1
point-identification collapse).
def OR reviewed
⚑ flagged
Causalean.PO
For a first real number and a second real number, the odds ratio is the first number's odds divided by the second number's odds, .
Definition (Lean source)
parameters
p₁ p₂ :
ℝ
def
OR p₁ p₂ :
ℝ
given by
(p₁ / (1 - p₁)) / (p₂ / (1 - p₂))
def sigmaXY1 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system, the complete-information σ-algebra is the σ-algebra on the sample space generated jointly by the factual covariate and the potential outcome under treatment.
Definition (Lean source)
parameters
def
given by
def completeProp reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system, the complete propensity assigns each unit the conditional probability of treatment given the factual covariate and treated potential outcome.
Definition (Lean source)
def candMean reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a candidate complete-propensity function, the candidate inverse-probability-weighted mean is the population mean of the treated-arm indicator times factual outcome divided by that candidate function.
Definition (Lean source)
parameters
def
candMean S etilde :
ℝ
given by
∫ ω, S.dVar.indicator true ω * S.factualY ω / etilde ω ∂P.μ
def Y1mean reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system, the treated potential-outcome mean is the population mean of the potential outcome under treatment.
Definition (Lean source)
def MSMSet reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a sensitivity level, the MSM ambiguity set contains exactly the candidate complete-propensity functions that are almost surely strictly between zero and one and whose odds ratio relative to the observed propensity is almost surely between the reciprocal of the sensitivity level and the sensitivity level.
Definition (Lean source)
def msmUpper reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a sensitivity level, the MSM upper bound is the supremum of candidate inverse-probability-weighted means over the MSM ambiguity set at that level.
Definition (Lean source)
def msmLower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a sensitivity level, the MSM lower bound is the infimum of candidate inverse-probability-weighted means over the MSM ambiguity set at that level.
Definition (Lean source)
theorem candMean_completeProp_eq_Y1mean reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
IPW / tower bridge. Assuming potential and observed outcomes agree under the realized treatment (consistency), the true complete propensity e₀ = P[D=1 | σ(X, Y(1))] is positive almost surely, the treated potential outcome Y(1) is integrable, and the inverse-propensity-weighted candidate A·Y/e₀ is integrable, then evaluated at the true complete propensity, the candidate IPW mean recovers the estimand: candMean e₀ = E[A · Y / e₀] = E[Y(1)].
Formal statement
hypotheses
γ :
Type u_1
IsFiniteMeasure P.μ
hcons :
P.Consistency
hpos :
∀ᵐ ω ∂P.μ, 0 < S.completeProp ω
hint :
Integrable (S.YofD true) P.μ
hcand_int :
Integrable (fun ω => S.dVar.indicator true ω * S.factualY ω / S.completeProp ω) P.μ
conclusion
S.candMean S.completeProp = S.Y1mean
Proof (Lean source)
theorem candMean_completeProp_eq_Y1mean
[StandardBorelSpace P.Ω] [IsFiniteMeasure P.μ]
(hcons : P.Consistency)
(hpos : ∀ᵐ ω ∂P.μ, 0 < S.completeProp ω)
(hint : Integrable (S.YofD true) P.μ)
(hcand_int :
Integrable
(fun ω => S.dVar.indicator true ω * S.factualY ω / S.completeProp ω) P.μ) :
S.candMean S.completeProp = S.Y1mean := by
classical
-- Abbreviations.
set f : P.Ω → ℝ := S.dVar.indicator true with hf_def
set e : P.Ω → ℝ := S.completeProp with he_def
set g : P.Ω → ℝ := fun ω => S.YofD true ω / e ω with hg_def
-- (1) Consistency: `f ω * factualY ω = f ω * YofD true ω` pointwise.
have hcons_fn :
(fun ω => S.factualY ω * f ω) = (fun ω => S.YofD true ω * f ω) := by
have h := POVar.factual_mul_indicator_eq_cfUnder_mul_indicator_fn
hcons S.yVar S.dVar true (Ne.symm S.hDY)
funext ω
have := congr_fun h ω
simpa [POBackdoorSystem.YofD, POBackdoorSystem.factualY, hf_def] using this
-- `candMean e = ∫ g ω * f ω`.
have hcandMean_eq : S.candMean e = ∫ ω, g ω * f ω ∂P.μ := by
unfold POBackdoorSystem.candMean
refine integral_congr_ae (Filter.Eventually.of_forall ?_)
intro ω
have hcw : S.factualY ω * f ω = S.YofD true ω * f ω := congr_fun hcons_fn ω
-- `f ω * factualY ω / e ω = (YofD true ω / e ω) * f ω`.
simp only [hg_def, hf_def] at hcw ⊢
rw [div_eq_mul_inv, div_eq_mul_inv]
linear_combination (e ω)⁻¹ * hcw
-- (2) `g` is `sigmaXY1`-strongly measurable.
have hY1_meas : Measurable[S.sigmaXY1] (S.YofD true) := by
have hle : comap (S.YofD true) inferInstance ≤ S.sigmaXY1 :=
le_sup_right
exact (comap_measurable (S.YofD true)).mono hle le_rfl
have he_smeas : StronglyMeasurable[S.sigmaXY1] e := by
rw [he_def]
exact stronglyMeasurable_condExp
have hg_smeas : StronglyMeasurable[S.sigmaXY1] g := by
have he_meas : Measurable[S.sigmaXY1] e := he_smeas.measurable
exact (hY1_meas.div he_meas).stronglyMeasurable
-- Integrability of `f` and `g * f`.
have hf_int : Integrable f P.μ :=
S.dVar.integrable_indicator true (measurableSet_singleton true)
have hgf_int : Integrable (fun ω => g ω * f ω) P.μ := by
refine hcand_int.congr (Filter.Eventually.of_forall ?_)
intro ω
have hcw : S.factualY ω * f ω = S.YofD true ω * f ω := congr_fun hcons_fn ω
simp only [hg_def, hf_def] at hcw ⊢
rw [div_eq_mul_inv, div_eq_mul_inv]
linear_combination (e ω)⁻¹ * hcw
-- (3) Pull-out + tower: `∫ g * f = ∫ g * e`.
have hpull :
P.μ[fun ω => g ω * f ω | S.sigmaXY1] =ᵐ[P.μ] (fun ω => g ω * e ω) := by
have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaXY1) (μ := P.μ) hg_smeas hgf_int hf_int
-- `μ[g * f | m] =ᵐ g * μ[f | m]`, and `μ[f | m] = e`.
have he_cond : (P.μ[f | S.sigmaXY1]) = e := by
rw [hf_def, he_def]; rfl
refine h.trans ?_
rw [he_cond]
rfl
have htower : ∫ ω, g ω * f ω ∂P.μ = ∫ ω, g ω * e ω ∂P.μ := by
have h1 :
∫ ω, P.μ[fun ω => g ω * f ω | S.sigmaXY1] ω ∂P.μ
= ∫ ω, g ω * f ω ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaXY1_le
rw [← h1]
exact integral_congr_ae hpull
-- (4) Cancel: `∫ g * e = ∫ YofD true = Y1mean`.
have hcancel : ∫ ω, g ω * e ω ∂P.μ = S.Y1mean := by
unfold POBackdoorSystem.Y1mean
refine integral_congr_ae ?_
filter_upwards [hpos] with ω hω
rw [hg_def]
field_simp
rw [hcandMean_eq, htower, hcancel]
theorem Y1mean_mem_Icc reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The MSM bound: E[Y(1)] lies in the MSM interval. Assuming the true complete propensity belongs to the marginal-sensitivity ambiguity set, the IPW/tower bridge identity candMean e₀ = E[Y(1)] holds, and the candidate mean is bounded below and above over the ambiguity set, the estimand E[Y(1)] is sandwiched between the infimum and supremum of the candidate mean over the ambiguity set:
Formal statement
Proof (Lean source)
theorem Y1mean_mem_Icc (Λ : ℝ)
(hmem : S.completeProp ∈ S.MSMSet Λ)
(hbridge : S.candMean S.completeProp = S.Y1mean)
(hbdd : BddBelow (S.candMean '' S.MSMSet Λ))
(hbdd' : BddAbove (S.candMean '' S.MSMSet Λ)) :
S.Y1mean ∈ Icc (S.msmLower Λ) (S.msmUpper Λ) := by
have hmemImg : S.candMean S.completeProp ∈ S.candMean '' S.MSMSet Λ :=
Set.mem_image_of_mem _ hmem
rw [Set.mem_Icc, ← hbridge]
refine ⟨?_, ?_⟩
· exact csInf_le hbdd hmemImg
· exact le_csSup hbdd' hmemImg
theorem MSMSet_one_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Point identification at Λ = 1 (no-unmeasured-confounding collapse). Assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). If a candidate complete propensity ẽ belongs to the marginal-sensitivity ambiguity set at Λ = 1, then it equals the observed propensity score almost everywhere.
Formal statement
hypotheses
γ :
Type u_1
etilde :
P.Ω → ℝ
hmem :
etilde ∈ S.MSMSet 1
conclusion
∀ᵐ ω ∂P.μ, etilde ω = S.propScore true ω
Proof (Lean source)
theorem MSMSet_one_eq (etilde : P.Ω → ℝ)
(hprop : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hmem : etilde ∈ S.MSMSet 1) :
∀ᵐ ω ∂P.μ, etilde ω = S.propScore true ω := by
obtain ⟨hint, hor⟩ := hmem
filter_upwards [hprop, hint, hor] with ω hq hp hOR
obtain ⟨hqpos, hqlt⟩ := hq
obtain ⟨hppos, hplt⟩ := hp
obtain ⟨hlo, hhi⟩ := hOR
-- At Λ = 1, the odds-ratio window is {1}.
rw [one_div, inv_one] at hlo
have hOReq : OR (etilde ω) (S.propScore true ω) = 1 := le_antisymm hhi hlo
-- Unfold OR and clear denominators.
set p := etilde ω with hpdef
set q := S.propScore true ω with hqdef
have h1p : (0:ℝ) < 1 - p := by linarith
have h1q : (0:ℝ) < 1 - q := by linarith
have hqratio : q / (1 - q) ≠ 0 := by
apply div_ne_zero
· exact ne_of_gt hqpos
· exact ne_of_gt h1q
rw [OR, div_eq_one_iff_eq hqratio] at hOReq
-- hOReq : p/(1-p) = q/(1-q); conclude p = q.
field_simp at hOReq
nlinarith [hOReq]
6 supporting declarations (lemmas, instances)
-
sigmaXY1_lelemma — The joint σ-algebra σ(X, Y(1)) is coarser than the ambient σ-algebra on Ω.hypothesesconclusionS.sigmaXY1 ≤ (inferInstance : MeasurableSpace P.Ω)Proof (Lean source)
lemma sigmaXY1_le : S.sigmaXY1 ≤ (inferInstance : MeasurableSpace P.Ω) := by refine sup_le ?_ ?_ · exact S.measurable_factualX.comap_le · exact (S.measurable_YofD true).comap_le -
candMean_eqlemma — The candidate inverse-probability-weighted mean for a candidate complete propensity is the population mean of the treatment indicator times the factual outcome, divided by that candidate propensity.hypothesesconclusionS.candMean etilde = ∫ ω, S.dVar.indicator true ω * S.factualY ω / etilde ω ∂P.μProof (Lean source)
@[causal_defs_simps] lemma candMean_eq (etilde : P.Ω → ℝ) : S.candMean etilde = ∫ ω, S.dVar.indicator true ω * S.factualY ω / etilde ω ∂P.μ := rfl -
completeProp_mem_MSMSettheorem — The MSM assumption: the truth lies in the ambiguity set. The true complete propensity e₀ belongs to MSMSet Λ, i.e. it is a.e. interior and its odds ratio against the observed propensity e(X) is a.e. within [1/Λ, Λ]. This is precisely the marginal sensitivity assumption; the membership facts are supplied as hMSM.hypothesesγ :sharedType u_1Λ :ℝconclusionS.completeProp ∈ S.MSMSet ΛProof (Lean source)
theorem completeProp_mem_MSMSet (Λ : ℝ) (hMSM : (∀ᵐ ω ∂P.μ, 0 < S.completeProp ω ∧ S.completeProp ω < 1) ∧ (∀ᵐ ω ∂P.μ, 1 / Λ ≤ OR (S.completeProp ω) (S.propScore true ω) ∧ OR (S.completeProp ω) (S.propScore true ω) ≤ Λ)) : S.completeProp ∈ S.MSMSet Λ := by simp only [MSMSet, Set.mem_setOf_eq] exact hMSM -
MSMSet_monotheorem — Monotonicity of the ambiguity set in the sensitivity parameter. A larger budget Λ ≤ Λ' (with 1 ≤ Λ) admits every candidate that the smaller budget admits: MSMSet Λ ⊆ MSMSet Λ'. The odds-ratio window [1/Λ, Λ] widens with Λ.hypothesesγ :sharedType u_1Λ Λ' :ℝhΛ :1 ≤ ΛhΛΛ' :Λ ≤ Λ'conclusionS.MSMSet Λ ⊆ S.MSMSet Λ'Proof (Lean source)
theorem MSMSet_mono {Λ Λ' : ℝ} (hΛ : 1 ≤ Λ) (hΛΛ' : Λ ≤ Λ') : S.MSMSet Λ ⊆ S.MSMSet Λ' := by have hΛpos : 0 < Λ := lt_of_lt_of_le one_pos hΛ intro etilde hetilde obtain ⟨hint, hor⟩ := hetilde refine ⟨hint, ?_⟩ filter_upwards [hor] with ω hω obtain ⟨hlo, hhi⟩ := hω constructor · have h1 : 1 / Λ' ≤ 1 / Λ := one_div_le_one_div_of_le hΛpos hΛΛ' exact le_trans h1 hlo · exact le_trans hhi hΛΛ' -
msmUpper_monotheorem — The MSM interval widens with Λ (upper endpoint). Since MSMSet Λ ⊆ MSMSet Λ', the supremum of the candidate mean can only increase. Boundedness of the larger image is required for the sSup comparison.hypothesesγ :sharedType u_1Λ Λ' :ℝhΛ :1 ≤ ΛhΛΛ' :Λ ≤ Λ'hne :(S.candMean '' S.MSMSet Λ).Nonemptyhbdd' :BddAbove (S.candMean '' S.MSMSet Λ')conclusionS.msmUpper Λ ≤ S.msmUpper Λ'Proof (Lean source)
theorem msmUpper_mono {Λ Λ' : ℝ} (hΛ : 1 ≤ Λ) (hΛΛ' : Λ ≤ Λ') (hne : (S.candMean '' S.MSMSet Λ).Nonempty) (hbdd' : BddAbove (S.candMean '' S.MSMSet Λ')) : S.msmUpper Λ ≤ S.msmUpper Λ' := by have hsub : S.MSMSet Λ ⊆ S.MSMSet Λ' := S.MSMSet_mono hΛ hΛΛ' have himg : S.candMean '' S.MSMSet Λ ⊆ S.candMean '' S.MSMSet Λ' := Set.image_mono hsub exact csSup_le_csSup hbdd' hne himg -
msmLower_antitheorem — The MSM interval widens with Λ (lower endpoint). Since MSMSet Λ ⊆ MSMSet Λ', the infimum of the candidate mean can only decrease. Boundedness-below of the larger image is required for the sInf comparison.hypothesesγ :sharedType u_1Λ Λ' :ℝhΛ :1 ≤ ΛhΛΛ' :Λ ≤ Λ'hne :(S.candMean '' S.MSMSet Λ).Nonemptyhbdd' :BddBelow (S.candMean '' S.MSMSet Λ')conclusionS.msmLower Λ' ≤ S.msmLower ΛProof (Lean source)
theorem msmLower_anti {Λ Λ' : ℝ} (hΛ : 1 ≤ Λ) (hΛΛ' : Λ ≤ Λ') (hne : (S.candMean '' S.MSMSet Λ).Nonempty) (hbdd' : BddBelow (S.candMean '' S.MSMSet Λ')) : S.msmLower Λ' ≤ S.msmLower Λ := by have hsub : S.MSMSet Λ ⊆ S.MSMSet Λ' := S.MSMSet_mono hΛ hΛΛ' have himg : S.candMean '' S.MSMSet Λ ⊆ S.candMean '' S.MSMSet Λ' := Set.image_mono hsub exact csInf_le_csInf hbdd' hne himg
Bounds 6 core · 8 supporting This file computes the Zhao-Small-Bhattacharya box bounds for E[Y(1)]. ★ msmUpper_eq★ msmLower_eq
Closed-form uncalibrated marginal-sensitivity bounds
This file computes the Zhao-Small-Bhattacharya box bounds for E[Y(1)]. Because
the uncalibrated odds-ratio ambiguity set is pointwise separable, the supremum
and infimum of the candidate mean are attained by boundary inverse-propensity
weights selected according to the sign of the observed outcome.
The public surface consists of the endpoint weights wMin and wMax, the
integral forms msmUpperForm and msmLowerForm, and the closed-form identities
msmUpper_eq and msmLower_eq.
def wMin reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes backdoor system, a real sensitivity level, and a unit in its sample space, the lower endpoint inverse-propensity weight is , where is that unit's treated propensity score. It is the endpoint corresponding to an odds ratio of .
Definition (Lean source)
parameters
def
wMin S Λ ω :
ℝ
def wMax reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes backdoor system, a real sensitivity level, and a unit in its sample space, the upper endpoint inverse-propensity weight is , where is that unit's treated propensity score. It is the endpoint corresponding to an odds ratio of .
Definition (Lean source)
parameters
def
wMax S Λ ω :
ℝ
def msmUpperForm reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes backdoor system and a real sensitivity level, the upper marginal-sensitivity functional is the expectation of the factual outcome among treated units, weighted by the upper endpoint weight when that outcome is nonnegative and by the lower endpoint weight otherwise.
Definition (Lean source)
parameters
def
msmUpperForm S Λ :
ℝ
given by
∫ ω, S.dVar.indicator true ω * S.factualY ω * (if 0 ≤ S.factualY ω then S.wMax Λ ω else S.wMin Λ ω) ∂P.μ
def msmLowerForm reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes backdoor system and a real sensitivity level, the lower marginal-sensitivity functional is the expectation of the factual outcome among treated units, weighted by the lower endpoint weight when that outcome is nonnegative and by the upper endpoint weight otherwise.
Definition (Lean source)
parameters
def
msmLowerForm S Λ :
ℝ
given by
∫ ω, S.dVar.indicator true ω * S.factualY ω * (if 0 ≤ S.factualY ω then S.wMin Λ ω else S.wMax Λ ω) ∂P.μ
theorem msmUpper_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Closed form of the MSM upper bound. Fix a sensitivity parameter Λ at least 1. If the propensity score lies strictly between 0 and 1 almost everywhere (two-sided overlap), every candidate propensity in the odds-ratio ambiguity set is measurable up to null sets, and the envelope A·|Y|·wMax(Λ) — which dominates every candidate IPW integrand — is integrable, then the supremum of the candidate IPW mean over the ambiguity set is attained pointwise: the MSM upper bound equals E[A·Y·(wMax if Y≥0 else wMin)].
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
hmeas :
∀ etilde ∈ S.MSMSet Λ, AEMeasurable etilde P.μ
henv :
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ
conclusion
S.msmUpper Λ = S.msmUpperForm Λ
Proof (Lean source)
theorem msmUpper_eq (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hmeas : ∀ etilde ∈ S.MSMSet Λ, AEMeasurable etilde P.μ)
(henv : Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ) :
S.msmUpper Λ = S.msmUpperForm Λ := by
classical
have hΛ0 : (0:ℝ) < Λ := lt_of_lt_of_le one_pos hΛ
-- Abbreviations.
set A : P.Ω → ℝ := S.dVar.indicator true with hA_def
set Y : P.Ω → ℝ := S.factualY with hY_def
set e : P.Ω → ℝ := S.propScore true with he_def
-- Measurability.
have hAm : Measurable A := S.dVar.measurable_indicator true (measurableSet_singleton true)
have hYm : Measurable Y := S.measurable_factualY
have hem : Measurable e := by
rw [he_def]; unfold POBackdoorSystem.propScore
exact (stronglyMeasurable_condExp.mono S.sigmaX_le).measurable
have hwMaxm : Measurable (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hem)).div hem))
have hwMinm : Measurable (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact (measurable_const.add
((measurable_const.sub hem).div (measurable_const.mul hem)))
-- `A` is in `[0,1]`.
have hA0 : ∀ ω, 0 ≤ A ω := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero true ω with h | h <;> simp [hA_def, h]
have hA1 : ∀ ω, A ω ≤ 1 := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero true ω with h | h <;> simp [hA_def, h]
-- The optimal weight and candidate propensity.
set wstar : P.Ω → ℝ := fun ω => if 0 ≤ Y ω then S.wMax Λ ω else S.wMin Λ ω with hwstar_def
set estar : P.Ω → ℝ := fun ω => 1 / wstar ω with hestar_def
-- a.e. positivity / ordering of the weights from overlap.
have hae : ∀ᵐ ω ∂P.μ, (1:ℝ) < S.wMin Λ ω ∧ S.wMin Λ ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap] with ω hω
obtain ⟨he0, he1⟩ := hω
have h1e : 0 < 1 - e ω := by rw [he_def] at *; linarith
have he0' : 0 < e ω := by rw [he_def] at *; exact he0
refine ⟨?_, ?_⟩
· have : 0 < (1 - e ω) / (Λ * e ω) := by positivity
simp only [POBackdoorSystem.wMin, ← he_def]; linarith
· simp only [POBackdoorSystem.wMin, POBackdoorSystem.wMax, ← he_def]
have hd1 : (1 - e ω) / (Λ * e ω) ≤ Λ * (1 - e ω) / e ω := by
rw [div_le_div_iff₀ (by positivity) he0']
nlinarith [hΛ, mul_pos h1e he0', mul_pos hΛ0 he0',
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0')) (sub_nonneg.mpr hΛ)]
linarith
-- Measurability and a.e. bounds of the optimal weight.
have hwstar_m : Measurable wstar := by
rw [hwstar_def]
exact Measurable.ite (measurableSet_le measurable_const hYm) hwMaxm hwMinm
have hwstar_ae : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ wstar ω ∧ wstar ω ≤ S.wMax Λ ω ∧ 0 < wstar ω := by
filter_upwards [hae] with ω hω
obtain ⟨hwm1, hwmle⟩ := hω
rw [hwstar_def]
by_cases hy : 0 ≤ Y ω
· simp only [if_pos hy]; exact ⟨hwmle, le_rfl, by linarith⟩
· simp only [if_neg hy]; exact ⟨le_rfl, hwmle, by linarith⟩
-- `A*Y*wstar` is dominated by the envelope, hence integrable.
have hform_int : Integrable (fun ω => A ω * Y ω * wstar ω) P.μ := by
refine Integrable.mono' henv
((hAm.mul hYm).mul hwstar_m).aestronglyMeasurable ?_
filter_upwards [hwstar_ae] with ω hω
obtain ⟨_, hle, hpos⟩ := hω
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω)]
have hwabs : |wstar ω| = wstar ω := abs_of_nonneg (le_of_lt hpos)
rw [hwabs, mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hle (abs_nonneg _)
-- `msmUpperForm = ∫ A*Y*wstar`.
have hform_eq : S.msmUpperForm Λ = ∫ ω, A ω * Y ω * wstar ω ∂P.μ := by
rfl
-- Witness: `estar = 1/wstar ∈ MSMSet Λ` with `candMean estar = msmUpperForm`.
have hestar_candMean : S.candMean estar = S.msmUpperForm Λ := by
rw [hform_eq]
unfold POBackdoorSystem.candMean
refine integral_congr_ae ?_
filter_upwards [hwstar_ae] with ω hω
obtain ⟨_, _, hpos⟩ := hω
change A ω * Y ω / (1 / wstar ω) = A ω * Y ω * wstar ω
rw [div_div_eq_mul_div, div_one]
-- a.e. `wstar > 1` (since `wstar ∈ {wMin, wMax}`, `wMin > 1`, `wMax ≥ wMin`).
have hwstar_gt1 : ∀ᵐ ω ∂P.μ, 1 < wstar ω := by
filter_upwards [hae] with ω hω
obtain ⟨hwm1, hwmle⟩ := hω
rw [hwstar_def]
by_cases hy : 0 ≤ Y ω
· simp only [if_pos hy]; linarith
· simp only [if_neg hy]; exact hwm1
have hestar_mem : estar ∈ S.MSMSet Λ := by
refine ⟨?_, ?_⟩
· filter_upwards [hwstar_gt1] with ω hω
rw [hestar_def]
constructor
· positivity
· rw [div_lt_one (by linarith)]; linarith
· filter_upwards [hoverlap, hwstar_ae, hwstar_gt1] with ω hov hw hwgt
obtain ⟨he0, he1⟩ := hov
obtain ⟨hmin, hmax, hpos⟩ := hw
have het0 : 0 < estar ω := by rw [hestar_def]; positivity
have het1 : estar ω < 1 := by
rw [hestar_def, div_lt_one (by linarith)]; linarith
rw [OR_box_iff hΛ0 he0 he1 het0 het1]
have hinv : 1 / estar ω = wstar ω := by
rw [hestar_def, one_div_one_div]
rw [hinv]
exact ⟨hmin, hmax⟩
-- Every candidate mean is `≤ msmUpperForm`.
have hcand_le : ∀ etilde ∈ S.MSMSet Λ, S.candMean etilde ≤ S.msmUpperForm Λ := by
intro et hmem
obtain ⟨hint, hor⟩ := hmem
have hetm : AEMeasurable et P.μ := hmeas et ⟨hint, hor⟩
-- a.e. box bound on `w = 1/et`.
have hbox : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ 1 / et ω ∧ 1 / et ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap, hint, hor] with ω hov het hOR
obtain ⟨he0, he1⟩ := hov
obtain ⟨het0, het1⟩ := het
have := (OR_box_iff hΛ0 he0 he1 het0 het1).mp hOR
exact this
-- `A*Y/et = A*Y*(1/et)` a.e.; integrable by domination.
have hcandmean_int : Integrable (fun ω => A ω * Y ω / et ω) P.μ := by
refine Integrable.mono' henv
(((hAm.mul hYm).aemeasurable.div hetm).aestronglyMeasurable) ?_
filter_upwards [hbox, hoverlap, hint] with ω hb hov het
obtain ⟨hmin, hmax⟩ := hb
obtain ⟨he0, he1⟩ := hov
obtain ⟨het0, het1⟩ := het
rw [Real.norm_eq_abs, mul_div_assoc, abs_mul, abs_of_nonneg (hA0 ω),
mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
have hYdiv : |Y ω / et ω| = |Y ω| * (1 / et ω) := by
rw [abs_div, abs_of_nonneg (le_of_lt het0), mul_one_div]
rw [hYdiv]
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have heq_w : (fun ω => A ω * Y ω / et ω)
=ᵐ[P.μ] (fun ω => A ω * Y ω * (1 / et ω)) := by
filter_upwards with ω
rw [mul_one_div]
-- `candMean et = ∫ A*Y*(1/et) ≤ ∫ A*Y*wstar = form`.
rw [show S.candMean et = ∫ ω, A ω * Y ω / et ω ∂P.μ from rfl, hform_eq]
rw [integral_congr_ae heq_w]
apply integral_mono_ae (hcandmean_int.congr heq_w) hform_int
filter_upwards [hbox] with ω hb
obtain ⟨hmin, hmax⟩ := hb
exact weight_mul_le_upper (hA0 ω) hmin hmax
-- Assemble: `msmUpper = sSup (candMean '' MSMSet) = msmUpperForm`.
have hne : (S.candMean '' S.MSMSet Λ).Nonempty :=
⟨S.candMean estar, Set.mem_image_of_mem _ hestar_mem⟩
have hbdd : BddAbove (S.candMean '' S.MSMSet Λ) := by
refine ⟨S.msmUpperForm Λ, ?_⟩
rintro x ⟨et, hmem, rfl⟩
exact hcand_le et hmem
refine le_antisymm ?_ ?_
· apply csSup_le hne
rintro x ⟨et, hmem, rfl⟩
exact hcand_le et hmem
· rw [← hestar_candMean]
exact le_csSup hbdd (Set.mem_image_of_mem _ hestar_mem)
theorem msmLower_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Closed form of the MSM lower bound. Fix a sensitivity parameter Λ at least 1. If the propensity score lies strictly between 0 and 1 almost everywhere (two-sided overlap), every candidate propensity in the odds-ratio ambiguity set is measurable up to null sets, and the envelope A·|Y|·wMax(Λ) — which dominates every candidate IPW integrand — is integrable, then the infimum of the candidate IPW mean over the ambiguity set is attained pointwise: the MSM lower bound equals E[A·Y·(wMin if Y≥0 else wMax)].
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
hmeas :
∀ etilde ∈ S.MSMSet Λ, AEMeasurable etilde P.μ
henv :
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ
conclusion
S.msmLower Λ = S.msmLowerForm Λ
Proof (Lean source)
theorem msmLower_eq (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hmeas : ∀ etilde ∈ S.MSMSet Λ, AEMeasurable etilde P.μ)
(henv : Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ) :
S.msmLower Λ = S.msmLowerForm Λ := by
classical
have hΛ0 : (0:ℝ) < Λ := lt_of_lt_of_le one_pos hΛ
set A : P.Ω → ℝ := S.dVar.indicator true with hA_def
set Y : P.Ω → ℝ := S.factualY with hY_def
set e : P.Ω → ℝ := S.propScore true with he_def
have hAm : Measurable A := S.dVar.measurable_indicator true (measurableSet_singleton true)
have hYm : Measurable Y := S.measurable_factualY
have hem : Measurable e := by
rw [he_def]; unfold POBackdoorSystem.propScore
exact (stronglyMeasurable_condExp.mono S.sigmaX_le).measurable
have hwMaxm : Measurable (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hem)).div hem))
have hwMinm : Measurable (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact (measurable_const.add
((measurable_const.sub hem).div (measurable_const.mul hem)))
have hA0 : ∀ ω, 0 ≤ A ω := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero true ω with h | h <;> simp [hA_def, h]
-- Lower-bound optimal weight: `wMin` where `Y ≥ 0`, `wMax` where `Y < 0`.
set wstar : P.Ω → ℝ := fun ω => if 0 ≤ Y ω then S.wMin Λ ω else S.wMax Λ ω with hwstar_def
set estar : P.Ω → ℝ := fun ω => 1 / wstar ω with hestar_def
have hae : ∀ᵐ ω ∂P.μ, (1:ℝ) < S.wMin Λ ω ∧ S.wMin Λ ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap] with ω hω
obtain ⟨he0, he1⟩ := hω
have h1e : 0 < 1 - e ω := by rw [he_def] at *; linarith
have he0' : 0 < e ω := by rw [he_def] at *; exact he0
refine ⟨?_, ?_⟩
· have : 0 < (1 - e ω) / (Λ * e ω) := by positivity
simp only [POBackdoorSystem.wMin, ← he_def]; linarith
· simp only [POBackdoorSystem.wMin, POBackdoorSystem.wMax, ← he_def]
have hd1 : (1 - e ω) / (Λ * e ω) ≤ Λ * (1 - e ω) / e ω := by
rw [div_le_div_iff₀ (by positivity) he0']
nlinarith [hΛ, mul_pos h1e he0', mul_pos hΛ0 he0',
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0')) (sub_nonneg.mpr hΛ)]
linarith
have hwstar_m : Measurable wstar := by
rw [hwstar_def]
exact Measurable.ite (measurableSet_le measurable_const hYm) hwMinm hwMaxm
have hwstar_ae : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ wstar ω ∧ wstar ω ≤ S.wMax Λ ω ∧ 0 < wstar ω := by
filter_upwards [hae] with ω hω
obtain ⟨hwm1, hwmle⟩ := hω
rw [hwstar_def]
by_cases hy : 0 ≤ Y ω
· simp only [if_pos hy]; exact ⟨le_rfl, hwmle, by linarith⟩
· simp only [if_neg hy]; exact ⟨hwmle, le_rfl, by linarith⟩
have hwstar_gt1 : ∀ᵐ ω ∂P.μ, 1 < wstar ω := by
filter_upwards [hae] with ω hω
obtain ⟨hwm1, hwmle⟩ := hω
rw [hwstar_def]
by_cases hy : 0 ≤ Y ω
· simp only [if_pos hy]; exact hwm1
· simp only [if_neg hy]; linarith
-- `A*Y*wstar` integrable (dominated by envelope).
have hform_int : Integrable (fun ω => A ω * Y ω * wstar ω) P.μ := by
refine Integrable.mono' henv
((hAm.mul hYm).mul hwstar_m).aestronglyMeasurable ?_
filter_upwards [hwstar_ae] with ω hω
obtain ⟨_, hle, hpos⟩ := hω
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω)]
have hwabs : |wstar ω| = wstar ω := abs_of_nonneg (le_of_lt hpos)
rw [hwabs, mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hle (abs_nonneg _)
have hform_eq : S.msmLowerForm Λ = ∫ ω, A ω * Y ω * wstar ω ∂P.μ := by
rfl
-- Witness `estar = 1/wstar ∈ MSMSet`, `candMean estar = msmLowerForm`.
have hestar_candMean : S.candMean estar = S.msmLowerForm Λ := by
rw [hform_eq]
unfold POBackdoorSystem.candMean
refine integral_congr_ae ?_
filter_upwards [hwstar_ae] with ω hω
obtain ⟨_, _, hpos⟩ := hω
change A ω * Y ω / (1 / wstar ω) = A ω * Y ω * wstar ω
rw [div_div_eq_mul_div, div_one]
have hestar_mem : estar ∈ S.MSMSet Λ := by
refine ⟨?_, ?_⟩
· filter_upwards [hwstar_gt1] with ω hω
rw [hestar_def]
exact ⟨by positivity, by rw [div_lt_one (by linarith)]; linarith⟩
· filter_upwards [hoverlap, hwstar_ae, hwstar_gt1] with ω hov hw hwgt
obtain ⟨he0, he1⟩ := hov
obtain ⟨hmin, hmax, hpos⟩ := hw
have het0 : 0 < estar ω := by rw [hestar_def]; positivity
have het1 : estar ω < 1 := by
rw [hestar_def, div_lt_one (by linarith)]; linarith
rw [OR_box_iff hΛ0 he0 he1 het0 het1]
have hinv : 1 / estar ω = wstar ω := by rw [hestar_def, one_div_one_div]
rw [hinv]; exact ⟨hmin, hmax⟩
-- Every candidate mean is `≥ msmLowerForm`.
have hcand_ge : ∀ etilde ∈ S.MSMSet Λ, S.msmLowerForm Λ ≤ S.candMean etilde := by
intro et hmem
obtain ⟨hint, hor⟩ := hmem
have hetm : AEMeasurable et P.μ := hmeas et ⟨hint, hor⟩
have hbox : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ 1 / et ω ∧ 1 / et ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap, hint, hor] with ω hov het hOR
obtain ⟨he0, he1⟩ := hov
obtain ⟨het0, het1⟩ := het
exact (OR_box_iff hΛ0 he0 he1 het0 het1).mp hOR
have hcandmean_int : Integrable (fun ω => A ω * Y ω / et ω) P.μ := by
refine Integrable.mono' henv
(((hAm.mul hYm).aemeasurable.div hetm).aestronglyMeasurable) ?_
filter_upwards [hbox, hoverlap, hint] with ω hb hov het
obtain ⟨hmin, hmax⟩ := hb
obtain ⟨he0, he1⟩ := hov
obtain ⟨het0, het1⟩ := het
rw [Real.norm_eq_abs, mul_div_assoc, abs_mul, abs_of_nonneg (hA0 ω),
mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
have hYdiv : |Y ω / et ω| = |Y ω| * (1 / et ω) := by
rw [abs_div, abs_of_nonneg (le_of_lt het0), mul_one_div]
rw [hYdiv]
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have heq_w : (fun ω => A ω * Y ω / et ω)
=ᵐ[P.μ] (fun ω => A ω * Y ω * (1 / et ω)) := by
filter_upwards with ω; rw [mul_one_div]
rw [show S.candMean et = ∫ ω, A ω * Y ω / et ω ∂P.μ from rfl, hform_eq]
rw [integral_congr_ae heq_w]
apply integral_mono_ae hform_int (hcandmean_int.congr heq_w)
filter_upwards [hbox] with ω hb
obtain ⟨hmin, hmax⟩ := hb
exact weight_mul_ge_lower (hA0 ω) hmin hmax
-- Assemble via `sInf`.
have hne : (S.candMean '' S.MSMSet Λ).Nonempty :=
⟨S.candMean estar, Set.mem_image_of_mem _ hestar_mem⟩
have hbdd : BddBelow (S.candMean '' S.MSMSet Λ) := by
refine ⟨S.msmLowerForm Λ, ?_⟩
rintro x ⟨et, hmem, rfl⟩
exact hcand_ge et hmem
refine le_antisymm ?_ ?_
· rw [← hestar_candMean]
exact csInf_le hbdd (Set.mem_image_of_mem _ hestar_mem)
· apply le_csInf hne
rintro x ⟨et, hmem, rfl⟩
exact hcand_ge et hmem
8 supporting declarations (lemmas, instances)
-
wMin_deflemma — The smallest admissible inverse-propensity weight at a sensitivity level sends a unit to one plus the ratio of the complementary propensity score to the sensitivity level times the propensity score.hypotheses -
wMax_deflemma — The largest admissible inverse-propensity weight at a sensitivity level sends a unit to one plus the sensitivity level times the complementary propensity score, divided by the propensity score.hypotheses -
measurable_wMin_sigmaXlemma — The lower marginal-sensitivity weight is measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (S.wMin Λ)Proof (Lean source)
@[fun_prop] lemma measurable_wMin_sigmaX (Λ : ℝ) : Measurable[S.sigmaX] (S.wMin Λ) := by have hp : Measurable[S.sigmaX] (S.propScore true) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable unfold POBackdoorSystem.wMin exact measurable_const.add ((measurable_const.sub hp).div (measurable_const.mul hp)) -
measurable_wMax_sigmaXlemma — The upper marginal-sensitivity weight is measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (S.wMax Λ)Proof (Lean source)
@[fun_prop] lemma measurable_wMax_sigmaX (Λ : ℝ) : Measurable[S.sigmaX] (S.wMax Λ) := by have hp : Measurable[S.sigmaX] (S.propScore true) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable unfold POBackdoorSystem.wMax exact measurable_const.add ((measurable_const.mul (measurable_const.sub hp)).div hp) -
stronglyMeasurable_wMin_sigmaXlemma — The strongly-measurable form, for the covariate σ-algebra, of the lower sensitivity weight.hypothesesconclusionStronglyMeasurable[S.sigmaX] (S.wMin Λ)Proof (Lean source)
@[fun_prop] lemma stronglyMeasurable_wMin_sigmaX (Λ : ℝ) : StronglyMeasurable[S.sigmaX] (S.wMin Λ) := (S.measurable_wMin_sigmaX Λ).stronglyMeasurable -
stronglyMeasurable_wMax_sigmaXlemma — The strongly-measurable form, for the covariate σ-algebra, of the upper sensitivity weight.hypothesesconclusionStronglyMeasurable[S.sigmaX] (S.wMax Λ)Proof (Lean source)
@[fun_prop] lemma stronglyMeasurable_wMax_sigmaX (Λ : ℝ) : StronglyMeasurable[S.sigmaX] (S.wMax Λ) := (S.measurable_wMax_sigmaX Λ).stronglyMeasurable -
measurable_wMinlemma — The lower sensitivity weight is measurable for the ambient σ-algebra.hypothesesconclusionMeasurable (S.wMin Λ)Proof (Lean source)
@[fun_prop] lemma measurable_wMin (Λ : ℝ) : Measurable (S.wMin Λ) := (S.measurable_wMin_sigmaX Λ).mono S.sigmaX_le le_rfl -
measurable_wMaxlemma — The upper sensitivity weight is measurable for the ambient σ-algebra.hypothesesconclusionMeasurable (S.wMax Λ)Proof (Lean source)
@[fun_prop] lemma measurable_wMax (Λ : ℝ) : Measurable (S.wMax Λ) := (S.measurable_wMax_sigmaX Λ).mono S.sigmaX_le le_rfl
Sharp 6 core · 4 supporting This file defines the calibrated treated-arm MSM ambiguity set and proves its basic validity properties. ★ Y1mean_mem_Icc_calib★ msmUpperCalib_le_msmUpper
Sharp calibrated marginal-sensitivity set
This file defines the calibrated treated-arm MSM ambiguity set and proves its
basic validity properties. It introduces Calibrated, MSMSetCalib,
msmUpperCalib, and msmLowerCalib; proves that the true complete propensity is
calibrated and therefore belongs to the calibrated set when the MSM assumption
holds; proves validity of the sharp interval via Y1mean_mem_Icc_calib; and
shows that calibrated bounds are tighter than the uncalibrated ZSB bounds.
def Calibrated reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a candidate complete-propensity function, the calibration condition holds exactly when the conditional mean, given the covariate σ-algebra, of the treated-arm indicator divided by that function equals one almost surely.
Definition (Lean source)
parameters
def
Calibrated S etilde :
Prop
given by
P.μ[fun ω => S.dVar.indicator true ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => 1)
def MSMSetCalib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a sensitivity level, the calibrated MSM ambiguity set contains exactly the candidate complete-propensity functions that belong to the MSM ambiguity set at that level and satisfy the calibration condition.
Definition (Lean source)
parameters
def
given by
{ etilde | etilde ∈ S.MSMSet Λ ∧ S.Calibrated etilde }
def msmUpperCalib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a sensitivity level, the sharp MSM upper bound is the supremum of candidate inverse-probability-weighted means over the calibrated MSM ambiguity set.
Definition (Lean source)
def msmLowerCalib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Given a binary-treatment backdoor system and a sensitivity level, the sharp MSM lower bound is the infimum of candidate inverse-probability-weighted means over the calibrated MSM ambiguity set.
Definition (Lean source)
theorem Y1mean_mem_Icc_calib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp bound is valid. Assuming the true complete propensity belongs to the calibrated (sharp) marginal-sensitivity ambiguity set, the IPW/tower bridge identity candMean e₀ = E[Y(1)] holds, and the candidate mean is bounded below and above over the calibrated ambiguity set, then the estimand E[Y(1)] lies in the calibrated (sharp) interval [msmLowerCalib Λ, msmUpperCalib Λ].
Formal statement
Proof (Lean source)
theorem Y1mean_mem_Icc_calib (Λ : ℝ)
(hmem : S.completeProp ∈ S.MSMSetCalib Λ)
(hbridge : S.candMean S.completeProp = S.Y1mean)
(hbdd : BddBelow (S.candMean '' S.MSMSetCalib Λ))
(hbdd' : BddAbove (S.candMean '' S.MSMSetCalib Λ)) :
S.Y1mean ∈ Icc (S.msmLowerCalib Λ) (S.msmUpperCalib Λ) := by
have hmemImg : S.candMean S.completeProp ∈ S.candMean '' S.MSMSetCalib Λ :=
Set.mem_image_of_mem _ hmem
rw [Set.mem_Icc, ← hbridge]
refine ⟨?_, ?_⟩
· exact csInf_le hbdd hmemImg
· exact le_csSup hbdd' hmemImg
theorem msmUpperCalib_le_msmUpper reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp upper bound is tighter than the ZSB bound. Assuming the calibrated candidate-mean image is nonempty and the candidate mean is bounded above over the uncalibrated odds-ratio-box ambiguity set, the sharp (calibrated) upper bound is at most the ZSB (uncalibrated) upper bound: msmUpperCalib Λ ≤ msmUpper Λ. The calibrated set is smaller, so its candidate-mean supremum can only decrease.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hne :
(S.candMean '' S.MSMSetCalib Λ).Nonempty
hbdd :
BddAbove (S.candMean '' S.MSMSet Λ)
conclusion
S.msmUpperCalib Λ ≤ S.msmUpper Λ
Proof (Lean source)
theorem msmUpperCalib_le_msmUpper (Λ : ℝ)
(hne : (S.candMean '' S.MSMSetCalib Λ).Nonempty)
(hbdd : BddAbove (S.candMean '' S.MSMSet Λ)) :
S.msmUpperCalib Λ ≤ S.msmUpper Λ := by
have hsub : S.MSMSetCalib Λ ⊆ S.MSMSet Λ := S.MSMSetCalib_subset Λ
have himg : S.candMean '' S.MSMSetCalib Λ ⊆ S.candMean '' S.MSMSet Λ :=
Set.image_mono hsub
exact csSup_le_csSup hbdd hne himg
4 supporting declarations (lemmas, instances)
-
completeProp_calibratedtheorem — The true complete propensity is calibrated. E[Z / e₀ | σ(X)] = 1 a.e., where e₀ = P[D=1 | σ(X, Y(1))]. By the tower property (σ(X) ⊆ σ(X, Y(1))): E[Z/e₀ | σX] = E[ E[Z/e₀ | σ(X,Y(1))] | σX] = E[ (1/e₀)·E[Z|σ(X,Y(1))] | σX] = E[ e₀/e₀ | σX] = 1. Uses the same condExp pull-out + cancellation as the IPW bridge in Setup.lean.hypothesesγ :sharedType u_1IsFiniteMeasure P.μhpos :∀ᵐ ω ∂P.μ, 0 < S.completeProp ωhint :Integrable (fun ω => S.dVar.indicator true ω / S.completeProp ω) P.μconclusionS.Calibrated S.completePropProof (Lean source)
theorem completeProp_calibrated [StandardBorelSpace P.Ω] [IsFiniteMeasure P.μ] (hpos : ∀ᵐ ω ∂P.μ, 0 < S.completeProp ω) (hint : Integrable (fun ω => S.dVar.indicator true ω / S.completeProp ω) P.μ) : S.Calibrated S.completeProp := by classical set A : P.Ω → ℝ := S.dVar.indicator true with hA_def set e : P.Ω → ℝ := S.completeProp with he_def -- `σ(X) ≤ σ(X, Y(1))`. have hX_le : S.sigmaX ≤ S.sigmaXY1 := by rw [POBackdoorSystem.sigmaX, POBackdoorSystem.sigmaXY1] exact le_sup_left -- `1/e` is `σ(X,Y(1))`-strongly measurable (`e = condExp` is). have he_smeas : StronglyMeasurable[S.sigmaXY1] e := by rw [he_def]; exact stronglyMeasurable_condExp have hinv_smeas : StronglyMeasurable[S.sigmaXY1] (fun ω => 1 / e ω) := (measurable_const.div he_smeas.measurable).stronglyMeasurable -- Integrability of `A` and `(1/e)·A` (= `A/e`). have hA_int : Integrable A P.μ := S.dVar.integrable_indicator true (measurableSet_singleton true) have hinvA_int : Integrable (fun ω => (1 / e ω) * A ω) P.μ := by refine hint.congr (Filter.Eventually.of_forall ?_) intro ω simp [hA_def, he_def, div_eq_inv_mul] -- Pull-out: `μ[(1/e)·A | σ(X,Y(1))] =ᵐ (1/e)·μ[A | σ(X,Y(1))] = (1/e)·e`. have he_cond : (P.μ[A | S.sigmaXY1]) = e := by rw [hA_def, he_def]; rfl have hpull : P.μ[fun ω => (1 / e ω) * A ω | S.sigmaXY1] =ᵐ[P.μ] (fun ω => (1 / e ω) * e ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaXY1) (μ := P.μ) hinv_smeas hinvA_int hA_int refine h.trans ?_ rw [he_cond] rfl -- Cancel: `(1/e)·e = 1` a.e. from positivity. have hcancel : (fun ω => (1 / e ω) * e ω) =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by filter_upwards [hpos] with ω hω rw [he_def] at hω rw [he_def] field_simp -- So `μ[A/e | σ(X,Y(1))] =ᵐ 1`. have hinner : P.μ[fun ω => A ω / e ω | S.sigmaXY1] =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by have hrw : (fun ω => A ω / e ω) = (fun ω => (1 / e ω) * A ω) := by funext ω; rw [one_div, div_eq_inv_mul] rw [hrw] exact hpull.trans hcancel -- Tower: `μ[A/e | σX] =ᵐ μ[ μ[A/e | σ(X,Y(1))] | σX] =ᵐ μ[1 | σX] =ᵐ 1`. unfold POBackdoorSystem.Calibrated have htower : P.μ[fun ω => A ω / e ω | S.sigmaX] =ᵐ[P.μ] P.μ[P.μ[fun ω => A ω / e ω | S.sigmaXY1] | S.sigmaX] := (MeasureTheory.condExp_condExp_of_le hX_le S.sigmaXY1_le).symm refine htower.trans ?_ have hcongr : P.μ[P.μ[fun ω => A ω / e ω | S.sigmaXY1] | S.sigmaX] =ᵐ[P.μ] P.μ[(fun _ => (1 : ℝ)) | S.sigmaX] := condExp_congr_ae hinner refine hcongr.trans ?_ exact Filter.EventuallyEq.of_eq (MeasureTheory.condExp_const S.sigmaX_le (1 : ℝ)) -
completeProp_mem_MSMSetCalibtheorem — The true complete propensity lies in the calibrated set when it satisfies MSM membership and calibration.hypothesesγ :sharedType u_1Λ :ℝhmem :S.completeProp ∈ S.MSMSet Λhcalib :S.Calibrated S.completePropconclusionS.completeProp ∈ S.MSMSetCalib ΛProof (Lean source)
theorem completeProp_mem_MSMSetCalib (Λ : ℝ) (hmem : S.completeProp ∈ S.MSMSet Λ) (hcalib : S.Calibrated S.completeProp) : S.completeProp ∈ S.MSMSetCalib Λ := ⟨hmem, hcalib⟩ -
MSMSetCalib_subsettheorem — The calibrated set is a subset of the odds-ratio box.hypothesesconclusionS.MSMSetCalib Λ ⊆ S.MSMSet ΛProof (Lean source)
theorem MSMSetCalib_subset (Λ : ℝ) : S.MSMSetCalib Λ ⊆ S.MSMSet Λ := fun _ h => h.1 -
msmLower_le_msmLowerCalibtheorem — The sharp lower bound is tighter than the ZSB bound: msmLower Λ ≤ msmLowerCalib Λ.hypothesesγ :sharedType u_1Λ :ℝhne :(S.candMean '' S.MSMSetCalib Λ).Nonemptyhbdd :BddBelow (S.candMean '' S.MSMSet Λ)conclusionS.msmLower Λ ≤ S.msmLowerCalib ΛProof (Lean source)
theorem msmLower_le_msmLowerCalib (Λ : ℝ) (hne : (S.candMean '' S.MSMSetCalib Λ).Nonempty) (hbdd : BddBelow (S.candMean '' S.MSMSet Λ)) : S.msmLower Λ ≤ S.msmLowerCalib Λ := by have hsub : S.MSMSetCalib Λ ⊆ S.MSMSet Λ := S.MSMSetCalib_subset Λ have himg : S.candMean '' S.MSMSetCalib Λ ⊆ S.candMean '' S.MSMSet Λ := Set.image_mono hsub exact csInf_le_csInf hbdd hne himg
ControlSetup 9 core · 6 supporting This file mirrors Setup.lean for the control arm. ★ Y0mean_mem_Icc★ MSMSet0_one_eq
Marginal Sensitivity Model (MSM) for the control mean E[Y(0)]
This file mirrors Setup.lean for the control arm. The treated MSM bounds
E[Y(1)] by inverse-probability weighting the indicator 1_{D=1} against the
complete treated propensity P[D=1 | σ(X, Y(1))]; here we bound E[Y(0)] by
weighting 1_{D=0} against the complete control propensity
P[D=0 | σ(X, Y(0))], with the discrepancy from the observed
P[D=0 | σ(X)] = propScore false controlled by the same odds-ratio budget Λ ≥ 1.
Every definition and theorem is the D=0 reflection of Setup.lean:
sigmaXY1 → sigmaXY0, completeProp → completeProp0, candMean → candMean0,
Y1mean → Y0mean, MSMSet → MSMSet0, etc. The odds-ratio object OR and the
structure-level pieces (propScore, YofD, consistency) are shared from Setup.lean
/ ATE.lean. This is the cheap symmetric extension that feeds the ATE interval
(ATE.lean).
def sigmaXY0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the joint σ-algebra generated by the factual covariate and the control potential outcome is the least σ-algebra making both quantities measurable.
Definition (Lean source)
parameters
def
given by
def completeProp0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the complete control propensity assigns to each unit the conditional probability of being untreated given its factual covariate and its control potential outcome.
Definition (Lean source)
def candMean0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a candidate complete control propensity, the candidate inverse-probability-weighted control mean is the population expectation of the factual outcome times the indicator of being untreated, divided by that candidate propensity.
Definition (Lean source)
parameters
def
candMean0 S etilde :
ℝ
given by
∫ ω, S.dVar.indicator false ω * S.factualY ω / etilde ω ∂P.μ
def Y0mean reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the control-mean estimand is the population mean of the potential outcome under control.
Definition (Lean source)
def MSMSet0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, at a sensitivity level, the control marginal- sensitivity-model ambiguity set consists of candidate complete control propensities that are strictly between zero and one almost surely and whose odds ratio relative to the observed control propensity is between and almost surely.
Definition (Lean source)
def msmUpper0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the control marginal- sensitivity-model upper bound is the supremum of the candidate inverse-probability- weighted control means over the control ambiguity set.
Definition (Lean source)
def msmLower0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the control marginal- sensitivity-model lower bound is the infimum of the candidate inverse-probability- weighted control means over the control ambiguity set.
Definition (Lean source)
theorem Y0mean_mem_Icc reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The control MSM bound is valid. For a sensitivity parameter Λ at which the true complete control propensity P[D=0∣σ(X,Y(0))] belongs to the control ambiguity set, assuming the candidate IPW mean evaluated at the true complete control propensity recovers E[Y(0)] and that the candidate means over the ambiguity set are bounded below and bounded above, the mean control potential outcome E[Y(0)] lies in the closed interval between the control MSM lower and upper bounds.
Formal statement
Proof (Lean source)
theorem Y0mean_mem_Icc (Λ : ℝ)
(hmem : S.completeProp0 ∈ S.MSMSet0 Λ)
(hbridge : S.candMean0 S.completeProp0 = S.Y0mean)
(hbdd : BddBelow (S.candMean0 '' S.MSMSet0 Λ))
(hbdd' : BddAbove (S.candMean0 '' S.MSMSet0 Λ)) :
S.Y0mean ∈ Icc (S.msmLower0 Λ) (S.msmUpper0 Λ) := by
have hmemImg : S.candMean0 S.completeProp0 ∈ S.candMean0 '' S.MSMSet0 Λ :=
Set.mem_image_of_mem _ hmem
rw [Set.mem_Icc, ← hbridge]
refine ⟨?_, ?_⟩
· exact csInf_le hbdd hmemImg
· exact le_csSup hbdd' hmemImg
theorem MSMSet0_one_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Point identification at Λ = 1 (control arm, no-unmeasured-confounding collapse). Assume the observed control propensity score P[D=0∣σ(X)] is almost surely strictly between 0 and 1. Then for any candidate complete control propensity ẽ belonging to the (uncalibrated) control ambiguity set at sensitivity level Λ = 1, ẽ agrees almost everywhere with the observed control propensity score: at Λ = 1 the odds-ratio ambiguity set collapses to the single point given by no unmeasured confounding.
Formal statement
hypotheses
γ :
Type u_1
etilde :
P.Ω → ℝ
hmem :
etilde ∈ S.MSMSet0 1
conclusion
∀ᵐ ω ∂P.μ, etilde ω = S.propScore false ω
Proof (Lean source)
theorem MSMSet0_one_eq (etilde : P.Ω → ℝ)
(hprop : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(hmem : etilde ∈ S.MSMSet0 1) :
∀ᵐ ω ∂P.μ, etilde ω = S.propScore false ω := by
obtain ⟨hint, hor⟩ := hmem
filter_upwards [hprop, hint, hor] with ω hq hp hOR
obtain ⟨hqpos, hqlt⟩ := hq
obtain ⟨hppos, hplt⟩ := hp
obtain ⟨hlo, hhi⟩ := hOR
rw [one_div, inv_one] at hlo
have hOReq : OR (etilde ω) (S.propScore false ω) = 1 := le_antisymm hhi hlo
set p := etilde ω with hpdef
set q := S.propScore false ω with hqdef
have h1p : (0:ℝ) < 1 - p := by linarith
have h1q : (0:ℝ) < 1 - q := by linarith
have hqratio : q / (1 - q) ≠ 0 := by
apply div_ne_zero
· exact ne_of_gt hqpos
· exact ne_of_gt h1q
rw [OR, div_eq_one_iff_eq hqratio] at hOReq
field_simp at hOReq
nlinarith [hOReq]
6 supporting declarations (lemmas, instances)
-
sigmaXY0_lelemma — The joint σ-algebra σ(X, Y(0)) is coarser than the ambient σ-algebra on Ω.hypothesesconclusionS.sigmaXY0 ≤ (inferInstance : MeasurableSpace P.Ω)Proof (Lean source)
lemma sigmaXY0_le : S.sigmaXY0 ≤ (inferInstance : MeasurableSpace P.Ω) := by refine sup_le ?_ ?_ · exact S.measurable_factualX.comap_le · exact (S.measurable_YofD false).comap_le -
candMean0_completeProp0_eq_Y0meantheorem — IPW / tower bridge (control arm). Evaluated at the true complete control propensity e₀ = P[D=0 | σ(X, Y(0))], the candidate IPW mean recovers E[Y(0)]. The D=0 reflection of candMean_completeProp_eq_Y1mean.hypothesesγ :sharedType u_1IsFiniteMeasure P.μhcons :P.Consistencyhpos :∀ᵐ ω ∂P.μ, 0 < S.completeProp0 ωhint :Integrable (S.YofD false) P.μhcand_int :Integrable (fun ω => S.dVar.indicator false ω * S.factualY ω / S.completeProp0 ω) P.μconclusionS.candMean0 S.completeProp0 = S.Y0meanProof (Lean source)
theorem candMean0_completeProp0_eq_Y0mean [StandardBorelSpace P.Ω] [IsFiniteMeasure P.μ] (hcons : P.Consistency) (hpos : ∀ᵐ ω ∂P.μ, 0 < S.completeProp0 ω) (hint : Integrable (S.YofD false) P.μ) (hcand_int : Integrable (fun ω => S.dVar.indicator false ω * S.factualY ω / S.completeProp0 ω) P.μ) : S.candMean0 S.completeProp0 = S.Y0mean := by classical set f : P.Ω → ℝ := S.dVar.indicator false with hf_def set e : P.Ω → ℝ := S.completeProp0 with he_def set g : P.Ω → ℝ := fun ω => S.YofD false ω / e ω with hg_def have hcons_fn : (fun ω => S.factualY ω * f ω) = (fun ω => S.YofD false ω * f ω) := by have h := POVar.factual_mul_indicator_eq_cfUnder_mul_indicator_fn hcons S.yVar S.dVar false (Ne.symm S.hDY) funext ω have := congr_fun h ω simpa [POBackdoorSystem.YofD, POBackdoorSystem.factualY, hf_def] using this have hcandMean_eq : S.candMean0 e = ∫ ω, g ω * f ω ∂P.μ := by unfold POBackdoorSystem.candMean0 refine integral_congr_ae (Filter.Eventually.of_forall ?_) intro ω have hcw : S.factualY ω * f ω = S.YofD false ω * f ω := congr_fun hcons_fn ω simp only [hg_def, hf_def] at hcw ⊢ rw [div_eq_mul_inv, div_eq_mul_inv] linear_combination (e ω)⁻¹ * hcw have hY0_meas : Measurable[S.sigmaXY0] (S.YofD false) := by have hle : comap (S.YofD false) inferInstance ≤ S.sigmaXY0 := le_sup_right exact (comap_measurable (S.YofD false)).mono hle le_rfl have he_smeas : StronglyMeasurable[S.sigmaXY0] e := by rw [he_def] exact stronglyMeasurable_condExp have hg_smeas : StronglyMeasurable[S.sigmaXY0] g := by have he_meas : Measurable[S.sigmaXY0] e := he_smeas.measurable exact (hY0_meas.div he_meas).stronglyMeasurable have hf_int : Integrable f P.μ := S.dVar.integrable_indicator false (MeasurableSet.singleton false) have hgf_int : Integrable (fun ω => g ω * f ω) P.μ := by refine hcand_int.congr (Filter.Eventually.of_forall ?_) intro ω have hcw : S.factualY ω * f ω = S.YofD false ω * f ω := congr_fun hcons_fn ω simp only [hg_def, hf_def] at hcw ⊢ rw [div_eq_mul_inv, div_eq_mul_inv] linear_combination (e ω)⁻¹ * hcw have hpull : P.μ[fun ω => g ω * f ω | S.sigmaXY0] =ᵐ[P.μ] (fun ω => g ω * e ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaXY0) (μ := P.μ) hg_smeas hgf_int hf_int have he_cond : (P.μ[f | S.sigmaXY0]) = e := by rw [hf_def, he_def]; rfl refine h.trans ?_ rw [he_cond] rfl have htower : ∫ ω, g ω * f ω ∂P.μ = ∫ ω, g ω * e ω ∂P.μ := by have h1 : ∫ ω, P.μ[fun ω => g ω * f ω | S.sigmaXY0] ω ∂P.μ = ∫ ω, g ω * f ω ∂P.μ := MeasureTheory.integral_condExp S.sigmaXY0_le rw [← h1] exact integral_congr_ae hpull have hcancel : ∫ ω, g ω * e ω ∂P.μ = S.Y0mean := by unfold POBackdoorSystem.Y0mean refine integral_congr_ae ?_ filter_upwards [hpos] with ω hω rw [hg_def] field_simp rw [hcandMean_eq, htower, hcancel] -
completeProp0_mem_MSMSet0theorem — The control MSM assumption: the truth lies in the ambiguity set.hypothesesγ :sharedType u_1Λ :ℝconclusionS.completeProp0 ∈ S.MSMSet0 ΛProof (Lean source)
theorem completeProp0_mem_MSMSet0 (Λ : ℝ) (hMSM : (∀ᵐ ω ∂P.μ, 0 < S.completeProp0 ω ∧ S.completeProp0 ω < 1) ∧ (∀ᵐ ω ∂P.μ, 1 / Λ ≤ OR (S.completeProp0 ω) (S.propScore false ω) ∧ OR (S.completeProp0 ω) (S.propScore false ω) ≤ Λ)) : S.completeProp0 ∈ S.MSMSet0 Λ := by simp only [MSMSet0, Set.mem_setOf_eq] exact hMSM -
MSMSet0_monotheorem — Monotonicity of the control ambiguity set in the sensitivity parameter.hypothesesγ :sharedType u_1Λ Λ' :ℝhΛ :1 ≤ ΛhΛΛ' :Λ ≤ Λ'conclusionS.MSMSet0 Λ ⊆ S.MSMSet0 Λ'Proof (Lean source)
theorem MSMSet0_mono {Λ Λ' : ℝ} (hΛ : 1 ≤ Λ) (hΛΛ' : Λ ≤ Λ') : S.MSMSet0 Λ ⊆ S.MSMSet0 Λ' := by have hΛpos : 0 < Λ := lt_of_lt_of_le one_pos hΛ intro etilde hetilde obtain ⟨hint, hor⟩ := hetilde refine ⟨hint, ?_⟩ filter_upwards [hor] with ω hω obtain ⟨hlo, hhi⟩ := hω constructor · have h1 : 1 / Λ' ≤ 1 / Λ := one_div_le_one_div_of_le hΛpos hΛΛ' exact le_trans h1 hlo · exact le_trans hhi hΛΛ' -
msmUpper0_monotheorem — The control MSM interval widens with Λ (upper endpoint).hypothesesγ :sharedType u_1Λ Λ' :ℝhΛ :1 ≤ ΛhΛΛ' :Λ ≤ Λ'hne :(S.candMean0 '' S.MSMSet0 Λ).Nonemptyhbdd' :BddAbove (S.candMean0 '' S.MSMSet0 Λ')conclusionS.msmUpper0 Λ ≤ S.msmUpper0 Λ'Proof (Lean source)
theorem msmUpper0_mono {Λ Λ' : ℝ} (hΛ : 1 ≤ Λ) (hΛΛ' : Λ ≤ Λ') (hne : (S.candMean0 '' S.MSMSet0 Λ).Nonempty) (hbdd' : BddAbove (S.candMean0 '' S.MSMSet0 Λ')) : S.msmUpper0 Λ ≤ S.msmUpper0 Λ' := by have hsub : S.MSMSet0 Λ ⊆ S.MSMSet0 Λ' := S.MSMSet0_mono hΛ hΛΛ' have himg : S.candMean0 '' S.MSMSet0 Λ ⊆ S.candMean0 '' S.MSMSet0 Λ' := Set.image_mono hsub exact csSup_le_csSup hbdd' hne himg -
msmLower0_antitheorem — The control MSM interval widens with Λ (lower endpoint).hypothesesγ :sharedType u_1Λ Λ' :ℝhΛ :1 ≤ ΛhΛΛ' :Λ ≤ Λ'hne :(S.candMean0 '' S.MSMSet0 Λ).Nonemptyhbdd' :BddBelow (S.candMean0 '' S.MSMSet0 Λ')conclusionS.msmLower0 Λ' ≤ S.msmLower0 ΛProof (Lean source)
theorem msmLower0_anti {Λ Λ' : ℝ} (hΛ : 1 ≤ Λ) (hΛΛ' : Λ ≤ Λ') (hne : (S.candMean0 '' S.MSMSet0 Λ).Nonempty) (hbdd' : BddBelow (S.candMean0 '' S.MSMSet0 Λ')) : S.msmLower0 Λ' ≤ S.msmLower0 Λ := by have hsub : S.MSMSet0 Λ ⊆ S.MSMSet0 Λ' := S.MSMSet0_mono hΛ hΛΛ' have himg : S.candMean0 '' S.MSMSet0 Λ ⊆ S.candMean0 '' S.MSMSet0 Λ' := Set.image_mono hsub exact csInf_le_csInf hbdd' hne himg
ControlSharp 5 core · 5 supporting This file mirrors the treated-arm sharp MSM construction for E[Y(0)]. ★ Y0mean_mem_Icc_calib
Sharp marginal-sensitivity set for the control mean
This file mirrors the treated-arm sharp MSM construction for E[Y(0)]. It
defines the calibrated control ambiguity set, proves that the true control mean
lies in the resulting sharp interval, and relates the calibrated set to the
wider uncalibrated control box.
def Calibrated0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a candidate complete control propensity, the control-arm calibration condition holds when the conditional expectation, given the factual covariate, of the untreated indicator divided by that candidate propensity equals one almost surely.
Definition (Lean source)
parameters
def
Calibrated0 S etilde :
Prop
given by
P.μ[fun ω => S.dVar.indicator false ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => 1)
def MSMSetCalib0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the calibrated control marginal-sensitivity-model ambiguity set consists of candidate complete control propensities that belong to the control ambiguity set and satisfy the control-arm calibration condition.
Definition (Lean source)
parameters
def
given by
{ etilde | etilde ∈ S.MSMSet0 Λ ∧ S.Calibrated0 etilde }
def msmUpperCalib0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the sharp control upper bound is the supremum of the candidate inverse-probability-weighted control means over the calibrated control ambiguity set.
Definition (Lean source)
def msmLowerCalib0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the sharp control lower bound is the infimum of the candidate inverse-probability-weighted control means over the calibrated control ambiguity set.
Definition (Lean source)
theorem Y0mean_mem_Icc_calib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp control bound is valid. For a sensitivity parameter Λ at which the true complete control propensity P[D=0∣σ(X,Y(0))] belongs to the calibrated control ambiguity set, assuming the candidate IPW mean evaluated at the true complete control propensity recovers E[Y(0)] and that the candidate means over the calibrated ambiguity set are bounded below and bounded above, the mean control potential outcome E[Y(0)] lies in the closed interval between the sharp control lower and upper bounds.
Formal statement
Proof (Lean source)
theorem Y0mean_mem_Icc_calib (Λ : ℝ)
(hmem : S.completeProp0 ∈ S.MSMSetCalib0 Λ)
(hbridge : S.candMean0 S.completeProp0 = S.Y0mean)
(hbdd : BddBelow (S.candMean0 '' S.MSMSetCalib0 Λ))
(hbdd' : BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ)) :
S.Y0mean ∈ Icc (S.msmLowerCalib0 Λ) (S.msmUpperCalib0 Λ) := by
have hmemImg : S.candMean0 S.completeProp0 ∈ S.candMean0 '' S.MSMSetCalib0 Λ :=
Set.mem_image_of_mem _ hmem
rw [Set.mem_Icc, ← hbridge]
refine ⟨?_, ?_⟩
· exact csInf_le hbdd hmemImg
· exact le_csSup hbdd' hmemImg
5 supporting declarations (lemmas, instances)
-
completeProp0_calibratedtheorem — The true complete control propensity is calibrated. E[(1−Z) / e₀ | σ(X)] = 1 a.e., where e₀ = P[D=0 | σ(X, Y(0))]. The D=0 reflection of completeProp_calibrated.hypothesesγ :sharedType u_1IsFiniteMeasure P.μhpos :∀ᵐ ω ∂P.μ, 0 < S.completeProp0 ωhint :Integrable (fun ω => S.dVar.indicator false ω / S.completeProp0 ω) P.μconclusionS.Calibrated0 S.completeProp0Proof (Lean source)
theorem completeProp0_calibrated [StandardBorelSpace P.Ω] [IsFiniteMeasure P.μ] (hpos : ∀ᵐ ω ∂P.μ, 0 < S.completeProp0 ω) (hint : Integrable (fun ω => S.dVar.indicator false ω / S.completeProp0 ω) P.μ) : S.Calibrated0 S.completeProp0 := by classical set A : P.Ω → ℝ := S.dVar.indicator false with hA_def set e : P.Ω → ℝ := S.completeProp0 with he_def have hX_le : S.sigmaX ≤ S.sigmaXY0 := by rw [POBackdoorSystem.sigmaX, POBackdoorSystem.sigmaXY0] exact le_sup_left have he_smeas : StronglyMeasurable[S.sigmaXY0] e := by rw [he_def]; exact stronglyMeasurable_condExp have hinv_smeas : StronglyMeasurable[S.sigmaXY0] (fun ω => 1 / e ω) := (measurable_const.div he_smeas.measurable).stronglyMeasurable have hA_int : Integrable A P.μ := S.dVar.integrable_indicator false (measurableSet_singleton false) have hinvA_int : Integrable (fun ω => (1 / e ω) * A ω) P.μ := by refine hint.congr (Filter.Eventually.of_forall ?_) intro ω simp [hA_def, he_def, div_eq_inv_mul] have he_cond : (P.μ[A | S.sigmaXY0]) = e := by rw [hA_def, he_def]; rfl have hpull : P.μ[fun ω => (1 / e ω) * A ω | S.sigmaXY0] =ᵐ[P.μ] (fun ω => (1 / e ω) * e ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaXY0) (μ := P.μ) hinv_smeas hinvA_int hA_int refine h.trans ?_ rw [he_cond] rfl have hcancel : (fun ω => (1 / e ω) * e ω) =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by filter_upwards [hpos] with ω hω rw [he_def] at hω rw [he_def] field_simp have hinner : P.μ[fun ω => A ω / e ω | S.sigmaXY0] =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by have hrw : (fun ω => A ω / e ω) = (fun ω => (1 / e ω) * A ω) := by funext ω; rw [one_div, div_eq_inv_mul] rw [hrw] exact hpull.trans hcancel unfold POBackdoorSystem.Calibrated0 have htower : P.μ[fun ω => A ω / e ω | S.sigmaX] =ᵐ[P.μ] P.μ[P.μ[fun ω => A ω / e ω | S.sigmaXY0] | S.sigmaX] := (MeasureTheory.condExp_condExp_of_le hX_le S.sigmaXY0_le).symm refine htower.trans ?_ have hcongr : P.μ[P.μ[fun ω => A ω / e ω | S.sigmaXY0] | S.sigmaX] =ᵐ[P.μ] P.μ[(fun _ => (1 : ℝ)) | S.sigmaX] := condExp_congr_ae hinner refine hcongr.trans ?_ exact Filter.EventuallyEq.of_eq (MeasureTheory.condExp_const S.sigmaX_le (1 : ℝ)) -
completeProp0_mem_MSMSetCalib0theorem — The true complete control propensity lies in the calibrated set.hypothesesγ :sharedType u_1Λ :ℝhmem :S.completeProp0 ∈ S.MSMSet0 Λhcalib :S.Calibrated0 S.completeProp0conclusionS.completeProp0 ∈ S.MSMSetCalib0 ΛProof (Lean source)
theorem completeProp0_mem_MSMSetCalib0 (Λ : ℝ) (hmem : S.completeProp0 ∈ S.MSMSet0 Λ) (hcalib : S.Calibrated0 S.completeProp0) : S.completeProp0 ∈ S.MSMSetCalib0 Λ := ⟨hmem, hcalib⟩ -
MSMSetCalib0_subsettheorem — The calibrated control set is a subset of the odds-ratio box.hypothesesconclusionS.MSMSetCalib0 Λ ⊆ S.MSMSet0 ΛProof (Lean source)
theorem MSMSetCalib0_subset (Λ : ℝ) : S.MSMSetCalib0 Λ ⊆ S.MSMSet0 Λ := fun _ h => h.1 -
msmUpperCalib0_le_msmUpper0theorem — The sharp control upper bound is tighter than the ZSB bound.hypothesesγ :sharedType u_1Λ :ℝhne :(S.candMean0 '' S.MSMSetCalib0 Λ).Nonemptyhbdd :BddAbove (S.candMean0 '' S.MSMSet0 Λ)conclusionS.msmUpperCalib0 Λ ≤ S.msmUpper0 ΛProof (Lean source)
theorem msmUpperCalib0_le_msmUpper0 (Λ : ℝ) (hne : (S.candMean0 '' S.MSMSetCalib0 Λ).Nonempty) (hbdd : BddAbove (S.candMean0 '' S.MSMSet0 Λ)) : S.msmUpperCalib0 Λ ≤ S.msmUpper0 Λ := by have hsub : S.MSMSetCalib0 Λ ⊆ S.MSMSet0 Λ := S.MSMSetCalib0_subset Λ have himg : S.candMean0 '' S.MSMSetCalib0 Λ ⊆ S.candMean0 '' S.MSMSet0 Λ := Set.image_mono hsub exact csSup_le_csSup hbdd hne himg -
msmLower0_le_msmLowerCalib0theorem — The sharp control lower bound is tighter than the ZSB bound.hypothesesγ :sharedType u_1Λ :ℝhne :(S.candMean0 '' S.MSMSetCalib0 Λ).Nonemptyhbdd :BddBelow (S.candMean0 '' S.MSMSet0 Λ)conclusionS.msmLower0 Λ ≤ S.msmLowerCalib0 ΛProof (Lean source)
theorem msmLower0_le_msmLowerCalib0 (Λ : ℝ) (hne : (S.candMean0 '' S.MSMSetCalib0 Λ).Nonempty) (hbdd : BddBelow (S.candMean0 '' S.MSMSet0 Λ)) : S.msmLower0 Λ ≤ S.msmLowerCalib0 Λ := by have hsub : S.MSMSetCalib0 Λ ⊆ S.MSMSet0 Λ := S.MSMSetCalib0_subset Λ have himg : S.candMean0 '' S.MSMSetCalib0 Λ ⊆ S.candMean0 '' S.MSMSet0 Λ := Set.image_mono hsub exact csInf_le_csInf hbdd hne himg
QuantileBalance 3 core · 0 supporting This file proves the Neyman-Pearson exchange argument behind the sharp treated upper bound in the marginal sensitivity model. ★ cutoff_optimal★ msmUpperCalib_eq_cutoff
Quantile balancing for sharp MSM upper bounds
This file proves the Neyman-Pearson exchange argument behind the sharp treated
upper bound in the marginal sensitivity model. It defines the quantile-cutoff
complete propensity cutoffProp, proves the optimality theorem
cutoff_optimal, and derives msmUpperCalib_eq_cutoff: once the cutoff
candidate is calibrated and feasible, the sharp upper endpoint is exactly its
candidate mean.
def cutoffProp reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, a real-valued cutoff function on the sample space, and a sample point, the treated-arm quantile-cutoff complete propensity is the reciprocal of the largest admissible treated inverse-propensity weight when the factual outcome exceeds the cutoff and of the smallest such weight otherwise.
Definition (Lean source)
parameters
def
cutoffProp S Λ c ω :
ℝ
given by
1 / (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω)
theorem cutoff_optimal reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Optimality of the quantile-cutoff weight (Neyman–Pearson exchange). Fix a sensitivity parameter Λ at least 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). For a σ(X)-measurable, integrable cutoff function c whose induced cutoff candidate is feasible and calibrated, and under envelope-integrability conditions bounding the treated outcome, the treatment-weighted mass, and the cutoff-weighted mass by the upper marginal-sensitivity-model weight, then for any other calibrated, box-feasible candidate complete propensity ẽ that is almost-everywhere measurable, ẽ's candidate mean is at most the cutoff candidate mean — the cutoff weight maximizes the candidate mean among calibrated candidates.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.cutoffProp Λ c ∈ S.MSMSetCalib Λ
henv :
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
etilde :
P.Ω → ℝ
hmem :
etilde ∈ S.MSMSetCalib Λ
hmeas :
AEMeasurable etilde P.μ
conclusion
S.candMean etilde ≤ S.candMean (S.cutoffProp Λ c)
Proof (Lean source)
theorem cutoff_optimal (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.cutoffProp Λ c ∈ S.MSMSetCalib Λ)
(henv : Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
{etilde : P.Ω → ℝ} (hmem : etilde ∈ S.MSMSetCalib Λ)
(hmeas : AEMeasurable etilde P.μ) :
S.candMean etilde ≤ S.candMean (S.cutoffProp Λ c) := by
classical
have _ : Integrable c P.μ := hc_int
have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le one_pos hΛ
set A : P.Ω → ℝ := S.dVar.indicator true with hA_def
set Y : P.Ω → ℝ := S.factualY with hY_def
set e : P.Ω → ℝ := S.propScore true with he_def
set wE : P.Ω → ℝ := fun ω => 1 / etilde ω with hwE_def
set wC : P.Ω → ℝ :=
fun ω => if c ω < Y ω then S.wMax Λ ω else S.wMin Λ ω with hwC_def
have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 →
((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et
∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by
intro e0 et he0 he1 het0 het1
have h1e : 0 < 1 - e0 := by linarith
have h1et : 0 < 1 - et := by linarith
have hOReq : OR et e0 = et * (1 - e0) / ((1 - et) * e0) := by
rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm]
ring_nf
rw [hOReq]
have hMax : (1 / Λ ≤ et * (1 - e0) / ((1 - et) * e0))
↔ (1 / et ≤ 1 + Λ * (1 - e0) / e0) := by
rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + Λ * (1 - e0) / e0 = (e0 + Λ * (1 - e0)) / e0 by
field_simp,
div_le_div_iff₀ het0 he0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
have hMin : (et * (1 - e0) / ((1 - et) * e0) ≤ Λ)
↔ (1 + (1 - e0) / (Λ * e0) ≤ 1 / et) := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + (1 - e0) / (Λ * e0) = (Λ * e0 + (1 - e0)) / (Λ * e0) by
field_simp,
div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e0) het0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
rw [hMax, hMin, and_comm]
have hAm : Measurable A := by
rw [hA_def]
exact S.dVar.measurable_indicator true (MeasurableSet.singleton true)
have hYm : Measurable Y := by
rw [hY_def]
exact S.measurable_factualY
have hem : Measurable e := by
rw [he_def]
unfold POBackdoorSystem.propScore
exact (stronglyMeasurable_condExp.mono S.sigmaX_le).measurable
have hwMaxm : Measurable (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hem)).div hem))
have hwMinm : Measurable (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact (measurable_const.add
((measurable_const.sub hem).div (measurable_const.mul hem)))
have hwCm : Measurable wC := by
rw [hwC_def]
exact Measurable.ite (measurableSet_lt (hc_meas.mono S.sigmaX_le le_rfl) hYm)
hwMaxm hwMinm
have hA0 : ∀ ω, 0 ≤ A ω := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero true ω with h | h <;> simp [hA_def, h]
have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin Λ ω ∧ S.wMin Λ ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap] with ω hω
obtain ⟨he0ω, he1ω⟩ := hω
have h1e : 0 < 1 - e ω := by rw [he_def] at *; linarith
have he0' : 0 < e ω := by rw [he_def] at *; exact he0ω
refine ⟨?_, ?_⟩
· have : 0 < (1 - e ω) / (Λ * e ω) := by positivity
simp only [POBackdoorSystem.wMin, ← he_def]
linarith
· simp only [POBackdoorSystem.wMin, POBackdoorSystem.wMax, ← he_def]
have hd1 : (1 - e ω) / (Λ * e ω) ≤ Λ * (1 - e ω) / e ω := by
rw [div_le_div_iff₀ (by positivity) he0']
nlinarith [hΛ, mul_pos h1e he0', mul_pos hΛ0 he0',
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0')) (sub_nonneg.mpr hΛ)]
linarith
have hboxE : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ wE ω ∧ wE ω ≤ S.wMax Λ ω := by
obtain ⟨hinterior, hor⟩ := hmem.1
filter_upwards [hoverlap, hinterior, hor] with ω hov het hOR
obtain ⟨he0ω, he1ω⟩ := hov
obtain ⟨het0, het1⟩ := het
have hbox := (hOR_box he0ω he1ω het0 het1).mp hOR
simpa [POBackdoorSystem.wMin, POBackdoorSystem.wMax, he_def, hwE_def] using hbox
have hboxC : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ wC ω ∧ wC ω ≤ S.wMax Λ ω ∧ 0 < wC ω := by
filter_upwards [hae] with ω hω
obtain ⟨hmin1, hminmax⟩ := hω
rw [hwC_def]
by_cases hcy : c ω < Y ω
· simp only [if_pos hcy]
exact ⟨hminmax, le_rfl, lt_of_lt_of_le (by linarith) hminmax⟩
· simp only [if_neg hcy]
exact ⟨le_rfl, hminmax, by linarith⟩
have hYE_int : Integrable (fun ω => A ω * Y ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by
rw [hwE_def]
exact aemeasurable_const.div hmeas
refine Integrable.mono' henv
(((hAm.mul hYm).aemeasurable.mul hwE_aem).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hYC_int : Integrable (fun ω => A ω * Y ω * wC ω) P.μ := by
refine Integrable.mono' henv
(((hAm.mul hYm).mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hXE_int : Integrable (fun ω => A ω / etilde ω) P.μ := by
refine Integrable.mono' hweight_env
((hAm.aemeasurable.div hmeas).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_div, abs_of_nonneg (hA0 ω), abs_of_pos het0,
div_eq_mul_inv, ← one_div, hA_def]
simpa [hA_def, hwE_def] using mul_le_mul_of_nonneg_left hmax (hA0 ω)
have hXC_int : Integrable (fun ω => A ω / S.cutoffProp Λ c ω) P.μ := by
have hAwC_int : Integrable (fun ω => A ω * wC ω) P.μ := by
refine Integrable.mono' hweight_env ((hAm.mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (hA0 ω), abs_of_nonneg (le_of_lt hpos)]
exact mul_le_mul_of_nonneg_left hmax (hA0 ω)
refine hAwC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change A ω * wC ω =
A ω / (1 / (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
have hcE_int : Integrable (fun ω => c ω * A ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by
rw [hwE_def]
exact aemeasurable_const.div hmeas
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).aemeasurable.mul hwE_aem).aestronglyMeasurable ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
simpa [mul_assoc, hwE_def, one_div] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hcC_int : Integrable (fun ω => c ω * A ω * wC ω) P.μ := by
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).mul hwCm).aestronglyMeasurable ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
simpa [mul_assoc] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hfirstE_int : Integrable (fun ω => A ω * (Y ω - c ω) * wE ω) P.μ := by
refine (hYE_int.sub hcE_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wE ω - c ω * A ω * wE ω = A ω * (Y ω - c ω) * wE ω
ring
have hfirstC_int : Integrable (fun ω => A ω * (Y ω - c ω) * wC ω) P.μ := by
refine (hYC_int.sub hcC_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wC ω - c ω * A ω * wC ω = A ω * (Y ω - c ω) * wC ω
ring
have hctermE_eq : ∫ ω, c ω * A ω * wE ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / etilde ω)) P.μ := by
refine hcE_int.congr (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω => c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXE_int
have hcal : P.μ[fun ω => A ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated, hA_def] using hmem.2
have hmain : ∫ ω, c ω * (A ω / etilde ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / etilde ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
calc
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω ∂P.μ :=
integral_congr_ae hpull
_ = ∫ ω, c ω * 1 ∂P.μ := by
refine integral_congr_ae ?_
filter_upwards [hcal] with ω hω
rw [hω]
_ = ∫ ω, c ω ∂P.μ := by simp
rw [← hmain]
refine integral_congr_ae (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hctermC_eq : ∫ ω, c ω * A ω * wC ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / S.cutoffProp Λ c ω)) P.μ := by
refine hcC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change c ω * A ω * wC ω =
c ω * (A ω / (1 / (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω)))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / S.cutoffProp Λ c ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω =>
c ω * P.μ[fun ω => A ω / S.cutoffProp Λ c ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXC_int
have hcal :
P.μ[fun ω => A ω / S.cutoffProp Λ c ω | S.sigmaX]
=ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated, hA_def] using hcut_mem.2
have hmain :
∫ ω, c ω * (A ω / S.cutoffProp Λ c ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / S.cutoffProp Λ c ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / S.cutoffProp Λ c ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
-- … truncated; follow the source link for the rest …
theorem msmUpperCalib_eq_cutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp upper bound has the quantile-balancing closed form. Fix a sensitivity parameter Λ at least 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). For a σ(X)-measurable, integrable cutoff function c whose induced cutoff candidate is feasible and calibrated, under envelope-integrability conditions bounding the treated outcome, the treatment-weighted mass, and the cutoff-weighted mass by the upper marginal-sensitivity-model weight, and assuming every candidate complete propensity in the calibrated ambiguity set is almost-everywhere measurable, then the sharp upper bound on E[Y(1)] equals the candidate mean of the cutoff propensity built from c.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.cutoffProp Λ c ∈ S.MSMSetCalib Λ
henv :
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hmeas :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
conclusion
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c)
Proof (Lean source)
theorem msmUpperCalib_eq_cutoff (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.cutoffProp Λ c ∈ S.MSMSetCalib Λ)
(henv : Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hmeas : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ) :
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c) := by
classical
have hne : (S.candMean '' S.MSMSetCalib Λ).Nonempty :=
⟨S.candMean (S.cutoffProp Λ c), Set.mem_image_of_mem _ hcut_mem⟩
have hle_all :
∀ x ∈ S.candMean '' S.MSMSetCalib Λ,
x ≤ S.candMean (S.cutoffProp Λ c) := by
rintro x ⟨etilde, hmem, rfl⟩
exact S.cutoff_optimal Λ hΛ hoverlap c hc_meas hc_int hcut_mem henv hweight_env hc_env
hmem (hmeas etilde hmem)
have hbdd : BddAbove (S.candMean '' S.MSMSetCalib Λ) :=
⟨S.candMean (S.cutoffProp Λ c), hle_all⟩
refine le_antisymm ?_ ?_
· unfold POBackdoorSystem.msmUpperCalib
exact csSup_le hne hle_all
· unfold POBackdoorSystem.msmUpperCalib
exact le_csSup hbdd (Set.mem_image_of_mem _ hcut_mem)
ControlCutoff 13 core · 0 supporting This file is the control-arm mirror of the treated cutoff-selection and calibration-bracket development: the cutoff propensity uses the untreated indicator and the control propensity P[D=0 | X], decomposes its conditiona ★ wMin0_mul_propScore_le_one★ one_le_wMax0_mul_propScore★ condExp_control_wMin0_eq★ condExp_control_wMax0_eq★ control_calibValue_eq★ controlCutoffProp_calibrated_of_survival★ cutoffProp0_mem_MSMSet0★ cutoffProp0_mem_MSMSetCalib0_of_survival
Marginal Sensitivity Model — control cutoff calibration
This file is the control-arm mirror of the treated cutoff-selection and calibration-bracket
development: the cutoff propensity uses the untreated indicator and the control propensity
P[D=0 | X], decomposes its conditional calibration value into a minimum-weight term plus a
conditional control-survival term, and reduces calibrated membership in the sharp control MSM set to
the corresponding conditional-survival equation.
It defines the control endpoint weights wMin0 and wMax0, the upper-cutoff
candidate cutoffProp0, the survival target survTarget0, and the conditional
survival functional controlSurv. The main theorems are the calibration
bracket lemmas, control_calibValue_eq, controlCutoffProp_calibrated_of_survival,
cutoffProp0_mem_MSMSet0, and cutoffProp0_mem_MSMSetCalib0_of_survival.
def wMin0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, and a sample point, the smallest admissible control inverse-propensity weight is , where is the probability of the control arm conditional on the covariates.
Definition (Lean source)
parameters
def
wMin0 S Λ ω :
ℝ
def wMax0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, and a sample point, the largest admissible control inverse-propensity weight is , where is the probability of the control arm conditional on the covariates.
Definition (Lean source)
parameters
def
wMax0 S Λ ω :
ℝ
def cutoffProp0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, a real-valued cutoff function on the sample space, and a sample point, the control quantile-cutoff complete propensity is the reciprocal of the largest admissible control inverse-propensity weight when the factual outcome exceeds the cutoff and of the smallest such weight otherwise.
Definition (Lean source)
parameters
def
cutoffProp0 S Λ c ω :
ℝ
given by
1 / (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω)
def controlSurv reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system and a real-valued cutoff function on the sample space, the conditional control-survival function assigns to each sample point the conditional expectation, given the covariates, of the control-arm indicator times the indicator that the factual outcome exceeds the cutoff at that point.
Definition (Lean source)
parameters
def
controlSurv S c :
P.Ω → ℝ
given by
P.μ[fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX]
def survTarget0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, and a sample point, the target control-survival probability is , where is the control propensity score.
Definition (Lean source)
parameters
def
survTarget0 S Λ ω :
ℝ
given by
(1 - S.wMin0 Λ ω * S.propScore false ω) / (S.wMax0 Λ ω - S.wMin0 Λ ω)
theorem wMin0_mul_propScore_le_one reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Lower control calibration bracket is at most one. Fix a sensitivity parameter Λ at least 1. If the control propensity P[D=0∣X] lies strictly between 0 and 1 almost everywhere (overlap), then almost everywhere the lower calibration weight wMin0 Λ times the control propensity is at most 1.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
conclusion
∀ᵐ ω ∂P.μ, S.wMin0 Λ ω * S.propScore false ω ≤ 1
Proof (Lean source)
theorem wMin0_mul_propScore_le_one (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) :
∀ᵐ ω ∂P.μ, S.wMin0 Λ ω * S.propScore false ω ≤ 1 := by
have hΛ0 : 0 < Λ := lt_of_lt_of_le zero_lt_one hΛ
filter_upwards [hoverlap] with ω hω
set e : ℝ := S.propScore false ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have hw :
S.wMin0 Λ ω * S.propScore false ω = e + (1 - e) / Λ := by
simp only [POBackdoorSystem.wMin0, ← he_def]
field_simp [hΛ0.ne', he0.ne']
have hdiv : (1 - e) / Λ ≤ 1 - e := by
rw [div_le_iff₀ hΛ0]
nlinarith [hΛ, le_of_lt he1]
calc
S.wMin0 Λ ω * S.propScore false ω = e + (1 - e) / Λ := hw
_ ≤ e + (1 - e) := by linarith
_ = 1 := by ring
theorem one_le_wMax0_mul_propScore reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Upper control calibration bracket is at least one. Fix a sensitivity parameter Λ at least 1. If the control propensity P[D=0∣X] lies strictly between 0 and 1 almost everywhere (overlap), then almost everywhere the upper calibration weight wMax0 Λ times the control propensity is at least 1.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
conclusion
∀ᵐ ω ∂P.μ, 1 ≤ S.wMax0 Λ ω * S.propScore false ω
Proof (Lean source)
theorem one_le_wMax0_mul_propScore (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) :
∀ᵐ ω ∂P.μ, 1 ≤ S.wMax0 Λ ω * S.propScore false ω := by
filter_upwards [hoverlap] with ω hω
set e : ℝ := S.propScore false ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have hw :
S.wMax0 Λ ω * S.propScore false ω = e + Λ * (1 - e) := by
simp only [POBackdoorSystem.wMax0, ← he_def]
field_simp [he0.ne']
have hmul : 1 - e ≤ Λ * (1 - e) := by
nlinarith [hΛ, le_of_lt he1]
calc
1 = e + (1 - e) := by ring
_ ≤ e + Λ * (1 - e) := by linarith
_ = S.wMax0 Λ ω * S.propScore false ω := hw.symm
theorem condExp_control_wMin0_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
All-lower-weight control calibration value. For a sensitivity parameter Λ, if the product of the control indicator 1{D=0} and the lower calibration weight wMin0 Λ is integrable, then the conditional expectation of that product given the covariate σ-algebra equals, almost everywhere, the lower weight times the control propensity P[D=0∣X].
Formal statement
hypotheses
Proof (Lean source)
theorem condExp_control_wMin0_eq (Λ : ℝ)
(hint : Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ) :
P.μ[fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin0 Λ ω * S.propScore false ω) := by
have hprop_meas : Measurable[S.sigmaX] (S.propScore false) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hw_smeas : StronglyMeasurable[S.sigmaX] (S.wMin0 Λ) := by
unfold POBackdoorSystem.wMin0
exact (measurable_const.add
((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas))).stronglyMeasurable
have hind_int : Integrable (S.dVar.indicator false) P.μ :=
S.dVar.integrable_indicator false (measurableSet_singleton false)
have hcomm :
(fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω)
= (fun ω => S.wMin0 Λ ω * S.dVar.indicator false ω) := by
funext ω
exact mul_comm _ _
refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ)
(Filter.EventuallyEq.of_eq hcomm)).trans ?_
have hpull :
P.μ[fun ω => S.wMin0 Λ ω * S.dVar.indicator false ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin0 Λ ω * P.μ[S.dVar.indicator false | S.sigmaX] ω) :=
MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hw_smeas (hint.congr (Filter.EventuallyEq.of_eq hcomm))
hind_int
exact hpull.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
theorem condExp_control_wMax0_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
All-upper-weight control calibration value. For a sensitivity parameter Λ, if the product of the control indicator 1{D=0} and the upper calibration weight wMax0 Λ is integrable, then the conditional expectation of that product given the covariate σ-algebra equals, almost everywhere, the upper weight times the control propensity P[D=0∣X].
Formal statement
hypotheses
Proof (Lean source)
theorem condExp_control_wMax0_eq (Λ : ℝ)
(hint : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) :
P.μ[fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMax0 Λ ω * S.propScore false ω) := by
have hprop_meas : Measurable[S.sigmaX] (S.propScore false) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hw_smeas : StronglyMeasurable[S.sigmaX] (S.wMax0 Λ) := by
unfold POBackdoorSystem.wMax0
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas)).stronglyMeasurable
have hind_int : Integrable (S.dVar.indicator false) P.μ :=
S.dVar.integrable_indicator false (measurableSet_singleton false)
have hcomm :
(fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω)
= (fun ω => S.wMax0 Λ ω * S.dVar.indicator false ω) := by
funext ω
exact mul_comm _ _
refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ)
(Filter.EventuallyEq.of_eq hcomm)).trans ?_
have hpull :
P.μ[fun ω => S.wMax0 Λ ω * S.dVar.indicator false ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMax0 Λ ω * P.μ[S.dVar.indicator false | S.sigmaX] ω) :=
MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hw_smeas (hint.congr (Filter.EventuallyEq.of_eq hcomm))
hind_int
exact hpull.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
theorem control_calibValue_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Cutoff control calibration value decomposes into a lower bracket plus a survival term. Fix a sensitivity parameter Λ and a cutoff function c measurable with respect to the covariate σ-algebra. If the ratio of the control indicator 1{D=0} to the cutoff-calibration weight cutoffProp0 Λ c is integrable, the product of the control indicator and the survival-cutoff indicator 1{c<Y} is integrable, the product of the control indicator and the lower weight wMin0 Λ is integrable, and the product of the weight spread wMax0 Λ - wMin0 Λ with the control-indicator survival term is integrable, then the conditional expectation, given the covariate σ-algebra, of the control indicator divided by the cutoff-calibration weight equals, almost everywhere, the lower weight times the control propensity plus the weight spread times the conditional control-survival functional controlSurv c.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
c :
P.Ω → ℝ
_hc_meas :
Measurable[S.sigmaX] c
_hint :
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ
hint1 :
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ
hmin_int :
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ
hdiff_int :
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ
Proof (Lean source)
theorem control_calibValue_eq (Λ : ℝ) (c : P.Ω → ℝ) (_hc_meas : Measurable[S.sigmaX] c)
(_hint : Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ)
(hint1 : Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ)
(hmin_int : Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ)
(hdiff_int : Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) :
P.μ[fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin0 Λ ω * S.propScore false ω
+ (S.wMax0 Λ ω - S.wMin0 Λ ω) * S.controlSurv c ω) := by
classical
set A : P.Ω → ℝ := S.dVar.indicator false with hA_def
set I : P.Ω → ℝ := fun ω => if c ω < S.factualY ω then (1 : ℝ) else 0 with hI_def
have hprop_meas : Measurable[S.sigmaX] (S.propScore false) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hwMin_smeas : StronglyMeasurable[S.sigmaX] (S.wMin0 Λ) := by
unfold POBackdoorSystem.wMin0
exact (measurable_const.add
((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas))).stronglyMeasurable
have hwMax_smeas : StronglyMeasurable[S.sigmaX] (S.wMax0 Λ) := by
unfold POBackdoorSystem.wMax0
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas)).stronglyMeasurable
have hdiff_smeas : StronglyMeasurable[S.sigmaX] (fun ω => S.wMax0 Λ ω - S.wMin0 Λ ω) :=
(hwMax_smeas.measurable.sub hwMin_smeas.measurable).stronglyMeasurable
have hA_int : Integrable A P.μ := by
rw [hA_def]
exact S.dVar.integrable_indicator false (measurableSet_singleton false)
have hI_int : Integrable (fun ω => A ω * I ω) P.μ := by
rw [hA_def, hI_def]
exact hint1
have hmin_int' : Integrable (fun ω => S.wMin0 Λ ω * A ω) P.μ := by
refine hmin_int.congr (Filter.Eventually.of_forall ?_)
intro ω
rw [hA_def]
exact mul_comm _ _
have hpoint :
(fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω)
=ᵐ[P.μ] (fun ω => S.wMin0 Λ ω * A ω
+ (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω)) := by
refine Filter.Eventually.of_forall ?_
intro ω
rw [hA_def, hI_def]
by_cases hcy : c ω < S.factualY ω
· simp only [POBackdoorSystem.cutoffProp0, if_pos hcy]
rw [div_div_eq_mul_div, div_one]
ring
· simp only [POBackdoorSystem.cutoffProp0, if_neg hcy]
rw [div_div_eq_mul_div, div_one]
ring
refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_
have hsplit :
P.μ[fun ω => S.wMin0 Λ ω * A ω
+ (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX]
=ᵐ[P.μ]
P.μ[fun ω => S.wMin0 Λ ω * A ω | S.sigmaX]
+ P.μ[fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX] :=
MeasureTheory.condExp_add hmin_int' hdiff_int S.sigmaX
have hpullMin :
P.μ[fun ω => S.wMin0 Λ ω * A ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin0 Λ ω * S.propScore false ω) := by
have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hwMin_smeas hmin_int' hA_int
exact h.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
have hpullDiff :
P.μ[fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * S.controlSurv c ω) := by
have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hdiff_smeas hdiff_int hI_int
exact h.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
filter_upwards [hsplit, hpullMin, hpullDiff] with ω hsplitω hminω hdiffω
rw [hsplitω]
change P.μ[fun ω => S.wMin0 Λ ω * A ω | S.sigmaX] ω
+ P.μ[fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX] ω
= S.wMin0 Λ ω * S.propScore false ω + (S.wMax0 Λ ω - S.wMin0 Λ ω) * S.controlSurv c ω
rw [hminω, hdiffω]
theorem controlCutoffProp_calibrated_of_survival reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
A cutoff solving the target control-survival equation is calibrated. Fix a sensitivity parameter Λ strictly greater than 1. If the control propensity P[D=0∣X] lies strictly between 0 and 1 almost everywhere (overlap), the cutoff function c is measurable with respect to the covariate σ-algebra, the ratio of the control indicator 1{D=0} to the cutoff-calibration weight cutoffProp0 Λ c is integrable, the product of the control indicator and the survival-cutoff indicator 1{c<Y} is integrable, the product of the control indicator and the lower weight wMin0 Λ is integrable, the product of the weight spread with the control-indicator survival term is integrable, and the conditional control-survival functional at c equals, almost everywhere, the target survival value survTarget0 Λ, then the cutoff-calibration propensity cutoffProp0 Λ c is calibrated: the conditional expectation of the control indicator divided by it, given the covariates, equals 1 almost everywhere.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hint :
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ
hint1 :
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ
hmin_int :
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ
hdiff_int :
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ
hsurv :
S.controlSurv c =ᵐ[P.μ] S.survTarget0 Λ
conclusion
S.Calibrated0 (S.cutoffProp0 Λ c)
Proof (Lean source)
theorem controlCutoffProp_calibrated_of_survival (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c)
(hint : Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ)
(hint1 : Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ)
(hmin_int : Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ)
(hdiff_int : Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ)
(hsurv : S.controlSurv c =ᵐ[P.μ] S.survTarget0 Λ) :
S.Calibrated0 (S.cutoffProp0 Λ c) := by
unfold POBackdoorSystem.Calibrated0
have hΛ0 : 0 < Λ := lt_trans zero_lt_one hΛ
refine (S.control_calibValue_eq Λ c hc_meas hint hint1 hmin_int hdiff_int).trans ?_
filter_upwards [hoverlap, hsurv] with ω hω hsurvω
rw [hsurvω]
set e : ℝ := S.propScore false ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have hdiff_pos : 0 < S.wMax0 Λ ω - S.wMin0 Λ ω := by
simp only [POBackdoorSystem.wMax0, POBackdoorSystem.wMin0, ← he_def]
have h1e : 0 < 1 - e := by linarith
have hΛsq : 0 < Λ * Λ - 1 := by nlinarith
field_simp [hΛ0.ne', he0.ne']
nlinarith [h1e, hΛsq, hΛ0, he0]
have hdiff_ne : S.wMax0 Λ ω - S.wMin0 Λ ω ≠ 0 := hdiff_pos.ne'
unfold POBackdoorSystem.survTarget0
field_simp [hdiff_ne]
ring
theorem cutoffProp0_mem_MSMSet0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The control cutoff propensity always lies inside the control odds-ratio box. Fix a sensitivity parameter Λ at least 1 and a cutoff function c. If the control propensity P[D=0∣X] lies strictly between 0 and 1 almost everywhere (overlap), then the cutoff-calibration candidate propensity cutoffProp0 Λ c always belongs to the control marginal-sensitivity-model ambiguity set MSMSet0 Λ.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
conclusion
S.cutoffProp0 Λ c ∈ S.MSMSet0 Λ
Proof (Lean source)
theorem cutoffProp0_mem_MSMSet0 (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) :
S.cutoffProp0 Λ c ∈ S.MSMSet0 Λ := by
classical
have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le zero_lt_one hΛ
have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 →
((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et
∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by
intro e et he0 he1 het0 het1
have h1e : 0 < 1 - e := by linarith
have h1et : 0 < 1 - et := by linarith
have hOReq : OR et e = et * (1 - e) / ((1 - et) * e) := by
rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm]
ring_nf
rw [hOReq]
have hMax : (1 / Λ ≤ et * (1 - e) / ((1 - et) * e))
↔ (1 / et ≤ 1 + Λ * (1 - e) / e) := by
rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e),
show (1 : ℝ) + Λ * (1 - e) / e = (e + Λ * (1 - e)) / e by
field_simp,
div_le_div_iff₀ het0 he0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
have hMin : (et * (1 - e) / ((1 - et) * e) ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et) := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e),
show (1 : ℝ) + (1 - e) / (Λ * e) = (Λ * e + (1 - e)) / (Λ * e) by
field_simp,
div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e) het0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
rw [hMax, hMin, and_comm]
have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin0 Λ ω ∧ S.wMin0 Λ ω ≤ S.wMax0 Λ ω := by
filter_upwards [hoverlap] with ω hω
set e : ℝ := S.propScore false ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have h1e : 0 < 1 - e := by linarith
refine ⟨?_, ?_⟩
· have : 0 < (1 - e) / (Λ * e) := by positivity
simp only [POBackdoorSystem.wMin0, ← he_def]
linarith
· simp only [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, ← he_def]
have hd1 : (1 - e) / (Λ * e) ≤ Λ * (1 - e) / e := by
rw [div_le_div_iff₀ (by positivity) he0]
nlinarith [hΛ, mul_pos h1e he0, mul_pos hΛ0 he0,
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0)) (sub_nonneg.mpr hΛ)]
linarith
have hboxC : ∀ᵐ ω ∂P.μ,
S.wMin0 Λ ω ≤ (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω)
∧ (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω) ≤ S.wMax0 Λ ω
∧ 1 < (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω) := by
filter_upwards [hae] with ω hω
obtain ⟨hmin1, hminmax⟩ := hω
by_cases hcy : c ω < S.factualY ω
· simp only [if_pos hcy]
exact ⟨hminmax, le_rfl, lt_of_lt_of_le hmin1 hminmax⟩
· simp only [if_neg hcy]
exact ⟨le_rfl, hminmax, hmin1⟩
refine ⟨?_, ?_⟩
· filter_upwards [hboxC] with ω hω
obtain ⟨_, _, hwgt⟩ := hω
unfold POBackdoorSystem.cutoffProp0
constructor
· positivity
· rw [div_lt_one (by linarith)]
linarith
· filter_upwards [hoverlap, hboxC] with ω hov hw
obtain ⟨he0, he1⟩ := hov
obtain ⟨hmin, hmax, hwgt⟩ := hw
set wC : ℝ := if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω with hwC_def
have hcut : S.cutoffProp0 Λ c ω = 1 / wC := by
rw [POBackdoorSystem.cutoffProp0, hwC_def]
have het0 : 0 < S.cutoffProp0 Λ c ω := by
rw [hcut]
positivity
have het1 : S.cutoffProp0 Λ c ω < 1 := by
rw [hcut, div_lt_one (by linarith)]
linarith
rw [(hOR_box he0 he1 het0 het1)]
have hinv : 1 / S.cutoffProp0 Λ c ω = wC := by
rw [hcut, one_div_one_div]
rw [hinv]
simpa [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, hwC_def] using ⟨hmin, hmax⟩
theorem cutoffProp0_mem_MSMSetCalib0_of_survival reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The cutoff belongs to the calibrated control MSM set whenever it solves the target control-survival equation. Fix a sensitivity parameter Λ strictly greater than 1. If the control propensity P[D=0∣X] lies strictly between 0 and 1 almost everywhere (overlap), the cutoff function c is measurable with respect to the covariate σ-algebra, the ratio of the control indicator 1{D=0} to the cutoff-calibration weight cutoffProp0 Λ c is integrable, the product of the control indicator and the survival-cutoff indicator 1{c<Y} is integrable, the product of the control indicator and the lower weight wMin0 Λ is integrable, the product of the weight spread with the control-indicator survival term is integrable, and the conditional control-survival functional at c equals, almost everywhere, the target survival value survTarget0 Λ, then the cutoff-calibration propensity cutoffProp0 Λ c belongs to the calibrated control MSM set MSMSetCalib0 Λ.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hint :
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ
hint1 :
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ
hmin_int :
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ
hdiff_int :
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ
hsurv :
S.controlSurv c =ᵐ[P.μ] S.survTarget0 Λ
conclusion
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
Proof (Lean source)
theorem cutoffProp0_mem_MSMSetCalib0_of_survival (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c)
(hint : Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ)
(hint1 : Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ)
(hmin_int : Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ)
(hdiff_int : Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ)
(hsurv : S.controlSurv c =ᵐ[P.μ] S.survTarget0 Λ) :
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ :=
⟨S.cutoffProp0_mem_MSMSet0 Λ (le_of_lt hΛ) hoverlap c,
S.controlCutoffProp_calibrated_of_survival Λ hΛ hoverlap c hc_meas hint hint1
hmin_int hdiff_int hsurv⟩
CutoffSelection 4 core · 2 supporting This file reduces calibrated feasibility of the upper MSM cutoff to one conditional-survival equation. ★ cutoff_calibValue_eq★ cutoffProp_mem_MSMSet
Sharp treated-arm upper bound from calibrated cutoffs
This file reduces calibrated feasibility of the upper MSM cutoff to one
conditional-survival equation. It defines treatedSurv and survTarget, proves
the calibration decomposition cutoff_calibValue_eq, derives
cutoffProp_calibrated_of_survival, proves every cutoff propensity lies in the
odds-ratio box via cutoffProp_mem_MSMSet, and packages both facts as
cutoffProp_mem_MSMSetCalib_of_survival.
def treatedSurv reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes backdoor system and a real-valued cutoff function on its sample space, the conditional treated-survival function assigns each unit the conditional expectation, given its covariates, of the treatment indicator times the indicator that its factual outcome exceeds its cutoff.
Definition (Lean source)
parameters
def
treatedSurv S c :
P.Ω → ℝ
given by
P.μ[fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX]
def survTarget reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes backdoor system, a real sensitivity level, and a unit in its sample space, the target survival probability for cutoff calibration is , where is the unit's treated propensity score and are its endpoint weights.
Definition (Lean source)
parameters
def
survTarget S Λ ω :
ℝ
given by
(1 - S.wMin Λ ω * S.propScore true ω) / (S.wMax Λ ω - S.wMin Λ ω)
theorem cutoff_calibValue_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Decomposition of the cutoff calibration value. For a σ(X)-measurable cutoff function c, assume the treatment indicator divided by the cutoff propensity is integrable, the treated-survival indicator, weighted by the treatment indicator, is integrable, the product of the treatment indicator and the lower marginal-sensitivity-model weight wMin is integrable, and the gap between the upper and lower weights, weighted by the treatment-weighted treated-survival indicator, is integrable. Then pulling the σ(X)-measurable weights wMin, wMax out of the conditional expectation decomposes the cutoff calibration value: E[Z/cutoffProp Λ c | σ(X)] = wMin·e + (wMax − wMin)·G(c), where G(c) is the conditional treated-survival at cutoff c.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
c :
P.Ω → ℝ
_hc_meas :
Measurable[S.sigmaX] c
_hint :
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ
hint1 :
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ
hmin_int :
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ
hdiff_int :
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ
Proof (Lean source)
theorem cutoff_calibValue_eq (Λ : ℝ) (c : P.Ω → ℝ) (_hc_meas : Measurable[S.sigmaX] c)
(_hint : Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ)
(hint1 : Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ)
(hmin_int : Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ)
(hdiff_int : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) :
P.μ[fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin Λ ω * S.propScore true ω
+ (S.wMax Λ ω - S.wMin Λ ω) * S.treatedSurv c ω) := by
classical
set A : P.Ω → ℝ := S.dVar.indicator true with hA_def
set I : P.Ω → ℝ := fun ω => if c ω < S.factualY ω then (1 : ℝ) else 0 with hI_def
have hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hwMin_smeas : StronglyMeasurable[S.sigmaX] (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact (measurable_const.add
((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas))).stronglyMeasurable
have hwMax_smeas : StronglyMeasurable[S.sigmaX] (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas)).stronglyMeasurable
have hdiff_smeas : StronglyMeasurable[S.sigmaX] (fun ω => S.wMax Λ ω - S.wMin Λ ω) :=
(hwMax_smeas.measurable.sub hwMin_smeas.measurable).stronglyMeasurable
have hA_int : Integrable A P.μ := by
rw [hA_def]
exact S.dVar.integrable_indicator true (measurableSet_singleton true)
have hI_int : Integrable (fun ω => A ω * I ω) P.μ := by
rw [hA_def, hI_def]
exact hint1
have hmin_int' : Integrable (fun ω => S.wMin Λ ω * A ω) P.μ := by
refine hmin_int.congr (Filter.Eventually.of_forall ?_)
intro ω
rw [hA_def]
exact mul_comm _ _
have hpoint :
(fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω)
=ᵐ[P.μ] (fun ω => S.wMin Λ ω * A ω
+ (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω)) := by
refine Filter.Eventually.of_forall ?_
intro ω
rw [hA_def, hI_def]
by_cases hcy : c ω < S.factualY ω
· simp only [POBackdoorSystem.cutoffProp, if_pos hcy]
rw [div_div_eq_mul_div, div_one]
ring
· simp only [POBackdoorSystem.cutoffProp, if_neg hcy]
rw [div_div_eq_mul_div, div_one]
ring
refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_
have hsplit :
P.μ[fun ω => S.wMin Λ ω * A ω
+ (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX]
=ᵐ[P.μ]
P.μ[fun ω => S.wMin Λ ω * A ω | S.sigmaX]
+ P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX] :=
MeasureTheory.condExp_add hmin_int' hdiff_int S.sigmaX
have hpullMin :
P.μ[fun ω => S.wMin Λ ω * A ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin Λ ω * S.propScore true ω) := by
have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hwMin_smeas hmin_int' hA_int
exact h.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
have hpullDiff :
P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * S.treatedSurv c ω) := by
have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hdiff_smeas hdiff_int hI_int
exact h.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
filter_upwards [hsplit, hpullMin, hpullDiff] with ω hsplitω hminω hdiffω
rw [hsplitω]
change P.μ[fun ω => S.wMin Λ ω * A ω | S.sigmaX] ω
+ P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX] ω
= S.wMin Λ ω * S.propScore true ω + (S.wMax Λ ω - S.wMin Λ ω) * S.treatedSurv c ω
rw [hminω, hdiffω]
theorem cutoffProp_mem_MSMSet reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The cutoff propensity is always in the odds-ratio box. Fix a sensitivity parameter Λ at least 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). Then for any measurable cutoff function c, the induced cutoff propensity always lies in the marginal-sensitivity-model odds-ratio ambiguity set, since at each point it equals either the lower or the upper marginal-sensitivity-model weight.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
conclusion
S.cutoffProp Λ c ∈ S.MSMSet Λ
Proof (Lean source)
theorem cutoffProp_mem_MSMSet (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(c : P.Ω → ℝ) :
S.cutoffProp Λ c ∈ S.MSMSet Λ := by
classical
have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le zero_lt_one hΛ
have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 →
((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et
∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by
intro e et he0 he1 het0 het1
have h1e : 0 < 1 - e := by linarith
have h1et : 0 < 1 - et := by linarith
have hOReq : OR et e = et * (1 - e) / ((1 - et) * e) := by
rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm]
ring_nf
rw [hOReq]
have hMax : (1 / Λ ≤ et * (1 - e) / ((1 - et) * e))
↔ (1 / et ≤ 1 + Λ * (1 - e) / e) := by
rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e),
show (1 : ℝ) + Λ * (1 - e) / e = (e + Λ * (1 - e)) / e by
field_simp,
div_le_div_iff₀ het0 he0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
have hMin : (et * (1 - e) / ((1 - et) * e) ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et) := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e),
show (1 : ℝ) + (1 - e) / (Λ * e) = (Λ * e + (1 - e)) / (Λ * e) by
field_simp,
div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e) het0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
rw [hMax, hMin, and_comm]
have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin Λ ω ∧ S.wMin Λ ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap] with ω hω
set e : ℝ := S.propScore true ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have h1e : 0 < 1 - e := by linarith
refine ⟨?_, ?_⟩
· have : 0 < (1 - e) / (Λ * e) := by positivity
simp only [POBackdoorSystem.wMin, ← he_def]
linarith
· simp only [POBackdoorSystem.wMin, POBackdoorSystem.wMax, ← he_def]
have hd1 : (1 - e) / (Λ * e) ≤ Λ * (1 - e) / e := by
rw [div_le_div_iff₀ (by positivity) he0]
nlinarith [hΛ, mul_pos h1e he0, mul_pos hΛ0 he0,
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0)) (sub_nonneg.mpr hΛ)]
linarith
have hboxC : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω)
∧ (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω) ≤ S.wMax Λ ω
∧ 1 < (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω) := by
filter_upwards [hae] with ω hω
obtain ⟨hmin1, hminmax⟩ := hω
by_cases hcy : c ω < S.factualY ω
· simp only [if_pos hcy]
exact ⟨hminmax, le_rfl, lt_of_lt_of_le hmin1 hminmax⟩
· simp only [if_neg hcy]
exact ⟨le_rfl, hminmax, hmin1⟩
refine ⟨?_, ?_⟩
· filter_upwards [hboxC] with ω hω
obtain ⟨_, _, hwgt⟩ := hω
unfold POBackdoorSystem.cutoffProp
constructor
· positivity
· rw [div_lt_one (by linarith)]
linarith
· filter_upwards [hoverlap, hboxC] with ω hov hw
obtain ⟨he0, he1⟩ := hov
obtain ⟨hmin, hmax, hwgt⟩ := hw
set wC : ℝ := if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω with hwC_def
have hcut : S.cutoffProp Λ c ω = 1 / wC := by
rw [POBackdoorSystem.cutoffProp, hwC_def]
have het0 : 0 < S.cutoffProp Λ c ω := by
rw [hcut]
positivity
have het1 : S.cutoffProp Λ c ω < 1 := by
rw [hcut, div_lt_one (by linarith)]
linarith
rw [(hOR_box he0 he1 het0 het1)]
have hinv : 1 / S.cutoffProp Λ c ω = wC := by
rw [hcut, one_div_one_div]
rw [hinv]
simpa [POBackdoorSystem.wMin, POBackdoorSystem.wMax, hwC_def] using ⟨hmin, hmax⟩
2 supporting declarations (lemmas, instances)
-
cutoffProp_calibrated_of_survivaltheorem — Calibration from the survival equation. If the conditional treated-survival of the cutoff equals the target, the cutoff is calibrated.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmin_int :Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μhsurv :S.treatedSurv c =ᵐ[P.μ] S.survTarget ΛconclusionS.Calibrated (S.cutoffProp Λ c)Proof (Lean source)
theorem cutoffProp_calibrated_of_survival (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmin_int : Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) (hsurv : S.treatedSurv c =ᵐ[P.μ] S.survTarget Λ) : S.Calibrated (S.cutoffProp Λ c) := by unfold POBackdoorSystem.Calibrated have hΛ0 : 0 < Λ := lt_trans zero_lt_one hΛ refine (S.cutoff_calibValue_eq Λ c hc_meas hint hint1 hmin_int hdiff_int).trans ?_ filter_upwards [hoverlap, hsurv] with ω hω hsurvω rw [hsurvω] set e : ℝ := S.propScore true ω with he_def have he0 : 0 < e := by simpa [he_def] using hω.1 have he1 : e < 1 := by simpa [he_def] using hω.2 have hdiff_pos : 0 < S.wMax Λ ω - S.wMin Λ ω := by simp only [POBackdoorSystem.wMax, POBackdoorSystem.wMin, ← he_def] have h1e : 0 < 1 - e := by linarith have hΛsq : 0 < Λ * Λ - 1 := by nlinarith field_simp [hΛ0.ne', he0.ne'] nlinarith [h1e, hΛsq, hΛ0, he0] have hdiff_ne : S.wMax Λ ω - S.wMin Λ ω ≠ 0 := hdiff_pos.ne' unfold POBackdoorSystem.survTarget field_simp [hdiff_ne] ring -
cutoffProp_mem_MSMSetCalib_of_survivaltheorem — Calibrated feasibility reduces to the survival equation. If the cutoff c solves the conditional treated-survival equation G(c) = survTarget, then cutoffProp Λ c ∈ MSMSetCalib Λ, discharging the hcut_mem hypothesis of msmUpperCalib_eq_cutoff.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmin_int :Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μhsurv :S.treatedSurv c =ᵐ[P.μ] S.survTarget ΛconclusionS.cutoffProp Λ c ∈ S.MSMSetCalib ΛProof (Lean source)
theorem cutoffProp_mem_MSMSetCalib_of_survival (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmin_int : Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) (hsurv : S.treatedSurv c =ᵐ[P.μ] S.survTarget Λ) : S.cutoffProp Λ c ∈ S.MSMSetCalib Λ := ⟨S.cutoffProp_mem_MSMSet Λ (le_of_lt hΛ) hoverlap c, S.cutoffProp_calibrated_of_survival Λ hΛ hoverlap c hc_meas hint hint1 hmin_int hdiff_int hsurv⟩
CutoffConstruct 6 core · 13 supporting This file constructs the treated-arm quantile cutoff used in the sharp MSM upper bound. ★ exists_calibrating_cutoff★ msmUpperCalib_eq_cutoff_unconditional
Construction of treated-arm calibrated cutoff weights
This file constructs the treated-arm quantile cutoff used in the sharp MSM
upper bound. Measurable conditional quantiles provide a σ(X)-measurable
cutoff whose induced boundary weight is calibrated and therefore attains the
closed-form upper endpoint.
It defines treatedSet, treatedXYLaw, treatedCondCDF, and calibLevel;
proves the constant and functional survival bridges treatedSurv_const_eq and
treatedSurv_eq; exposes exists_factor_through_factualX; constructs a cutoff
in exists_calibrating_cutoff; and packages the unconditional upper endpoint
as msmUpperCalib_eq_cutoff_unconditional.
def treatedSet reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the treated set is the set of all units whose factual treatment status is treatment.
Definition (Lean source)
def treatedXYLaw reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the treated covariate--outcome law is the image law of the factual covariate and factual outcome under the population measure restricted to treated units.
Definition (Lean source)
def treatedCondCDF reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a unit, and a real threshold, the treated conditional distribution-function value is the probability that a treated unit's factual outcome does not exceed the threshold, conditional on having that unit's factual covariate value.
Definition (Lean source)
def calibLevel reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a sensitivity level, and a unit, the calibration quantile level is one minus the target treated-survival probability divided by that unit's propensity for treatment. It is the treated conditional-distribution-function level whose quantile supplies the calibrating cutoff.
Definition (Lean source)
theorem exists_calibrating_cutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Existence of a calibrating cutoff (treated arm). Fix a sensitivity parameter Λ strictly greater than one. Assume the treated propensity score is almost surely strictly between 0 and 1 (two-sided overlap), that the treated-arm conditional law of the outcome given covariates is atomless, i.e. its conditional CDF is continuous, and that the calibration quantile level lies strictly between 0 and 1 almost everywhere. Then there exists a σ(X)-measurable cutoff function c such that the treatment-weighted conditional survival function at c agrees almost everywhere with the target survival function survTarget Λ; the cutoff is realized as the conditional quantile of the treated outcome law at the calibration level.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomless :
∀ a : γ, Continuous (condCDF S.treatedXYLaw a)
hlevel :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1
conclusion
∃ c : P.Ω → ℝ,
conclusion 1
Measurable[S.sigmaX] c
conclusion 2
S.treatedSurv c =ᵐ[P.μ] S.survTarget Λ
Proof (Lean source)
theorem exists_calibrating_cutoff (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hatomless : ∀ a : γ, Continuous (condCDF S.treatedXYLaw a))
(hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1) :
∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧ S.treatedSurv c =ᵐ[P.μ] S.survTarget Λ := by
classical
have hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hwMin_meas : Measurable[S.sigmaX] (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact measurable_const.add
((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas))
have hwMax_meas : Measurable[S.sigmaX] (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact measurable_const.add
((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas)
have hsurvTarget_meas : Measurable[S.sigmaX] (S.survTarget Λ) := by
unfold POBackdoorSystem.survTarget
exact (measurable_const.sub (hwMin_meas.mul hprop_meas)).div
(hwMax_meas.sub hwMin_meas)
have hlevel_meas : Measurable[S.sigmaX] (S.calibLevel Λ) := by
unfold POBackdoorSystem.calibLevel
exact measurable_const.sub (hsurvTarget_meas.div hprop_meas)
obtain ⟨g, hg, hg_eq⟩ := S.exists_factor_through_factualX hlevel_meas
let τ : γ → ℝ := fun a => if 0 < g a ∧ g a < 1 then g a else (1 / 2 : ℝ)
have hτ_meas : Measurable τ := by
dsimp [τ]
refine Measurable.ite ?_ hg measurable_const
exact (measurableSet_lt measurable_const hg).inter (measurableSet_lt hg measurable_const)
have hτ0 : ∀ a, 0 < τ a := by
intro a
dsimp [τ]
by_cases ha : 0 < g a ∧ g a < 1
· simpa [ha] using ha.1
· simp [ha]
have hτ1 : ∀ a, τ a < 1 := by
intro a
dsimp [τ]
by_cases ha : 0 < g a ∧ g a < 1
· simpa [ha] using ha.2
· simp only [ha, ↓reduceIte]
norm_num
haveI : IsFiniteMeasure S.treatedXYLaw := by
unfold POBackdoorSystem.treatedXYLaw
infer_instance
obtain ⟨hq_meas, hq_attain⟩ :=
measurable_condQuantile_and_attains
S.treatedXYLaw τ hτ_meas hτ0 hτ1 (fun a => (hatomless a).continuousAt)
let c : P.Ω → ℝ := fun ω =>
condQuantile S.treatedXYLaw τ (S.factualX ω)
have hc_meas : Measurable[S.sigmaX] c := by
rw [POBackdoorSystem.sigmaX]
exact hq_meas.comp (comap_measurable S.factualX)
refine ⟨c, hc_meas, ?_⟩
have hτ_eq_level : ∀ᵐ ω ∂P.μ, τ (S.factualX ω) = S.calibLevel Λ ω := by
filter_upwards [hlevel] with ω hω
have hgx : g (S.factualX ω) = S.calibLevel Λ ω := by
exact (congrFun hg_eq ω).symm
dsimp [τ]
rw [hgx]
simp [hω]
have hsurv := S.treatedSurv_eq c hc_meas
filter_upwards [hsurv, hτ_eq_level, hoverlap] with ω hsurvω hτω hoverlapω
rw [hsurvω]
have hcdf :
S.treatedCondCDF ω (c ω) = τ (S.factualX ω) := by
unfold POBackdoorSystem.treatedCondCDF c
exact hq_attain (S.factualX ω)
rw [hcdf, hτω]
unfold POBackdoorSystem.calibLevel
have hpos : S.propScore true ω ≠ 0 := ne_of_gt hoverlapω.1
field_simp [hpos]
ring
theorem msmUpperCalib_eq_cutoff_unconditional reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp treated upper bound, unconditionally. Fix a sensitivity parameter Λ strictly greater than one. Assume two-sided overlap of the treated propensity score, that the treated-arm conditional outcome law given covariates is atomless, i.e. its conditional CDF is continuous, that the calibration quantile level lies strictly between 0 and 1 almost everywhere, and that the candidate means over the calibrated ambiguity set are bounded above. If every calibrated candidate propensity is almost-everywhere measurable and every σ(X)-measurable cutoff satisfies the integrability conditions needed for the calibration and optimality arguments, then there exists a σ(X)-measurable cutoff function whose induced quantile-cutoff propensity is calibrated-feasible, at which the sharp (supremum) upper bound for E[Y(1)] equals the candidate mean.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomless :
∀ a : γ, Continuous (condCDF S.treatedXYLaw a)
hlevel :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1
hbdd :
BddAbove (S.candMean '' S.MSMSetCalib Λ)
hmeas :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
hreg :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
conclusion
∃ c : P.Ω → ℝ,
conclusion 1
Measurable[S.sigmaX] c
conclusion 2
S.cutoffProp Λ c ∈ S.MSMSetCalib Λ
conclusion 3
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c)
Proof (Lean source)
theorem msmUpperCalib_eq_cutoff_unconditional (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hatomless : ∀ a : γ, Continuous (condCDF S.treatedXYLaw a))
(hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1)
(hbdd : BddAbove (S.candMean '' S.MSMSetCalib Λ))
(hmeas : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ)
(hreg : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ) :
∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧
S.cutoffProp Λ c ∈ S.MSMSetCalib Λ ∧
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c) := by
obtain ⟨c, hc_meas, hsurv⟩ :=
S.exists_calibrating_cutoff Λ hΛ hoverlap hatomless hlevel
obtain ⟨hc_int, hint, hint1, hmin_int, hdiff_int,
henv, hweight_env, hc_env⟩ := hreg c hc_meas
have hcut_mem : S.cutoffProp Λ c ∈ S.MSMSetCalib Λ :=
S.cutoffProp_mem_MSMSetCalib_of_survival Λ hΛ hoverlap c hc_meas
hint hint1 hmin_int hdiff_int hsurv
have heq : S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c) :=
S.msmUpperCalib_eq_cutoff Λ (le_of_lt hΛ) hoverlap c hc_meas
hc_int hcut_mem henv hweight_env hc_env hmeas
exact ⟨c, hc_meas, hcut_mem, heq⟩
13 supporting declarations (lemmas, instances)
-
treatedXYLaw_eqlemma — The treated push-forward law of the covariate and outcome is the image, under the map recording the factual covariate and factual outcome, of the population measure restricted to the treated set.hypothesesconclusionS.treatedXYLaw = (P.μ.restrict S.treatedSet).map (fun ω => (S.factualX ω, S.factualY ω)) -
measurable_treatedCondCDF_constlemma — At a fixed outcome level, the treated conditional CDF depends on the unit only through the observed covariate, so it is measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (fun ω => S.treatedCondCDF ω t)Proof (Lean source)
@[fun_prop] lemma measurable_treatedCondCDF_const (t : ℝ) : Measurable[S.sigmaX] (fun ω => S.treatedCondCDF ω t) := by rw [POBackdoorSystem.sigmaX] unfold POBackdoorSystem.treatedCondCDF exact (ProbabilityTheory.measurable_condCDF S.treatedXYLaw t).comp (comap_measurable S.factualX) -
stronglyMeasurable_treatedCondCDF_constlemma — The strongly-measurable form, for the covariate σ-algebra, of the treated conditional CDF at a fixed outcome level.hypothesesconclusionStronglyMeasurable[S.sigmaX] (fun ω => S.treatedCondCDF ω t)Proof (Lean source)
@[fun_prop] lemma stronglyMeasurable_treatedCondCDF_const (t : ℝ) : StronglyMeasurable[S.sigmaX] (fun ω => S.treatedCondCDF ω t) := (S.measurable_treatedCondCDF_const t).stronglyMeasurable -
measurable_treatedCondCDF_const_ambientlemma — The treated conditional CDF at a fixed outcome level is measurable for the ambient σ-algebra as well as for the covariate one.hypothesesconclusionMeasurable (fun ω => S.treatedCondCDF ω t)Proof (Lean source)
@[fun_prop] lemma measurable_treatedCondCDF_const_ambient (t : ℝ) : Measurable (fun ω => S.treatedCondCDF ω t) := (S.measurable_treatedCondCDF_const t).mono S.sigmaX_le le_rfl -
treatedSurv_const_eqtheorem — The survival bridge (constant cutoff). The weighted conditional survival equals the treated conditional survival scaled by the propensity: E[Z·1{Y>t} | σ(X)] = e(X)·(1 − F(t | X)) a.e. The genuine measure-theoretic content relates a conditional expectation under μ (weighted by the treatment indicator) to the conditional CDF of the treated push-forward law.hypothesesProof (Lean source)
theorem treatedSurv_const_eq (t : ℝ) : P.μ[fun ω => S.dVar.indicator true ω * (if t < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX] =ᵐ[P.μ] fun ω => S.propScore true ω * (1 - S.treatedCondCDF ω t) := by classical have hpoint : (fun ω => S.dVar.indicator true ω * (if t < S.factualY ω then (1 : ℝ) else 0)) =ᵐ[P.μ] (fun ω => S.dVar.indicator true ω - S.dVar.indicator true ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0)) := by exact Filter.Eventually.of_forall fun ω => by by_cases hle : S.factualY ω ≤ t · have hnot : ¬ t < S.factualY ω := not_lt.mpr hle simp [hle, hnot] · have hlt : t < S.factualY ω := lt_of_not_ge hle simp [hle, hlt] refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_ have hsub := MeasureTheory.condExp_sub (μ := P.μ) (m := S.sigmaX) (f := S.dVar.indicator true) (g := fun ω => S.dVar.indicator true ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0)) (S.dVar.integrable_indicator true (MeasurableSet.singleton true)) (S.integrable_treated_le_indicator t) have hle_bridge := S.treatedLe_const_eq t filter_upwards [hsub, hle_bridge] with ω hsubω hleω change P.μ[S.dVar.indicator true - (fun ω => S.dVar.indicator true ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0)) | S.sigmaX] ω = S.propScore true ω * (1 - S.treatedCondCDF ω t) rw [hsubω] change S.propScore true ω - P.μ[fun ω => S.dVar.indicator true ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0) | S.sigmaX] ω = S.propScore true ω * (1 - S.treatedCondCDF ω t) rw [hleω] ring -
measurable_condCDF_variablelemma — The conditional CDF remains measurable when evaluated at a measurable cutoff.hypothesesconclusionMeasurable (fun a => condCDF ρ a (q a))Proof (Lean source)
@[fun_prop] lemma measurable_condCDF_variable (ρ : Measure (γ × ℝ)) [IsFiniteMeasure ρ] {q : γ → ℝ} (hq : Measurable q) : Measurable (fun a => condCDF ρ a (q a)) := by classical let V : Set (γ × ℝ) := {p : γ × ℝ | p.2 ≤ q p.1} have hV : MeasurableSet V := by dsimp [V] exact measurableSet_le measurable_snd (hq.comp measurable_fst) let hf := ProbabilityTheory.isCondKernelCDF_condCDF ρ have hkern : Measurable fun a : γ => hf.toKernel (fun p : Unit × γ => condCDF ρ p.2) ((), a) (Prod.mk a ⁻¹' V) := by exact Kernel.measurable_kernel_prodMk_left' (η := hf.toKernel (fun p : Unit × γ => condCDF ρ p.2)) hV () have hfun : (fun a : γ => condCDF ρ a (q a)) = fun a => (hf.toKernel (fun p : Unit × γ => condCDF ρ p.2) ((), a) (Prod.mk a ⁻¹' V)).toReal := by funext a have hpre : Prod.mk a ⁻¹' V = Iic (q a) := by ext y simp [V] rw [hpre, ProbabilityTheory.IsCondKernelCDF.toKernel_Iic] exact (ENNReal.toReal_ofReal (ProbabilityTheory.condCDF_nonneg ρ a (q a))).symm rw [hfun] exact ENNReal.measurable_toReal.comp hkern -
integrable_condCDF_variablelemma — The conditional CDF evaluated at a measurable cutoff is integrable under the first marginal.hypothesesconclusionIntegrable (fun a => condCDF ρ a (q a)) ρ.fstProof (Lean source)
@[fun_prop] lemma integrable_condCDF_variable (ρ : Measure (γ × ℝ)) [IsFiniteMeasure ρ] {q : γ → ℝ} (hq : Measurable q) : Integrable (fun a => condCDF ρ a (q a)) ρ.fst := by refine (integrable_const (μ := ρ.fst) (c := (1 : ℝ))).mono' (measurable_condCDF_variable ρ hq).aestronglyMeasurable ?_ exact Filter.Eventually.of_forall fun a => by rw [Real.norm_of_nonneg (ProbabilityTheory.condCDF_nonneg ρ a (q a))] exact ProbabilityTheory.condCDF_le_one ρ a (q a) -
setLIntegral_condCDF_variablelemma — Set-lintegral form of the conditional CDF identity at a measurable variable cutoff.Proof (Lean source)
lemma setLIntegral_condCDF_variable (ρ : Measure (γ × ℝ)) [IsFiniteMeasure ρ] {B : Set γ} (hB : MeasurableSet B) {q : γ → ℝ} (hq : Measurable q) : ∫⁻ a in B, ofReal (condCDF ρ a (q a)) ∂ρ.fst = ρ {p : γ × ℝ | p.1 ∈ B ∧ p.2 ≤ q p.1} := by classical let V : Set (γ × ℝ) := {p : γ × ℝ | p.1 ∈ B ∧ p.2 ≤ q p.1} have hV : MeasurableSet V := by dsimp [V] exact (hB.preimage measurable_fst).inter (measurableSet_le measurable_snd (hq.comp measurable_fst)) let hf := ProbabilityTheory.isCondKernelCDF_condCDF ρ have hmem := ProbabilityTheory.lintegral_toKernel_mem (κ := Kernel.const Unit ρ) (ν := Kernel.const Unit ρ.fst) (f := fun p : Unit × γ => condCDF ρ p.2) hf () hV have hpoint : ∀ a : γ, hf.toKernel (fun p : Unit × γ => condCDF ρ p.2) ((), a) (Prod.mk a ⁻¹' V) = B.indicator (fun a => ofReal (condCDF ρ a (q a))) a := by intro a by_cases ha : a ∈ B · have hpre : Prod.mk a ⁻¹' V = Iic (q a) := by ext y simp [V, ha] rw [hpre, ProbabilityTheory.IsCondKernelCDF.toKernel_Iic] simp [Set.indicator_of_mem ha] · have hpre : Prod.mk a ⁻¹' V = ∅ := by ext y simp [V, ha] rw [hpre] simp [Set.indicator_of_notMem ha] calc ∫⁻ a in B, ofReal (condCDF ρ a (q a)) ∂ρ.fst = ∫⁻ a, B.indicator (fun a => ofReal (condCDF ρ a (q a))) a ∂ρ.fst := by exact (MeasureTheory.lintegral_indicator hB _).symm _ = ∫⁻ a, hf.toKernel (fun p : Unit × γ => condCDF ρ p.2) ((), a) (Prod.mk a ⁻¹' V) ∂(Kernel.const Unit ρ.fst ()) := by simp only [Kernel.const_apply] exact lintegral_congr_ae (Filter.Eventually.of_forall fun a => (hpoint a).symm) _ = Kernel.const Unit ρ () V := hmem _ = ρ V := by simp -
measurable_treatedCondCDF_variablelemma — Evaluated at a cutoff that itself depends on the unit only through the observed covariate, the treated conditional CDF is still measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (fun ω => S.treatedCondCDF ω (c ω))Proof (Lean source)
@[fun_prop] lemma measurable_treatedCondCDF_variable (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : Measurable[S.sigmaX] (fun ω => S.treatedCondCDF ω (c ω)) := by obtain ⟨q, hq, hc_eq⟩ := S.exists_factor_through_factualX_private hc haveI : IsFiniteMeasure S.treatedXYLaw := by unfold POBackdoorSystem.treatedXYLaw infer_instance rw [POBackdoorSystem.sigmaX, hc_eq] unfold POBackdoorSystem.treatedCondCDF exact (measurable_condCDF_variable S.treatedXYLaw hq).comp (comap_measurable S.factualX) -
stronglyMeasurable_treatedCondCDF_variablelemma — The strongly-measurable form, for the covariate σ-algebra, of the treated conditional CDF at a covariate-measurable cutoff.hypothesesconclusionStronglyMeasurable[S.sigmaX] (fun ω => S.treatedCondCDF ω (c ω))Proof (Lean source)
@[fun_prop] lemma stronglyMeasurable_treatedCondCDF_variable (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : StronglyMeasurable[S.sigmaX] (fun ω => S.treatedCondCDF ω (c ω)) := (S.measurable_treatedCondCDF_variable c hc).stronglyMeasurable -
measurable_treatedCondCDF_variable_ambientlemma — The treated conditional CDF at a covariate-measurable cutoff is measurable for the ambient σ-algebra as well as for the covariate one.hypothesesconclusionMeasurable (fun ω => S.treatedCondCDF ω (c ω))Proof (Lean source)
@[fun_prop] lemma measurable_treatedCondCDF_variable_ambient (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : Measurable (fun ω => S.treatedCondCDF ω (c ω)) := (S.measurable_treatedCondCDF_variable c hc).mono S.sigmaX_le le_rfl -
treatedSurv_eqtheorem — The survival bridge (functional cutoff). The version of treatedSurv_const_eq evaluated at a σ(X)-measurable cutoff c: E[Z·1{Y>c(X)} | σ(X)] = e(X)·(1 − F(c(X) | X)) a.e. Since c is σ(X)-measurable, it is "frozen" inside the conditional expectation, reducing to the constant-cutoff bridge fibrewise. This is the form consumed by exists_calibrating_cutoff.hypothesesconclusionS.treatedSurv c =ᵐ[P.μ] fun ω => S.propScore true ω * (1 - S.treatedCondCDF ω (c ω))Proof (Lean source)
theorem treatedSurv_eq (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : S.treatedSurv c =ᵐ[P.μ] fun ω => S.propScore true ω * (1 - S.treatedCondCDF ω (c ω)) := by classical unfold POBackdoorSystem.treatedSurv have hpoint : (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) =ᵐ[P.μ] (fun ω => S.dVar.indicator true ω - S.dVar.indicator true ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0)) := by exact Filter.Eventually.of_forall fun ω => by by_cases hle : S.factualY ω ≤ c ω · have hnot : ¬ c ω < S.factualY ω := not_lt.mpr hle simp [hle, hnot] · have hlt : c ω < S.factualY ω := lt_of_not_ge hle simp [hle, hlt] refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_ have hsub := MeasureTheory.condExp_sub (μ := P.μ) (m := S.sigmaX) (f := S.dVar.indicator true) (g := fun ω => S.dVar.indicator true ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0)) (S.dVar.integrable_indicator true (MeasurableSet.singleton true)) (S.integrable_treated_le_indicator_variable c hc) have hle_bridge := S.treatedLe_eq c hc filter_upwards [hsub, hle_bridge] with ω hsubω hleω change P.μ[S.dVar.indicator true - (fun ω => S.dVar.indicator true ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0)) | S.sigmaX] ω = S.propScore true ω * (1 - S.treatedCondCDF ω (c ω)) rw [hsubω] change S.propScore true ω - P.μ[fun ω => S.dVar.indicator true ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0) | S.sigmaX] ω = S.propScore true ω * (1 - S.treatedCondCDF ω (c ω)) rw [hleω] ring -
exists_factor_through_factualXtheorem — σ(X)-measurable functions factor through X. If f is σ(X)-measurable then f = g ∘ X for a measurable g : γ → ℝ. This is standard comap factorization: the conditioning is on the value of X.hypothesesProof (Lean source)
theorem exists_factor_through_factualX {f : P.Ω → ℝ} (hf : Measurable[S.sigmaX] f) : ∃ g : γ → ℝ, Measurable g ∧ f = fun ω => g (S.factualX ω) := by rw [POBackdoorSystem.sigmaX] at hf obtain ⟨g, hg, hfg⟩ := hf.exists_eq_measurable_comp (f := S.factualX) exact ⟨g, hg, by simpa [Function.comp_def] using hfg⟩
ControlCutoffConstruct 5 core · 10 supporting This file is the control-arm mirror of CutoffConstruct: it constructs a σ(X)-measurable cutoff solving the control conditional-survival calibration equation and uses it to discharge the membership hypothesis in the calib ★ msmUpperCalib0_eq_cutoff_unconditional
Marginal Sensitivity Model -- constructing the calibrating control cutoff
This file is the control-arm mirror of CutoffConstruct: it constructs a σ(X)-measurable
cutoff solving the control conditional-survival calibration equation and uses it to discharge the
membership hypothesis in the calibrated control sharp upper bound.
The file defines controlSet, controlXYLaw, controlCondCDF, and
calibLevel0; proves the constant and functional survival bridges
controlSurv_const_eq and controlSurv_eq; constructs a measurable cutoff in
exists_calibrating_cutoff0; and packages the unconditional sharp upper
endpoint as msmUpperCalib0_eq_cutoff_unconditional.
def controlSet reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the control set is the set of all units whose factual treatment status is control.
Definition (Lean source)
def controlXYLaw reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the control covariate--outcome law is the image law of the factual covariate and factual outcome under the population measure restricted to control units.
Definition (Lean source)
def controlCondCDF reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a unit, and a real threshold, the control conditional distribution-function value is the probability that a control unit's factual outcome does not exceed the threshold, conditional on having that unit's factual covariate value.
Definition (Lean source)
def calibLevel0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a sensitivity level, and a unit, the control calibration quantile level is one minus the target control-survival probability divided by that unit's propensity for control. It is the control conditional-distribution-function level whose quantile supplies the calibrating cutoff.
Definition (Lean source)
theorem msmUpperCalib0_eq_cutoff_unconditional reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp control upper bound has a quantile-balancing closed form, unconditionally. Fix a sensitivity parameter Λ strictly greater than 1. If the control propensity P[D=0∣X] lies strictly between 0 and 1 almost everywhere (overlap), the control outcome's conditional law given the covariates is atomless (its conditional CDF is continuous), the calibration level lies strictly between 0 and 1 almost everywhere, every candidate propensity in the calibrated control ambiguity set is almost-everywhere measurable, and every covariate-measurable cutoff function satisfies the integrability conditions needed to evaluate the calibration and candidate-mean functionals at it, then there exists a covariate-measurable cutoff c such that the cutoff-calibration propensity cutoffProp0 Λ c lies in the calibrated control MSM set and the sharp control upper bound equals the candidate mean at that cutoff, msmUpperCalib0 Λ = candMean0 (cutoffProp0 Λ c).
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomless :
∀ a : γ, Continuous (condCDF S.controlXYLaw a)
hlevel :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1
_hbdd :
BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ)
hmeas :
∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ
hreg :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
conclusion
∃ c : P.Ω → ℝ,
conclusion 1
Measurable[S.sigmaX] c
conclusion 2
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
conclusion 3
S.msmUpperCalib0 Λ = S.candMean0 (S.cutoffProp0 Λ c)
Proof (Lean source)
theorem msmUpperCalib0_eq_cutoff_unconditional (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(hatomless : ∀ a : γ, Continuous (condCDF S.controlXYLaw a))
(hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1)
(_hbdd : BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ))
(hmeas : ∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ)
(hreg : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) :
∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ ∧
S.msmUpperCalib0 Λ = S.candMean0 (S.cutoffProp0 Λ c) := by
obtain ⟨c, hc_meas, hsurv⟩ :=
S.exists_calibrating_cutoff0 Λ hΛ hoverlap hatomless hlevel
obtain ⟨hc_int, hint, hint1, hmin_int, hdiff_int,
henv, hweight_env, hc_env⟩ := hreg c hc_meas
have hcut_mem : S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ :=
S.cutoffProp0_mem_MSMSetCalib0_of_survival Λ hΛ hoverlap c hc_meas
hint hint1 hmin_int hdiff_int hsurv
have heq : S.msmUpperCalib0 Λ = S.candMean0 (S.cutoffProp0 Λ c) :=
S.msmUpperCalib0_eq_cutoff Λ (le_of_lt hΛ) hoverlap c hc_meas
hc_int hcut_mem henv hweight_env hc_env hmeas
exact ⟨c, hc_meas, hcut_mem, heq⟩
10 supporting declarations (lemmas, instances)
-
controlXYLaw_eqlemma — The control push-forward law of the covariate and outcome is the image, under the map recording the factual covariate and factual outcome, of the population measure restricted to the control set.hypothesesconclusionS.controlXYLaw = (P.μ.restrict S.controlSet).map (fun ω => (S.factualX ω, S.factualY ω)) -
measurable_controlCondCDF_constlemma — At a fixed outcome level, the control conditional CDF depends on the unit only through the observed covariate, so it is measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (fun ω => S.controlCondCDF ω t)Proof (Lean source)
@[fun_prop] lemma measurable_controlCondCDF_const (t : ℝ) : Measurable[S.sigmaX] (fun ω => S.controlCondCDF ω t) := by rw [POBackdoorSystem.sigmaX] unfold POBackdoorSystem.controlCondCDF exact (ProbabilityTheory.measurable_condCDF S.controlXYLaw t).comp (comap_measurable S.factualX) -
stronglyMeasurable_controlCondCDF_constlemma — The strongly-measurable form, for the covariate σ-algebra, of the control conditional CDF at a fixed outcome level.hypothesesconclusionStronglyMeasurable[S.sigmaX] (fun ω => S.controlCondCDF ω t)Proof (Lean source)
@[fun_prop] lemma stronglyMeasurable_controlCondCDF_const (t : ℝ) : StronglyMeasurable[S.sigmaX] (fun ω => S.controlCondCDF ω t) := (S.measurable_controlCondCDF_const t).stronglyMeasurable -
measurable_controlCondCDF_const_ambientlemma — The control conditional CDF at a fixed outcome level is measurable for the ambient σ-algebra as well as for the covariate one.hypothesesconclusionMeasurable (fun ω => S.controlCondCDF ω t)Proof (Lean source)
@[fun_prop] lemma measurable_controlCondCDF_const_ambient (t : ℝ) : Measurable (fun ω => S.controlCondCDF ω t) := (S.measurable_controlCondCDF_const t).mono S.sigmaX_le le_rfl -
controlSurv_const_eqtheorem — The survival bridge (constant cutoff). The weighted conditional survival equals the control conditional survival scaled by the propensity: E[(1-Z)·1{Y>t} | σ(X)] = e₀(X)·(1 − F₀(t | X)) a.e. The genuine measure-theoretic content relates a conditional expectation under μ to the conditional CDF of the control push-forward law.hypothesesProof (Lean source)
theorem controlSurv_const_eq (t : ℝ) : P.μ[fun ω => S.dVar.indicator false ω * (if t < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX] =ᵐ[P.μ] fun ω => S.propScore false ω * (1 - S.controlCondCDF ω t) := by classical have hpoint : (fun ω => S.dVar.indicator false ω * (if t < S.factualY ω then (1 : ℝ) else 0)) =ᵐ[P.μ] (fun ω => S.dVar.indicator false ω - S.dVar.indicator false ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0)) := by exact Filter.Eventually.of_forall fun ω => by by_cases hle : S.factualY ω ≤ t · have hnot : ¬ t < S.factualY ω := not_lt.mpr hle simp [hle, hnot] · have hlt : t < S.factualY ω := lt_of_not_ge hle simp [hle, hlt] refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_ have hsub := MeasureTheory.condExp_sub (μ := P.μ) (m := S.sigmaX) (f := S.dVar.indicator false) (g := fun ω => S.dVar.indicator false ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0)) (S.dVar.integrable_indicator false (MeasurableSet.singleton false)) (S.integrable_control_le_indicator t) have hle_bridge := S.controlLe_const_eq t filter_upwards [hsub, hle_bridge] with ω hsubω hleω change P.μ[S.dVar.indicator false - (fun ω => S.dVar.indicator false ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0)) | S.sigmaX] ω = S.propScore false ω * (1 - S.controlCondCDF ω t) rw [hsubω] change S.propScore false ω - P.μ[fun ω => S.dVar.indicator false ω * (if S.factualY ω ≤ t then (1 : ℝ) else 0) | S.sigmaX] ω = S.propScore false ω * (1 - S.controlCondCDF ω t) rw [hleω] ring -
measurable_controlCondCDF_variablelemma — Evaluated at a cutoff that itself depends on the unit only through the observed covariate, the control conditional CDF is still measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (fun ω => S.controlCondCDF ω (c ω))Proof (Lean source)
@[fun_prop] lemma measurable_controlCondCDF_variable (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : Measurable[S.sigmaX] (fun ω => S.controlCondCDF ω (c ω)) := by obtain ⟨q, hq, hc_eq⟩ := S.exists_factor_through_factualX hc haveI : IsFiniteMeasure S.controlXYLaw := by unfold POBackdoorSystem.controlXYLaw infer_instance rw [POBackdoorSystem.sigmaX, hc_eq] unfold POBackdoorSystem.controlCondCDF exact (measurable_condCDF_variable S.controlXYLaw hq).comp (comap_measurable S.factualX) -
stronglyMeasurable_controlCondCDF_variablelemma — The strongly-measurable form, for the covariate σ-algebra, of the control conditional CDF at a covariate-measurable cutoff.hypothesesconclusionStronglyMeasurable[S.sigmaX] (fun ω => S.controlCondCDF ω (c ω))Proof (Lean source)
@[fun_prop] lemma stronglyMeasurable_controlCondCDF_variable (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : StronglyMeasurable[S.sigmaX] (fun ω => S.controlCondCDF ω (c ω)) := (S.measurable_controlCondCDF_variable c hc).stronglyMeasurable -
measurable_controlCondCDF_variable_ambientlemma — The control conditional CDF at a covariate-measurable cutoff is measurable for the ambient σ-algebra as well as for the covariate one.hypothesesconclusionMeasurable (fun ω => S.controlCondCDF ω (c ω))Proof (Lean source)
@[fun_prop] lemma measurable_controlCondCDF_variable_ambient (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : Measurable (fun ω => S.controlCondCDF ω (c ω)) := (S.measurable_controlCondCDF_variable c hc).mono S.sigmaX_le le_rfl -
controlSurv_eqtheorem — The survival bridge (functional cutoff). The version of controlSurv_const_eq evaluated at a σ(X)-measurable cutoff c: E[(1-Z)·1{Y>c(X)} | σ(X)] = e₀(X)·(1 − F₀(c(X) | X)) a.e. Since c is σ(X)-measurable it is frozen inside the conditional expectation, reducing to the constant-cutoff bridge fibrewise. This is the form consumed by exists_calibrating_cutoff0.hypothesesconclusionS.controlSurv c =ᵐ[P.μ] fun ω => S.propScore false ω * (1 - S.controlCondCDF ω (c ω))Proof (Lean source)
theorem controlSurv_eq (c : P.Ω → ℝ) (hc : Measurable[S.sigmaX] c) : S.controlSurv c =ᵐ[P.μ] fun ω => S.propScore false ω * (1 - S.controlCondCDF ω (c ω)) := by classical unfold POBackdoorSystem.controlSurv have hpoint : (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) =ᵐ[P.μ] (fun ω => S.dVar.indicator false ω - S.dVar.indicator false ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0)) := by exact Filter.Eventually.of_forall fun ω => by by_cases hle : S.factualY ω ≤ c ω · have hnot : ¬ c ω < S.factualY ω := not_lt.mpr hle simp [hle, hnot] · have hlt : c ω < S.factualY ω := lt_of_not_ge hle simp [hle, hlt] refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_ have hsub := MeasureTheory.condExp_sub (μ := P.μ) (m := S.sigmaX) (f := S.dVar.indicator false) (g := fun ω => S.dVar.indicator false ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0)) (S.dVar.integrable_indicator false (MeasurableSet.singleton false)) (S.integrable_control_le_indicator_variable c hc) have hle_bridge := S.controlLe_eq c hc filter_upwards [hsub, hle_bridge] with ω hsubω hleω change P.μ[S.dVar.indicator false - (fun ω => S.dVar.indicator false ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0)) | S.sigmaX] ω = S.propScore false ω * (1 - S.controlCondCDF ω (c ω)) rw [hsubω] change S.propScore false ω - P.μ[fun ω => S.dVar.indicator false ω * (if S.factualY ω ≤ c ω then (1 : ℝ) else 0) | S.sigmaX] ω = S.propScore false ω * (1 - S.controlCondCDF ω (c ω)) rw [hleω] ring -
exists_calibrating_cutoff0theorem — Existence of a calibrating cutoff. Under overlap, 1 < Λ, an atomless control conditional outcome law (condCDF of the control push-forward continuous), and a strictly-interior calibration level, there is a σ(X)-measurable cutoff c solving the survival equation controlSurv c =ᵐ survTarget0 Λ. The cutoff is the conditional quantile Q_{calibLevel0}(X).hypothesesγ :sharedType u_1Λ :ℝ_hΛ :1 < Λhatomless :∀ a : γ, Continuous (condCDF S.controlXYLaw a)hlevel :∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1conclusion∃ c : P.Ω → ℝ,conclusion 1Measurable[S.sigmaX] cconclusion 2S.controlSurv c =ᵐ[P.μ] S.survTarget0 ΛProof (Lean source)
theorem exists_calibrating_cutoff0 (Λ : ℝ) (_hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) (hatomless : ∀ a : γ, Continuous (condCDF S.controlXYLaw a)) (hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1) : ∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧ S.controlSurv c =ᵐ[P.μ] S.survTarget0 Λ := by classical have hprop_meas : Measurable[S.sigmaX] (S.propScore false) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable have hwMin0_meas : Measurable[S.sigmaX] (S.wMin0 Λ) := by unfold POBackdoorSystem.wMin0 exact measurable_const.add ((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas)) have hwMax0_meas : Measurable[S.sigmaX] (S.wMax0 Λ) := by unfold POBackdoorSystem.wMax0 exact measurable_const.add ((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas) have hsurvTarget0_meas : Measurable[S.sigmaX] (S.survTarget0 Λ) := by unfold POBackdoorSystem.survTarget0 exact (measurable_const.sub (hwMin0_meas.mul hprop_meas)).div (hwMax0_meas.sub hwMin0_meas) have hlevel_meas : Measurable[S.sigmaX] (S.calibLevel0 Λ) := by unfold POBackdoorSystem.calibLevel0 exact measurable_const.sub (hsurvTarget0_meas.div hprop_meas) obtain ⟨g, hg, hg_eq⟩ := S.exists_factor_through_factualX hlevel_meas let τ : γ → ℝ := fun a => if 0 < g a ∧ g a < 1 then g a else (1 / 2 : ℝ) have hτ_meas : Measurable τ := by dsimp [τ] refine Measurable.ite ?_ hg measurable_const exact (measurableSet_lt measurable_const hg).inter (measurableSet_lt hg measurable_const) have hτ0 : ∀ a, 0 < τ a := by intro a dsimp [τ] by_cases ha : 0 < g a ∧ g a < 1 · simp [ha] · simp [ha] have hτ1 : ∀ a, τ a < 1 := by intro a dsimp [τ] by_cases ha : 0 < g a ∧ g a < 1 · simp [ha] · simp only [ha, ↓reduceIte] norm_num haveI : IsFiniteMeasure S.controlXYLaw := by unfold POBackdoorSystem.controlXYLaw infer_instance obtain ⟨hq_meas, hq_attain⟩ := measurable_condQuantile_and_attains S.controlXYLaw τ hτ_meas hτ0 hτ1 (fun a => (hatomless a).continuousAt) let c : P.Ω → ℝ := fun ω => condQuantile S.controlXYLaw τ (S.factualX ω) have hc_meas : Measurable[S.sigmaX] c := by rw [POBackdoorSystem.sigmaX] exact hq_meas.comp (comap_measurable S.factualX) refine ⟨c, hc_meas, ?_⟩ have hτ_eq_level : ∀ᵐ ω ∂P.μ, τ (S.factualX ω) = S.calibLevel0 Λ ω := by filter_upwards [hlevel] with ω hω have hgx : g (S.factualX ω) = S.calibLevel0 Λ ω := by exact (congrFun hg_eq ω).symm dsimp [τ] rw [hgx] simp [hω] have hsurv := S.controlSurv_eq c hc_meas filter_upwards [hsurv, hτ_eq_level, hoverlap] with ω hsurvω hτω hoverlapω rw [hsurvω] have hcdf : S.controlCondCDF ω (c ω) = τ (S.factualX ω) := by unfold POBackdoorSystem.controlCondCDF c exact hq_attain (S.factualX ω) rw [hcdf, hτω] unfold POBackdoorSystem.calibLevel0 have hpos : S.propScore false ω ≠ 0 := ne_of_gt hoverlapω.1 field_simp [hpos] ring
ATE 8 core · 1 supporting This file combines treated-arm and control-arm marginal-sensitivity intervals into an interval for the average treatment effect. ★ ate_mem_Icc_calib★ ate_mem_Icc★ ateCalib_subset
Marginal-sensitivity-model ATE interval
This file combines treated-arm and control-arm marginal-sensitivity intervals into an interval for the average treatment effect. The ATE upper endpoint pairs the treated upper bound with the control lower bound, and the lower endpoint pairs the treated lower bound with the control upper bound.
The main declarations are ate, the calibrated endpoints ateUpperCalib and
ateLowerCalib, the uncalibrated endpoints ateUpper and ateLower, validity
theorems ate_mem_Icc_calib and ate_mem_Icc, and the nesting theorem
ateCalib_subset.
def ate reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, and a back-door system on them, the average treatment effect is the population mean of the potential outcome under treatment minus the population mean of the potential outcome under control.
Definition (Lean source)
parameters
def
ate S :
ℝ
given by
S.Y1mean - S.Y0mean
def ateUpperCalib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the sharp upper bound for the average treatment effect is the sharp treated-arm upper bound minus the sharp control- arm lower bound.
Definition (Lean source)
parameters
def
ateUpperCalib S Λ :
ℝ
given by
S.msmUpperCalib Λ - S.msmLowerCalib0 Λ
def ateLowerCalib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the sharp lower bound for the average treatment effect is the sharp treated-arm lower bound minus the sharp control- arm upper bound.
Definition (Lean source)
parameters
def
ateLowerCalib S Λ :
ℝ
given by
S.msmLowerCalib Λ - S.msmUpperCalib0 Λ
def ateUpper reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the uncalibrated upper bound for the average treatment effect is the uncalibrated treated-arm upper bound minus the uncalibrated control-arm lower bound.
Definition (Lean source)
parameters
def
ateUpper S Λ :
ℝ
given by
S.msmUpper Λ - S.msmLower0 Λ
def ateLower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, and a sensitivity level, the uncalibrated lower bound for the average treatment effect is the uncalibrated treated-arm lower bound minus the uncalibrated control-arm upper bound.
Definition (Lean source)
parameters
def
ateLower S Λ :
ℝ
given by
S.msmLower Λ - S.msmUpper0 Λ
theorem ate_mem_Icc_calib reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp ATE interval is valid. If the treated arm's mean potential outcome E[Y(1)] lies in the calibrated sharp interval [msmLowerCalib Λ, msmUpperCalib Λ] and the control arm's mean potential outcome E[Y(0)] lies in the calibrated sharp interval [msmLowerCalib0 Λ, msmUpperCalib0 Λ], then the true average treatment effect τ = E[Y(1)] − E[Y(0)] lies in the sharp interval [ateLowerCalib Λ, ateUpperCalib Λ].
Formal statement
Proof (Lean source)
theorem ate_mem_Icc_calib (Λ : ℝ)
(hT : S.Y1mean ∈ Icc (S.msmLowerCalib Λ) (S.msmUpperCalib Λ))
(hC : S.Y0mean ∈ Icc (S.msmLowerCalib0 Λ) (S.msmUpperCalib0 Λ)) :
S.ate ∈ Icc (S.ateLowerCalib Λ) (S.ateUpperCalib Λ) := by
unfold POBackdoorSystem.ate POBackdoorSystem.ateLowerCalib POBackdoorSystem.ateUpperCalib
exact sub_mem_Icc_of_mem_Icc hT hC
theorem ate_mem_Icc reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The ZSB ATE interval is valid. If the treated arm's mean potential outcome E[Y(1)] lies in the uncalibrated ZSB interval [msmLower Λ, msmUpper Λ] and the control arm's mean potential outcome E[Y(0)] lies in the uncalibrated ZSB interval [msmLower0 Λ, msmUpper0 Λ], then the true average treatment effect τ = E[Y(1)] − E[Y(0)] lies in the ZSB interval [ateLower Λ, ateUpper Λ].
Formal statement
Proof (Lean source)
theorem ate_mem_Icc (Λ : ℝ)
(hT : S.Y1mean ∈ Icc (S.msmLower Λ) (S.msmUpper Λ))
(hC : S.Y0mean ∈ Icc (S.msmLower0 Λ) (S.msmUpper0 Λ)) :
S.ate ∈ Icc (S.ateLower Λ) (S.ateUpper Λ) := by
unfold POBackdoorSystem.ate POBackdoorSystem.ateLower POBackdoorSystem.ateUpper
exact sub_mem_Icc_of_mem_Icc hT hC
theorem ateCalib_subset reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp ATE interval is contained in the ZSB ATE interval. If the treated arm's calibrated sharp upper bound does not exceed its uncalibrated ZSB upper bound, the treated arm's uncalibrated ZSB lower bound does not exceed its calibrated sharp lower bound, the control arm's calibrated sharp upper bound does not exceed its uncalibrated ZSB upper bound, and the control arm's uncalibrated ZSB lower bound does not exceed its calibrated sharp lower bound, then the sharp ATE interval [ateLowerCalib Λ, ateUpperCalib Λ] is contained in the ZSB ATE interval [ateLower Λ, ateUpper Λ].
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hUT :
S.msmUpperCalib Λ ≤ S.msmUpper Λ
hLT :
S.msmLower Λ ≤ S.msmLowerCalib Λ
hU0 :
S.msmUpperCalib0 Λ ≤ S.msmUpper0 Λ
hL0 :
S.msmLower0 Λ ≤ S.msmLowerCalib0 Λ
Proof (Lean source)
theorem ateCalib_subset (Λ : ℝ)
(hUT : S.msmUpperCalib Λ ≤ S.msmUpper Λ)
(hLT : S.msmLower Λ ≤ S.msmLowerCalib Λ)
(hU0 : S.msmUpperCalib0 Λ ≤ S.msmUpper0 Λ)
(hL0 : S.msmLower0 Λ ≤ S.msmLowerCalib0 Λ) :
Icc (S.ateLowerCalib Λ) (S.ateUpperCalib Λ)
⊆ Icc (S.ateLower Λ) (S.ateUpper Λ) := by
apply Set.Icc_subset_Icc
· unfold POBackdoorSystem.ateLower POBackdoorSystem.ateLowerCalib
linarith
· unfold POBackdoorSystem.ateUpper POBackdoorSystem.ateUpperCalib
linarith
1 supporting declaration (lemmas, instances)
-
sub_mem_Icc_of_mem_Icctheorem — Interval subtraction. If a ∈ [aₗ, aᵤ] and b ∈ [bₗ, bᵤ], then a − b ∈ [aₗ − bᵤ, aᵤ − bₗ]. The arithmetic core of the ATE-interval theorems.hypothesesconclusiona - b ∈ Icc (aₗ - bᵤ) (aᵤ - bₗ)Proof (Lean source)
theorem sub_mem_Icc_of_mem_Icc {a aₗ aᵤ b bₗ bᵤ : ℝ} (ha : a ∈ Icc aₗ aᵤ) (hb : b ∈ Icc bₗ bᵤ) : a - b ∈ Icc (aₗ - bᵤ) (aᵤ - bₗ) := by obtain ⟨ha₁, ha₂⟩ := ha obtain ⟨hb₁, hb₂⟩ := hb exact ⟨by linarith, by linarith⟩
ControlLowerBound 6 core · 5 supporting This file gives the control-arm sInf lower bound for the Marginal Sensitivity Model. ★ cutoff_optimal0_lower★ msmLowerCalib0_eq_cutoff★ msmLowerCalib0_eq_cutoff_unconditional
Marginal Sensitivity Model — control sharp lower bound
This file gives the control-arm sInf lower bound for the Marginal Sensitivity Model. It mirrors
the treated lower-bound construction with the control propensity, untreated indicator, and control
cutoff-survival equation.
It defines the lower-cutoff candidate lowerCutoffProp0, the lower survival
target survTargetLower0, and the quantile level calibLevelLower0. The main
results are cutoff_optimal0_lower, msmLowerCalib0_eq_cutoff,
lowerControl_calibValue_eq, feasibility lemmas for the lower cutoff, the
existence theorem exists_calibrating_cutoff0_lower, and the unconditional
closed form msmLowerCalib0_eq_cutoff_unconditional.
def lowerCutoffProp0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, a real-valued cutoff function on the sample space, and a sample point, the lower quantile-cutoff complete propensity is the reciprocal of the lower admissible control inverse-propensity weight when the factual outcome exceeds the cutoff and of the upper admissible weight otherwise: if , and otherwise.
Definition (Lean source)
parameters
def
lowerCutoffProp0 S Λ c ω :
ℝ
given by
1 / (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω)
def survTargetLower0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, and a sample point, the lower target control-survival probability is , where is the control propensity score.
Definition (Lean source)
parameters
def
survTargetLower0 S Λ ω :
ℝ
given by
(S.wMax0 Λ ω * S.propScore false ω - 1) / (S.wMax0 Λ ω - S.wMin0 Λ ω)
def calibLevelLower0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a sensitivity parameter, and a sample point, the lower calibration quantile level is one minus the lower target control-survival probability divided by the control propensity score at that point.
Definition (Lean source)
theorem cutoff_optimal0_lower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Optimality of the lower quantile-cutoff weight. Fix a sensitivity parameter Λ at least one. Assume the control propensity score is almost surely strictly between 0 and 1 (two-sided overlap), and let c be a σ(X)-measurable, integrable cutoff function such that the lower quantile-cutoff propensity it induces lies in the calibrated control ambiguity set. If the envelope 1_{D=0}·|Y|·wMax0(Λ) is integrable, the weighted control indicator 1_{D=0}·wMax0(Λ) is integrable, and the cutoff-weighted envelope |c|·1_{D=0}·wMax0(Λ) is integrable, then for any almost-everywhere measurable candidate complete control propensity ẽ in the calibrated ambiguity set, the candidate mean at the lower quantile-cutoff weight is no greater than the candidate mean at ẽ — the lower cutoff attains the minimum over all calibrated candidates.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
henv :
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
etilde :
P.Ω → ℝ
hmem :
etilde ∈ S.MSMSetCalib0 Λ
hmeas :
AEMeasurable etilde P.μ
conclusion
S.candMean0 (S.lowerCutoffProp0 Λ c) ≤ S.candMean0 etilde
Proof (Lean source)
theorem cutoff_optimal0_lower (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ)
(henv : Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
{etilde : P.Ω → ℝ} (hmem : etilde ∈ S.MSMSetCalib0 Λ)
(hmeas : AEMeasurable etilde P.μ) :
S.candMean0 (S.lowerCutoffProp0 Λ c) ≤ S.candMean0 etilde := by
classical
have _ : Integrable c P.μ := hc_int
have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le one_pos hΛ
set A : P.Ω → ℝ := S.dVar.indicator false with hA_def
set Y : P.Ω → ℝ := S.factualY with hY_def
set e : P.Ω → ℝ := S.propScore false with he_def
set wE : P.Ω → ℝ := fun ω => 1 / etilde ω with hwE_def
set wC : P.Ω → ℝ :=
fun ω => if c ω < Y ω then S.wMin0 Λ ω else S.wMax0 Λ ω with hwC_def
have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 →
((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et
∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by
intro e0 et he0 he1 het0 het1
have h1e : 0 < 1 - e0 := by linarith
have h1et : 0 < 1 - et := by linarith
have hOReq : OR et e0 = et * (1 - e0) / ((1 - et) * e0) := by
rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm]
ring_nf
rw [hOReq]
have hMax : (1 / Λ ≤ et * (1 - e0) / ((1 - et) * e0))
↔ (1 / et ≤ 1 + Λ * (1 - e0) / e0) := by
rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + Λ * (1 - e0) / e0 = (e0 + Λ * (1 - e0)) / e0 by
field_simp,
div_le_div_iff₀ het0 he0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
have hMin : (et * (1 - e0) / ((1 - et) * e0) ≤ Λ)
↔ (1 + (1 - e0) / (Λ * e0) ≤ 1 / et) := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + (1 - e0) / (Λ * e0) = (Λ * e0 + (1 - e0)) / (Λ * e0) by
field_simp,
div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e0) het0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
rw [hMax, hMin, and_comm]
have hAm : Measurable A := by
rw [hA_def]
exact S.dVar.measurable_indicator false (measurableSet_singleton false)
have hYm : Measurable Y := by
rw [hY_def]
exact S.measurable_factualY
have hem : Measurable e := by
rw [he_def]
unfold POBackdoorSystem.propScore
exact (stronglyMeasurable_condExp.mono S.sigmaX_le).measurable
have hwMaxm : Measurable (S.wMax0 Λ) := by
unfold POBackdoorSystem.wMax0
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hem)).div hem))
have hwMinm : Measurable (S.wMin0 Λ) := by
unfold POBackdoorSystem.wMin0
exact (measurable_const.add
((measurable_const.sub hem).div (measurable_const.mul hem)))
have hwCm : Measurable wC := by
rw [hwC_def]
exact Measurable.ite (measurableSet_lt (hc_meas.mono S.sigmaX_le le_rfl) hYm)
hwMinm hwMaxm
have hA0 : ∀ ω, 0 ≤ A ω := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero false ω with h | h <;> simp [hA_def, h]
have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin0 Λ ω ∧ S.wMin0 Λ ω ≤ S.wMax0 Λ ω := by
filter_upwards [hoverlap] with ω hω
obtain ⟨he0ω, he1ω⟩ := hω
have h1e : 0 < 1 - e ω := by rw [he_def] at *; linarith
have he0' : 0 < e ω := by rw [he_def] at *; exact he0ω
refine ⟨?_, ?_⟩
· have : 0 < (1 - e ω) / (Λ * e ω) := by positivity
simp only [POBackdoorSystem.wMin0, ← he_def]
linarith
· simp only [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, ← he_def]
have hd1 : (1 - e ω) / (Λ * e ω) ≤ Λ * (1 - e ω) / e ω := by
rw [div_le_div_iff₀ (by positivity) he0']
nlinarith [hΛ, mul_pos h1e he0', mul_pos hΛ0 he0',
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0')) (sub_nonneg.mpr hΛ)]
linarith
have hboxE : ∀ᵐ ω ∂P.μ,
S.wMin0 Λ ω ≤ wE ω ∧ wE ω ≤ S.wMax0 Λ ω := by
obtain ⟨hinterior, hor⟩ := hmem.1
filter_upwards [hoverlap, hinterior, hor] with ω hov het hOR
obtain ⟨he0ω, he1ω⟩ := hov
obtain ⟨het0, het1⟩ := het
have hbox := (hOR_box he0ω he1ω het0 het1).mp hOR
simpa [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, he_def, hwE_def] using hbox
have hboxC : ∀ᵐ ω ∂P.μ,
S.wMin0 Λ ω ≤ wC ω ∧ wC ω ≤ S.wMax0 Λ ω ∧ 0 < wC ω := by
filter_upwards [hae] with ω hω
obtain ⟨hmin1, hminmax⟩ := hω
rw [hwC_def]
by_cases hcy : c ω < Y ω
· simp only [if_pos hcy]
exact ⟨le_rfl, hminmax, by linarith⟩
· simp only [if_neg hcy]
exact ⟨hminmax, le_rfl, lt_of_lt_of_le (by linarith) hminmax⟩
have hYE_int : Integrable (fun ω => A ω * Y ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by
rw [hwE_def]
exact aemeasurable_const.div hmeas
refine Integrable.mono' henv
(((hAm.mul hYm).aemeasurable.mul hwE_aem).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hYC_int : Integrable (fun ω => A ω * Y ω * wC ω) P.μ := by
refine Integrable.mono' henv
(((hAm.mul hYm).mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hXE_int : Integrable (fun ω => A ω / etilde ω) P.μ := by
refine Integrable.mono' hweight_env
((hAm.aemeasurable.div hmeas).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_div, abs_of_nonneg (hA0 ω), abs_of_pos het0,
div_eq_mul_inv, ← one_div, hA_def]
simpa [hA_def, hwE_def] using mul_le_mul_of_nonneg_left hmax (hA0 ω)
have hXC_int : Integrable (fun ω => A ω / S.lowerCutoffProp0 Λ c ω) P.μ := by
have hAwC_int : Integrable (fun ω => A ω * wC ω) P.μ := by
refine Integrable.mono' hweight_env ((hAm.mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (hA0 ω), abs_of_nonneg (le_of_lt hpos)]
exact mul_le_mul_of_nonneg_left hmax (hA0 ω)
refine hAwC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change A ω * wC ω =
A ω / (1 / (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
have hcE_int : Integrable (fun ω => c ω * A ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by
rw [hwE_def]
exact aemeasurable_const.div hmeas
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).aemeasurable.mul hwE_aem).aestronglyMeasurable ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
simpa [mul_assoc, hwE_def, one_div] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hcC_int : Integrable (fun ω => c ω * A ω * wC ω) P.μ := by
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).mul hwCm).aestronglyMeasurable ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
simpa [mul_assoc] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hfirstE_int : Integrable (fun ω => A ω * (Y ω - c ω) * wE ω) P.μ := by
refine (hYE_int.sub hcE_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wE ω - c ω * A ω * wE ω = A ω * (Y ω - c ω) * wE ω
ring
have hfirstC_int : Integrable (fun ω => A ω * (Y ω - c ω) * wC ω) P.μ := by
refine (hYC_int.sub hcC_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wC ω - c ω * A ω * wC ω = A ω * (Y ω - c ω) * wC ω
ring
have hctermE_eq : ∫ ω, c ω * A ω * wE ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / etilde ω)) P.μ := by
refine hcE_int.congr (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω => c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXE_int
have hcal : P.μ[fun ω => A ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated0, hA_def] using hmem.2
have hmain : ∫ ω, c ω * (A ω / etilde ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / etilde ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
calc
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω ∂P.μ :=
integral_congr_ae hpull
_ = ∫ ω, c ω * 1 ∂P.μ := by
refine integral_congr_ae ?_
filter_upwards [hcal] with ω hω
rw [hω]
_ = ∫ ω, c ω ∂P.μ := by simp
rw [← hmain]
refine integral_congr_ae (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hctermC_eq : ∫ ω, c ω * A ω * wC ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / S.lowerCutoffProp0 Λ c ω)) P.μ := by
refine hcC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change c ω * A ω * wC ω =
c ω * (A ω / (1 / (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω)))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / S.lowerCutoffProp0 Λ c ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω =>
c ω * P.μ[fun ω => A ω / S.lowerCutoffProp0 Λ c ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXC_int
have hcal :
P.μ[fun ω => A ω / S.lowerCutoffProp0 Λ c ω | S.sigmaX]
=ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated0, hA_def] using hcut_mem.2
have hmain :
∫ ω, c ω * (A ω / S.lowerCutoffProp0 Λ c ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / S.lowerCutoffProp0 Λ c ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / S.lowerCutoffProp0 Λ c ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
-- … truncated; follow the source link for the rest …
theorem msmLowerCalib0_eq_cutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp lower bound has the quantile-balancing closed form. Fix a sensitivity parameter Λ at least one. Under two-sided overlap of the control propensity score, given a σ(X)-measurable, integrable cutoff c whose induced lower quantile-cutoff propensity is itself calibrated-feasible, and assuming the envelope, weighted-indicator, and cutoff-weighted envelope integrability conditions bounding the IPW integrands together with almost-everywhere measurability of every calibrated candidate propensity, the sharp (infimum) lower bound for E[Y(0)] over the calibrated ambiguity set equals the candidate mean evaluated at the lower quantile-cutoff propensity.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
henv :
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hmeas :
∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ
conclusion
S.msmLowerCalib0 Λ = S.candMean0 (S.lowerCutoffProp0 Λ c)
Proof (Lean source)
theorem msmLowerCalib0_eq_cutoff (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ)
(henv : Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hmeas : ∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ) :
S.msmLowerCalib0 Λ = S.candMean0 (S.lowerCutoffProp0 Λ c) := by
classical
have hne : (S.candMean0 '' S.MSMSetCalib0 Λ).Nonempty :=
⟨S.candMean0 (S.lowerCutoffProp0 Λ c), Set.mem_image_of_mem _ hcut_mem⟩
have hle_all :
∀ x ∈ S.candMean0 '' S.MSMSetCalib0 Λ,
S.candMean0 (S.lowerCutoffProp0 Λ c) ≤ x := by
rintro x ⟨etilde, hmem, rfl⟩
exact S.cutoff_optimal0_lower Λ hΛ hoverlap c hc_meas hc_int hcut_mem henv hweight_env
hc_env hmem (hmeas etilde hmem)
have hbdd : BddBelow (S.candMean0 '' S.MSMSetCalib0 Λ) :=
⟨S.candMean0 (S.lowerCutoffProp0 Λ c), hle_all⟩
refine le_antisymm ?_ ?_
· unfold POBackdoorSystem.msmLowerCalib0
exact csInf_le hbdd (Set.mem_image_of_mem _ hcut_mem)
· unfold POBackdoorSystem.msmLowerCalib0
exact le_csInf hne hle_all
theorem msmLowerCalib0_eq_cutoff_unconditional reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp lower bound, unconditionally. Fix a sensitivity parameter Λ strictly greater than one. Assume two-sided overlap of the control propensity score, that the control-arm conditional law of the outcome given covariates is atomless, i.e. its conditional CDF is continuous, and that the lower calibration quantile level lies strictly between 0 and 1 almost everywhere. If every calibrated candidate propensity is almost-everywhere measurable and every σ(X)-measurable cutoff satisfies the integrability conditions needed for the calibration and optimality arguments, then there exists a σ(X)-measurable cutoff function whose induced lower quantile-cutoff propensity is calibrated-feasible, at which the sharp (infimum) lower bound for E[Y(0)] equals the candidate mean.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomless :
∀ a : γ, Continuous (condCDF S.controlXYLaw a)
hlevel :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1
hmeas :
∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ
hreg :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
conclusion
∃ c : P.Ω → ℝ,
conclusion 1
Measurable[S.sigmaX] c
conclusion 2
S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
conclusion 3
S.msmLowerCalib0 Λ = S.candMean0 (S.lowerCutoffProp0 Λ c)
Proof (Lean source)
theorem msmLowerCalib0_eq_cutoff_unconditional (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(hatomless : ∀ a : γ, Continuous (condCDF S.controlXYLaw a))
(hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1)
(hmeas : ∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ)
(hreg : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) :
∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧
S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ ∧
S.msmLowerCalib0 Λ = S.candMean0 (S.lowerCutoffProp0 Λ c) := by
obtain ⟨c, hc_meas, hsurv⟩ :=
S.exists_calibrating_cutoff0_lower Λ hΛ hoverlap hatomless hlevel
obtain ⟨hc_int, hint, hint1, hmax_int, hdiff_int,
henv, hc_env⟩ := hreg c hc_meas
have hcut_mem : S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ :=
S.lowerCutoffProp0_mem_MSMSetCalib0_of_survival Λ hΛ hoverlap c hc_meas
hint hint1 hmax_int hdiff_int hsurv
have heq : S.msmLowerCalib0 Λ = S.candMean0 (S.lowerCutoffProp0 Λ c) :=
S.msmLowerCalib0_eq_cutoff Λ (le_of_lt hΛ) hoverlap c hc_meas
hc_int hcut_mem henv hmax_int hc_env hmeas
exact ⟨c, hc_meas, hcut_mem, heq⟩
5 supporting declarations (lemmas, instances)
-
lowerControl_calibValue_eqtheorem — Decomposition of the lower-cutoff calibration value. E[(1-Z)/lowerCutoffProp0 Λ c | σ(X)] = wMax0·e₀ − (wMax0 − wMin0)·G(c), with G(c) = controlSurv c.hypothesesγ :sharedType u_1Λ :ℝc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmax_int :Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μProof (Lean source)
theorem lowerControl_calibValue_eq (Λ : ℝ) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmax_int : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) : P.μ[fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω | S.sigmaX] =ᵐ[P.μ] (fun ω => S.wMax0 Λ ω * S.propScore false ω - (S.wMax0 Λ ω - S.wMin0 Λ ω) * S.controlSurv c ω) := by classical have _hc_meas_used := hc_meas have _hint_used := hint set A : P.Ω → ℝ := S.dVar.indicator false with hA_def set I : P.Ω → ℝ := fun ω => if c ω < S.factualY ω then (1 : ℝ) else 0 with hI_def have hprop_meas : Measurable[S.sigmaX] (S.propScore false) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable have hwMin_smeas : StronglyMeasurable[S.sigmaX] (S.wMin0 Λ) := by unfold POBackdoorSystem.wMin0 exact (measurable_const.add ((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas))).stronglyMeasurable have hwMax_smeas : StronglyMeasurable[S.sigmaX] (S.wMax0 Λ) := by unfold POBackdoorSystem.wMax0 exact (measurable_const.add ((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas)).stronglyMeasurable have hdiff_smeas : StronglyMeasurable[S.sigmaX] (fun ω => S.wMax0 Λ ω - S.wMin0 Λ ω) := (hwMax_smeas.measurable.sub hwMin_smeas.measurable).stronglyMeasurable have hA_int : Integrable A P.μ := by rw [hA_def] exact S.dVar.integrable_indicator (μ := P.μ) false (measurableSet_singleton false) have hI_int : Integrable (fun ω => A ω * I ω) P.μ := by rw [hA_def, hI_def] exact hint1 have hmax_int' : Integrable (fun ω => S.wMax0 Λ ω * A ω) P.μ := by refine hmax_int.congr (Filter.Eventually.of_forall ?_) intro ω rw [hA_def] exact mul_comm _ _ have hpoint : (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) =ᵐ[P.μ] (fun ω => S.wMax0 Λ ω * A ω - (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω)) := by refine Filter.Eventually.of_forall ?_ intro ω rw [hA_def, hI_def] by_cases hcy : c ω < S.factualY ω · simp only [POBackdoorSystem.lowerCutoffProp0, if_pos hcy] rw [div_div_eq_mul_div, div_one] ring · simp only [POBackdoorSystem.lowerCutoffProp0, if_neg hcy] rw [div_div_eq_mul_div, div_one] ring refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_ have hsplit : P.μ[fun ω => S.wMax0 Λ ω * A ω - (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX] =ᵐ[P.μ] P.μ[fun ω => S.wMax0 Λ ω * A ω | S.sigmaX] - P.μ[fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX] := MeasureTheory.condExp_sub hmax_int' hdiff_int S.sigmaX have hpullMax : P.μ[fun ω => S.wMax0 Λ ω * A ω | S.sigmaX] =ᵐ[P.μ] (fun ω => S.wMax0 Λ ω * S.propScore false ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaX) (μ := P.μ) hwMax_smeas hmax_int' hA_int exact h.trans (Filter.EventuallyEq.of_eq (by funext ω rfl)) have hpullDiff : P.μ[fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX] =ᵐ[P.μ] (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * S.controlSurv c ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaX) (μ := P.μ) hdiff_smeas hdiff_int hI_int exact h.trans (Filter.EventuallyEq.of_eq (by funext ω rfl)) filter_upwards [hsplit, hpullMax, hpullDiff] with ω hsplitω hmaxω hdiffω rw [hsplitω] change P.μ[fun ω => S.wMax0 Λ ω * A ω | S.sigmaX] ω - P.μ[fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (A ω * I ω) | S.sigmaX] ω = S.wMax0 Λ ω * S.propScore false ω - (S.wMax0 Λ ω - S.wMin0 Λ ω) * S.controlSurv c ω rw [hmaxω, hdiffω] -
lowerCutoffProp0_calibrated_of_survivaltheorem — Lower-cutoff calibration from the survival equation.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmax_int :Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μhsurv :S.controlSurv c =ᵐ[P.μ] S.survTargetLower0 ΛconclusionS.Calibrated0 (S.lowerCutoffProp0 Λ c)Proof (Lean source)
theorem lowerCutoffProp0_calibrated_of_survival (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmax_int : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) (hsurv : S.controlSurv c =ᵐ[P.μ] S.survTargetLower0 Λ) : S.Calibrated0 (S.lowerCutoffProp0 Λ c) := by unfold POBackdoorSystem.Calibrated0 have hΛ0 : 0 < Λ := lt_trans zero_lt_one hΛ refine (S.lowerControl_calibValue_eq Λ c hc_meas hint hint1 hmax_int hdiff_int).trans ?_ filter_upwards [hoverlap, hsurv] with ω hω hsurvω rw [hsurvω] set e : ℝ := S.propScore false ω with he_def have he0 : 0 < e := by simpa [he_def] using hω.1 have he1 : e < 1 := by simpa [he_def] using hω.2 have hdiff_pos : 0 < S.wMax0 Λ ω - S.wMin0 Λ ω := by simp only [POBackdoorSystem.wMax0, POBackdoorSystem.wMin0, ← he_def] have h1e : 0 < 1 - e := by linarith have hΛsq : 0 < Λ * Λ - 1 := by nlinarith field_simp [hΛ0.ne', he0.ne'] nlinarith [h1e, hΛsq, hΛ0, he0] have hdiff_ne : S.wMax0 Λ ω - S.wMin0 Λ ω ≠ 0 := hdiff_pos.ne' unfold POBackdoorSystem.survTargetLower0 field_simp [hdiff_ne] ring -
lowerCutoffProp0_mem_MSMSet0theorem — The lower cutoff propensity is always in the odds-ratio box.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 ≤ Λc :P.Ω → ℝconclusionS.lowerCutoffProp0 Λ c ∈ S.MSMSet0 ΛProof (Lean source)
theorem lowerCutoffProp0_mem_MSMSet0 (Λ : ℝ) (hΛ : 1 ≤ Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) (c : P.Ω → ℝ) : S.lowerCutoffProp0 Λ c ∈ S.MSMSet0 Λ := by classical have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le zero_lt_one hΛ have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 → ((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ) ↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et ∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by intro e et he0 he1 het0 het1 have h1e : 0 < 1 - e := by linarith have h1et : 0 < 1 - et := by linarith have hOReq : OR et e = et * (1 - e) / ((1 - et) * e) := by rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm] ring_nf rw [hOReq] have hMax : (1 / Λ ≤ et * (1 - e) / ((1 - et) * e)) ↔ (1 / et ≤ 1 + Λ * (1 - e) / e) := by rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e), show (1 : ℝ) + Λ * (1 - e) / e = (e + Λ * (1 - e)) / e by field_simp, div_le_div_iff₀ het0 he0] constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0] have hMin : (et * (1 - e) / ((1 - et) * e) ≤ Λ) ↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et) := by rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e), show (1 : ℝ) + (1 - e) / (Λ * e) = (Λ * e + (1 - e)) / (Λ * e) by field_simp, div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e) het0] constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0] rw [hMax, hMin, and_comm] have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin0 Λ ω ∧ S.wMin0 Λ ω ≤ S.wMax0 Λ ω := by filter_upwards [hoverlap] with ω hω set e : ℝ := S.propScore false ω with he_def have he0 : 0 < e := by simpa [he_def] using hω.1 have he1 : e < 1 := by simpa [he_def] using hω.2 have h1e : 0 < 1 - e := by linarith refine ⟨?_, ?_⟩ · have : 0 < (1 - e) / (Λ * e) := by positivity simp only [POBackdoorSystem.wMin0, ← he_def] linarith · simp only [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, ← he_def] have hd1 : (1 - e) / (Λ * e) ≤ Λ * (1 - e) / e := by rw [div_le_div_iff₀ (by positivity) he0] nlinarith [hΛ, mul_pos h1e he0, mul_pos hΛ0 he0, mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0)) (sub_nonneg.mpr hΛ)] linarith have hboxC : ∀ᵐ ω ∂P.μ, S.wMin0 Λ ω ≤ (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω) ∧ (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω) ≤ S.wMax0 Λ ω ∧ 1 < (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω) := by filter_upwards [hae] with ω hω obtain ⟨hmin1, hminmax⟩ := hω by_cases hcy : c ω < S.factualY ω · simp only [if_pos hcy] exact ⟨le_rfl, hminmax, hmin1⟩ · simp only [if_neg hcy] exact ⟨hminmax, le_rfl, lt_of_lt_of_le hmin1 hminmax⟩ refine ⟨?_, ?_⟩ · filter_upwards [hboxC] with ω hω obtain ⟨_, _, hwgt⟩ := hω unfold POBackdoorSystem.lowerCutoffProp0 constructor · positivity · rw [div_lt_one (by linarith)] linarith · filter_upwards [hoverlap, hboxC] with ω hov hw obtain ⟨he0, he1⟩ := hov obtain ⟨hmin, hmax, hwgt⟩ := hw set wC : ℝ := if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω with hwC_def have hcut : S.lowerCutoffProp0 Λ c ω = 1 / wC := by rw [POBackdoorSystem.lowerCutoffProp0, hwC_def] have het0 : 0 < S.lowerCutoffProp0 Λ c ω := by rw [hcut] positivity have het1 : S.lowerCutoffProp0 Λ c ω < 1 := by rw [hcut, div_lt_one (by linarith)] linarith rw [(hOR_box he0 he1 het0 het1)] have hinv : 1 / S.lowerCutoffProp0 Λ c ω = wC := by rw [hcut, one_div_one_div] rw [hinv] simpa [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, hwC_def] using ⟨hmin, hmax⟩ -
lowerCutoffProp0_mem_MSMSetCalib0_of_survivaltheorem — The lower cutoff is calibrated-feasible given the survival equation.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmax_int :Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μhsurv :S.controlSurv c =ᵐ[P.μ] S.survTargetLower0 ΛconclusionS.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 ΛProof (Lean source)
theorem lowerCutoffProp0_mem_MSMSetCalib0_of_survival (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmax_int : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) (hsurv : S.controlSurv c =ᵐ[P.μ] S.survTargetLower0 Λ) : S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ := by exact ⟨S.lowerCutoffProp0_mem_MSMSet0 Λ (le_of_lt hΛ) hoverlap c, S.lowerCutoffProp0_calibrated_of_survival Λ hΛ hoverlap c hc_meas hint hint1 hmax_int hdiff_int hsurv⟩ -
exists_calibrating_cutoff0_lowertheorem — Existence of a calibrating lower cutoff. The survTargetLower0 analogue of exists_calibrating_cutoff: a σ(X)-measurable c with controlSurv c =ᵐ survTargetLower0 Λ.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λhatomless :∀ a : γ, Continuous (condCDF S.controlXYLaw a)hlevel :∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1conclusion∃ c : P.Ω → ℝ,conclusion 1Measurable[S.sigmaX] cconclusion 2S.controlSurv c =ᵐ[P.μ] S.survTargetLower0 ΛProof (Lean source)
theorem exists_calibrating_cutoff0_lower (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1) (hatomless : ∀ a : γ, Continuous (condCDF S.controlXYLaw a)) (hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1) : ∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧ S.controlSurv c =ᵐ[P.μ] S.survTargetLower0 Λ := by classical have _hΛ_used := hΛ have hprop_meas : Measurable[S.sigmaX] (S.propScore false) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable have hwMin_meas : Measurable[S.sigmaX] (S.wMin0 Λ) := by unfold POBackdoorSystem.wMin0 exact measurable_const.add ((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas)) have hwMax_meas : Measurable[S.sigmaX] (S.wMax0 Λ) := by unfold POBackdoorSystem.wMax0 exact measurable_const.add ((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas) have hsurvTarget_meas : Measurable[S.sigmaX] (S.survTargetLower0 Λ) := by unfold POBackdoorSystem.survTargetLower0 exact ((hwMax_meas.mul hprop_meas).sub measurable_const).div (hwMax_meas.sub hwMin_meas) have hlevel_meas : Measurable[S.sigmaX] (S.calibLevelLower0 Λ) := by unfold POBackdoorSystem.calibLevelLower0 exact measurable_const.sub (hsurvTarget_meas.div hprop_meas) obtain ⟨g, hg, hg_eq⟩ := S.exists_factor_through_factualX hlevel_meas let τ : γ → ℝ := fun a => if 0 < g a ∧ g a < 1 then g a else (1 / 2 : ℝ) have hτ_meas : Measurable τ := by dsimp [τ] refine Measurable.ite ?_ hg measurable_const exact (measurableSet_lt measurable_const hg).inter (measurableSet_lt hg measurable_const) have hτ0 : ∀ a, 0 < τ a := by intro a dsimp [τ] by_cases ha : 0 < g a ∧ g a < 1 · simp [ha] · simp [ha] have hτ1 : ∀ a, τ a < 1 := by intro a dsimp [τ] by_cases ha : 0 < g a ∧ g a < 1 · simp [ha] · simp only [ha, ↓reduceIte] norm_num haveI : IsFiniteMeasure S.controlXYLaw := by unfold POBackdoorSystem.controlXYLaw infer_instance obtain ⟨hq_meas, hq_attain⟩ := measurable_condQuantile_and_attains S.controlXYLaw τ hτ_meas hτ0 hτ1 (fun a => (hatomless a).continuousAt) let c : P.Ω → ℝ := fun ω => condQuantile S.controlXYLaw τ (S.factualX ω) have hc_meas : Measurable[S.sigmaX] c := by rw [POBackdoorSystem.sigmaX] exact hq_meas.comp (comap_measurable S.factualX) refine ⟨c, hc_meas, ?_⟩ have hτ_eq_level : ∀ᵐ ω ∂P.μ, τ (S.factualX ω) = S.calibLevelLower0 Λ ω := by filter_upwards [hlevel] with ω hω have hgx : g (S.factualX ω) = S.calibLevelLower0 Λ ω := by exact (congrFun hg_eq ω).symm dsimp [τ] rw [hgx] simp [hω] have hsurv := S.controlSurv_eq c hc_meas filter_upwards [hsurv, hτ_eq_level, hoverlap] with ω hsurvω hτω hoverlapω rw [hsurvω] have hcdf : S.controlCondCDF ω (c ω) = τ (S.factualX ω) := by unfold POBackdoorSystem.controlCondCDF c exact hq_attain (S.factualX ω) rw [hcdf, hτω] unfold POBackdoorSystem.calibLevelLower0 have hpos : S.propScore false ω ≠ 0 := ne_of_gt hoverlapω.1 field_simp [hpos] ring
Gaussian 3 core · 3 supporting This file specializes the treated-arm calibrated MSM upper bound to conditional Gaussian outcome laws. ★ msmUpperCalib_gaussian
Gaussian treated-arm MSM cutoff formula
This file specializes the treated-arm calibrated MSM upper bound to conditional
Gaussian outcome laws. It proves the propensity-free calibration level
calibLevel_eq, introduces the conditional-Gaussian CDF assumption
GaussianTreatedModel, defines the explicit quantile cutoff gaussianCutoff,
proves gaussianCutoff_calibrates, and concludes with msmUpperCalib_gaussian:
the sharp calibrated upper endpoint is the candidate mean at that explicit
Gaussian cutoff. The separate half-width file evaluates that candidate mean in
closed form.
structure GaussianTreatedModel reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The conditional-Gaussian treated-outcome model. The treated conditional law of Y given X is N(m(X), σ(X)²): a measurable mean m and positive standard deviation σ with condCDF treatedXYLaw a t = Φ((t − m a)/σ a) for all a, t.
Definition (Lean source)
parameters
assumes
measurable_m :
measurable_σ :
σ_pos :
∀ a, 0 < σ a
condCDF_eq :
∀ a t, condCDF S.treatedXYLaw a t = stdNormalCDF ((t - m a) / σ a)
def gaussianCutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcome backdoor system, a covariate-indexed mean function and standard-deviation function, a sensitivity parameter, and a sample point, the explicit Gaussian cutoff is .
Definition (Lean source)
parameters
def
gaussianCutoff S m σ Λ ω :
ℝ
given by
m (S.factualX ω) + σ (S.factualX ω) * probit (Λ / (Λ + 1))
theorem msmUpperCalib_gaussian reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp upper bound at the explicit Gaussian cutoff. Fix a sensitivity parameter Λ strictly greater than 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). Under the conditional-Gaussian treated-outcome model, i.e. the treated conditional law of the outcome given the covariates is Gaussian with mean m and standard deviation σ, assuming every candidate complete propensity in the calibrated ambiguity set is almost-everywhere measurable and the integrability conditions needed to make the candidate means, the survival decomposition, and the cutoff propensity well defined, the sharp (Dorn–Guo) upper bound on E[Y(1)] equals the candidate IPW mean evaluated at the cutoff propensity built from the explicit Gaussian quantile cutoff m(X) + σ(X)·Φ⁻¹(Λ/(Λ+1)).
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
m σ :
γ → ℝ
hmodel :
S.GaussianTreatedModel m σ
hmeas :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
hreg :
Integrable (S.gaussianCutoff m σ Λ) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ (S.gaussianCutoff m σ Λ) ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |S.gaussianCutoff m σ Λ ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
conclusion
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ (S.gaussianCutoff m σ Λ))
Proof (Lean source)
theorem msmUpperCalib_gaussian (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
{m σ : γ → ℝ} (hmodel : S.GaussianTreatedModel m σ)
(hmeas : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ)
(hreg : Integrable (S.gaussianCutoff m σ Λ) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ (S.gaussianCutoff m σ Λ) ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω *
(if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω *
(if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |S.gaussianCutoff m σ Λ ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ) :
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ (S.gaussianCutoff m σ Λ)) := by
let c := S.gaussianCutoff m σ Λ
have hc : Measurable[S.sigmaX] c :=
S.measurable_gaussianCutoff hmodel.measurable_m hmodel.measurable_σ Λ
have hsurv : S.treatedSurv c =ᵐ[P.μ] S.survTarget Λ := by
simpa [c] using S.gaussianCutoff_calibrates Λ hΛ hoverlap hmodel
obtain ⟨hc_int, hint, hint1, hmin_int, hdiff_int,
henv, hweight_env, hc_env⟩ := hreg
have hcut_mem : S.cutoffProp Λ c ∈ S.MSMSetCalib Λ :=
S.cutoffProp_mem_MSMSetCalib_of_survival Λ hΛ hoverlap c hc
hint hint1 hmin_int hdiff_int hsurv
exact S.msmUpperCalib_eq_cutoff Λ (le_of_lt hΛ) hoverlap c hc
hc_int hcut_mem henv hweight_env hc_env hmeas
3 supporting declarations (lemmas, instances)
-
calibLevel_eqtheorem — The calibration level is exactly Λ/(Λ+1). Under overlap and 1 < Λ, the sharp-upper-bound quantile level calibLevel = 1 − survTarget/e equals Λ/(Λ+1) a.e., independent of the propensity e(X) — because survTarget = e/(Λ+1). Pure algebra from wMin, wMax.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λconclusion∀ᵐ ω ∂P.μ, S.calibLevel Λ ω = Λ / (Λ + 1)Proof (Lean source)
theorem calibLevel_eq (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) : ∀ᵐ ω ∂P.μ, S.calibLevel Λ ω = Λ / (Λ + 1) := by filter_upwards [hoverlap] with ω hω unfold POBackdoorSystem.calibLevel rw [S.survTarget_eq_prop_div Λ hΛ hω] have he0 : S.propScore true ω ≠ 0 := ne_of_gt hω.1 have hΛp : Λ + 1 ≠ 0 := ne_of_gt (by linarith : (0 : ℝ) < Λ + 1) field_simp [he0, hΛp] ring -
measurable_gaussianCutofftheorem — The explicit Gaussian cutoff is σ(X)-measurable.hypothesesγ :sharedType u_1m σ :γ → ℝhm :hσ :Λ :ℝconclusionMeasurable[S.sigmaX] (S.gaussianCutoff m σ Λ)Proof (Lean source)
@[fun_prop] theorem measurable_gaussianCutoff {m σ : γ → ℝ} (hm : Measurable m) (hσ : Measurable σ) (Λ : ℝ) : Measurable[S.sigmaX] (S.gaussianCutoff m σ Λ) := by unfold POBackdoorSystem.gaussianCutoff change Measurable[comap S.factualX inferInstance] (fun ω => m (S.factualX ω) + σ (S.factualX ω) * probit (Λ / (Λ + 1))) exact (hm.comp (comap_measurable S.factualX)).add ((hσ.comp (comap_measurable S.factualX)).mul measurable_const) -
gaussianCutoff_calibratestheorem — The explicit Gaussian cutoff calibrates. Under the conditional-Gaussian model, the cutoff m(X) + σ(X)·Φ⁻¹(Λ/(Λ+1)) solves the survival equation treatedSurv c =ᵐ survTarget Λ.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λm σ :γ → ℝhmodel :S.GaussianTreatedModel m σconclusionS.treatedSurv (S.gaussianCutoff m σ Λ) =ᵐ[P.μ] S.survTarget ΛProof (Lean source)
theorem gaussianCutoff_calibrates (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) {m σ : γ → ℝ} (hmodel : S.GaussianTreatedModel m σ) : S.treatedSurv (S.gaussianCutoff m σ Λ) =ᵐ[P.μ] S.survTarget Λ := by have hc : Measurable[S.sigmaX] (S.gaussianCutoff m σ Λ) := S.measurable_gaussianCutoff hmodel.measurable_m hmodel.measurable_σ Λ have hsurv := S.treatedSurv_eq (S.gaussianCutoff m σ Λ) hc filter_upwards [hsurv, hoverlap] with ω hsurvω hω rw [hsurvω] have hσpos : 0 < σ (S.factualX ω) := hmodel.σ_pos (S.factualX ω) have hσne : σ (S.factualX ω) ≠ 0 := ne_of_gt hσpos have hp0 : 0 < Λ / (Λ + 1) := by positivity have hp1 : Λ / (Λ + 1) < 1 := by have hΛp : 0 < Λ + 1 := by linarith rw [div_lt_one hΛp] linarith have hcdf : S.treatedCondCDF ω (S.gaussianCutoff m σ Λ ω) = Λ / (Λ + 1) := by unfold POBackdoorSystem.treatedCondCDF rw [hmodel.condCDF_eq] have harg : (S.gaussianCutoff m σ Λ ω - m (S.factualX ω)) / σ (S.factualX ω) = probit (Λ / (Λ + 1)) := by unfold POBackdoorSystem.gaussianCutoff field_simp [hσne] ring rw [harg] exact stdNormalCDF_probit hp0 hp1 rw [hcdf, S.survTarget_eq_prop_div Λ hΛ hω] have hΛp_ne : Λ + 1 ≠ 0 := ne_of_gt (by linarith : (0 : ℝ) < Λ + 1) field_simp [hΛp_ne] ring
LowerBound 6 core · 7 supporting This file proves the lower-endpoint mirror of the treated-arm quantile-cutoff construction. ★ cutoff_optimal_lower★ exists_calibrating_cutoff_lower★ msmLowerCalib_eq_cutoff_unconditional
Sharp treated-arm lower bound for the marginal sensitivity model
This file proves the lower-endpoint mirror of the treated-arm quantile-cutoff
construction. It defines lowerCutoffProp, survTargetLower, and
calibLevelLower; proves lower-cutoff optimality and the endpoint identity
msmLowerCalib_eq_cutoff; reduces calibrated feasibility to the lower survival
equation; constructs a calibrating lower cutoff under continuous conditional
treated laws; and packages the unconditional sharp lower-bound theorem
msmLowerCalib_eq_cutoff_unconditional.
def lowerCutoffProp reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a sensitivity level, a cutoff function, and a unit, the lower quantile-cutoff complete propensity is the reciprocal of the lower inverse-probability weight when that unit's factual outcome exceeds its cutoff and of the upper inverse-probability weight otherwise.
Definition (Lean source)
parameters
def
lowerCutoffProp S Λ c ω :
ℝ
given by
1 / (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω)
def survTargetLower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a sensitivity level, and a unit, the lower target survival probability is the upper inverse-probability weight times the treatment propensity minus one, divided by the difference between the upper and lower inverse-probability weights.
Definition (Lean source)
parameters
def
survTargetLower S Λ ω :
ℝ
given by
(S.wMax Λ ω * S.propScore true ω - 1) / (S.wMax Λ ω - S.wMin Λ ω)
def calibLevelLower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a potential-outcomes system, a measurable covariate space, a back-door system on them, a sensitivity level, and a unit, the lower calibration quantile level is one minus the lower target survival probability divided by that unit's propensity for treatment.
Definition (Lean source)
theorem cutoff_optimal_lower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Optimality of the lower quantile-cutoff weight. Fix a sensitivity parameter Λ at least 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). For a σ(X)-measurable, integrable cutoff function c whose induced lower-cutoff candidate is feasible and calibrated, and under envelope-integrability conditions bounding the treated outcome, the treatment-weighted mass, and the cutoff-weighted mass by the upper marginal-sensitivity-model weight, then for any other calibrated, box-feasible candidate complete propensity ẽ that is almost-everywhere measurable, the lower-cutoff candidate mean is at most ẽ's candidate mean — the lower cutoff minimizes the candidate mean among calibrated candidates. The ≥-mirror of cutoff_optimal.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ
henv :
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
etilde :
P.Ω → ℝ
hmem :
etilde ∈ S.MSMSetCalib Λ
hmeas :
AEMeasurable etilde P.μ
conclusion
S.candMean (S.lowerCutoffProp Λ c) ≤ S.candMean etilde
Proof (Lean source)
theorem cutoff_optimal_lower (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ)
(henv : Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
{etilde : P.Ω → ℝ} (hmem : etilde ∈ S.MSMSetCalib Λ)
(hmeas : AEMeasurable etilde P.μ) :
S.candMean (S.lowerCutoffProp Λ c) ≤ S.candMean etilde := by
classical
have _ : Integrable c P.μ := by fun_prop
have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le one_pos hΛ
set A : P.Ω → ℝ := S.dVar.indicator true with hA_def
set Y : P.Ω → ℝ := S.factualY with hY_def
set e : P.Ω → ℝ := S.propScore true with he_def
set wE : P.Ω → ℝ := fun ω => 1 / etilde ω with hwE_def
set wC : P.Ω → ℝ :=
fun ω => if c ω < Y ω then S.wMin Λ ω else S.wMax Λ ω with hwC_def
have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 →
((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et
∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by
intro e0 et he0 he1 het0 het1
have h1e : 0 < 1 - e0 := by linarith
have h1et : 0 < 1 - et := by linarith
have hOReq : OR et e0 = et * (1 - e0) / ((1 - et) * e0) := by
rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm]
ring_nf
rw [hOReq]
have hMax : (1 / Λ ≤ et * (1 - e0) / ((1 - et) * e0))
↔ (1 / et ≤ 1 + Λ * (1 - e0) / e0) := by
rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + Λ * (1 - e0) / e0 = (e0 + Λ * (1 - e0)) / e0 by
field_simp,
div_le_div_iff₀ het0 he0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
have hMin : (et * (1 - e0) / ((1 - et) * e0) ≤ Λ)
↔ (1 + (1 - e0) / (Λ * e0) ≤ 1 / et) := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + (1 - e0) / (Λ * e0) = (Λ * e0 + (1 - e0)) / (Λ * e0) by
field_simp,
div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e0) het0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
rw [hMax, hMin, and_comm]
have hAm : Measurable A := by fun_prop
have hYm : Measurable Y := by
rw [hY_def]
exact S.measurable_factualY
have hem : Measurable e := by
rw [he_def]
unfold POBackdoorSystem.propScore
exact (stronglyMeasurable_condExp.mono S.sigmaX_le).measurable
have hwMaxm : Measurable (S.wMax Λ) := by fun_prop
have hwMinm : Measurable (S.wMin Λ) := by fun_prop
have hwCm : Measurable wC := by
rw [hwC_def]
exact Measurable.ite (measurableSet_lt (hc_meas.mono S.sigmaX_le le_rfl) hYm)
hwMinm hwMaxm
have hA0 : ∀ ω, 0 ≤ A ω := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero true ω with h | h <;> simp [hA_def, h]
have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin Λ ω ∧ S.wMin Λ ω ≤ S.wMax Λ ω := by
filter_upwards [hoverlap] with ω hω
obtain ⟨he0ω, he1ω⟩ := hω
have h1e : 0 < 1 - e ω := by rw [he_def] at *; linarith
have he0' : 0 < e ω := by rw [he_def] at *; exact he0ω
refine ⟨?_, ?_⟩
· have : 0 < (1 - e ω) / (Λ * e ω) := by positivity
simp only [POBackdoorSystem.wMin, ← he_def]
linarith
· simp only [POBackdoorSystem.wMin, POBackdoorSystem.wMax, ← he_def]
have hd1 : (1 - e ω) / (Λ * e ω) ≤ Λ * (1 - e ω) / e ω := by
rw [div_le_div_iff₀ (by positivity) he0']
nlinarith [hΛ, mul_pos h1e he0', mul_pos hΛ0 he0',
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0')) (sub_nonneg.mpr hΛ)]
linarith
have hboxE : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ wE ω ∧ wE ω ≤ S.wMax Λ ω := by
obtain ⟨hinterior, hor⟩ := hmem.1
filter_upwards [hoverlap, hinterior, hor] with ω hov het hOR
obtain ⟨he0ω, he1ω⟩ := hov
obtain ⟨het0, het1⟩ := het
have hbox := (hOR_box he0ω he1ω het0 het1).mp hOR
simpa [POBackdoorSystem.wMin, POBackdoorSystem.wMax, he_def, hwE_def] using hbox
have hboxC : ∀ᵐ ω ∂P.μ,
S.wMin Λ ω ≤ wC ω ∧ wC ω ≤ S.wMax Λ ω ∧ 0 < wC ω := by
filter_upwards [hae] with ω hω
obtain ⟨hmin1, hminmax⟩ := hω
rw [hwC_def]
by_cases hcy : c ω < Y ω
· simp only [if_pos hcy]
exact ⟨le_rfl, hminmax, by linarith⟩
· simp only [if_neg hcy]
exact ⟨hminmax, le_rfl, lt_of_lt_of_le (by linarith) hminmax⟩
have hYE_int : Integrable (fun ω => A ω * Y ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by fun_prop
refine Integrable.mono' henv
(((hAm.mul hYm).aemeasurable.mul hwE_aem).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hYC_int : Integrable (fun ω => A ω * Y ω * wC ω) P.μ := by
refine Integrable.mono' henv
(((hAm.mul hYm).mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hXE_int : Integrable (fun ω => A ω / etilde ω) P.μ := by
refine Integrable.mono' hweight_env
((hAm.aemeasurable.div hmeas).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_div, abs_of_nonneg (hA0 ω), abs_of_pos het0,
div_eq_mul_inv, ← one_div, hA_def]
simpa [hA_def, hwE_def] using mul_le_mul_of_nonneg_left hmax (hA0 ω)
have hXC_int : Integrable (fun ω => A ω / S.lowerCutoffProp Λ c ω) P.μ := by
have hAwC_int : Integrable (fun ω => A ω * wC ω) P.μ := by
refine Integrable.mono' hweight_env ((hAm.mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (hA0 ω), abs_of_nonneg (le_of_lt hpos)]
exact mul_le_mul_of_nonneg_left hmax (hA0 ω)
refine hAwC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change A ω * wC ω =
A ω / (1 / (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
have hcE_int : Integrable (fun ω => c ω * A ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by fun_prop
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).aemeasurable.mul hwE_aem).aestronglyMeasurable ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
simpa [mul_assoc, hwE_def, one_div] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hcC_int : Integrable (fun ω => c ω * A ω * wC ω) P.μ := by
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).mul hwCm).aestronglyMeasurable ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
simpa [mul_assoc] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hfirstE_int : Integrable (fun ω => A ω * (Y ω - c ω) * wE ω) P.μ := by
refine (hYE_int.sub hcE_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wE ω - c ω * A ω * wE ω = A ω * (Y ω - c ω) * wE ω
ring
have hfirstC_int : Integrable (fun ω => A ω * (Y ω - c ω) * wC ω) P.μ := by
refine (hYC_int.sub hcC_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wC ω - c ω * A ω * wC ω = A ω * (Y ω - c ω) * wC ω
ring
have hctermE_eq : ∫ ω, c ω * A ω * wE ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / etilde ω)) P.μ := by
refine hcE_int.congr (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω => c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXE_int
have hcal : P.μ[fun ω => A ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated, hA_def] using hmem.2
have hmain : ∫ ω, c ω * (A ω / etilde ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / etilde ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
calc
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω ∂P.μ :=
integral_congr_ae hpull
_ = ∫ ω, c ω * 1 ∂P.μ := by
refine integral_congr_ae ?_
filter_upwards [hcal] with ω hω
rw [hω]
_ = ∫ ω, c ω ∂P.μ := by simp
rw [← hmain]
refine integral_congr_ae (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hctermC_eq : ∫ ω, c ω * A ω * wC ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / S.lowerCutoffProp Λ c ω)) P.μ := by
refine hcC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change c ω * A ω * wC ω =
c ω * (A ω / (1 / (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω)))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / S.lowerCutoffProp Λ c ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω =>
c ω * P.μ[fun ω => A ω / S.lowerCutoffProp Λ c ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXC_int
have hcal :
P.μ[fun ω => A ω / S.lowerCutoffProp Λ c ω | S.sigmaX]
=ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated, hA_def] using hcut_mem.2
have hmain :
∫ ω, c ω * (A ω / S.lowerCutoffProp Λ c ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / S.lowerCutoffProp Λ c ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / S.lowerCutoffProp Λ c ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
calc
∫ ω, P.μ[fun ω => c ω * (A ω / S.lowerCutoffProp Λ c ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω *
P.μ[fun ω => A ω / S.lowerCutoffProp Λ c ω | S.sigmaX] ω ∂P.μ :=
integral_congr_ae hpull
_ = ∫ ω, c ω * 1 ∂P.μ := by
refine integral_congr_ae ?_
filter_upwards [hcal] with ω hω
rw [hω]
_ = ∫ ω, c ω ∂P.μ := by simp
rw [← hmain]
refine integral_congr_ae ?_
filter_upwards [hboxC] with ω hbox
change c ω * A ω * wC ω =
-- … truncated; follow the source link for the rest …
theorem exists_calibrating_cutoff_lower reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Existence of a calibrating lower cutoff. Fix a sensitivity parameter Λ strictly greater than 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). If the treated outcome's conditional distribution given each covariate value has a continuous cumulative distribution function and the lower calibration quantile level lies strictly between 0 and 1 almost surely, then there exists a σ(X)-measurable cutoff function whose conditional treated-survival equals the lower target survival almost everywhere. The survTargetLower analogue of exists_calibrating_cutoff.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomless :
∀ a : γ, Continuous (condCDF S.treatedXYLaw a)
hlevel :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1
conclusion
∃ c : P.Ω → ℝ,
conclusion 1
Measurable[S.sigmaX] c
conclusion 2
S.treatedSurv c =ᵐ[P.μ] S.survTargetLower Λ
Proof (Lean source)
theorem exists_calibrating_cutoff_lower (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hatomless : ∀ a : γ, Continuous (condCDF S.treatedXYLaw a))
(hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1) :
∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧ S.treatedSurv c =ᵐ[P.μ] S.survTargetLower Λ := by
classical
have _hΛ_used := hΛ
have _hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hwMin_meas : Measurable[S.sigmaX] (S.wMin Λ) := by fun_prop
have hwMax_meas : Measurable[S.sigmaX] (S.wMax Λ) := by fun_prop
have hsurvTarget_meas : Measurable[S.sigmaX] (S.survTargetLower Λ) := by fun_prop
have hlevel_meas : Measurable[S.sigmaX] (S.calibLevelLower Λ) := by fun_prop
obtain ⟨g, hg, hg_eq⟩ := S.exists_factor_through_factualX hlevel_meas
let τ : γ → ℝ := fun a => if 0 < g a ∧ g a < 1 then g a else (1 / 2 : ℝ)
have hτ_meas : Measurable τ := by
dsimp [τ]
refine Measurable.ite ?_ hg measurable_const
exact (measurableSet_lt measurable_const hg).inter (measurableSet_lt hg measurable_const)
have hτ0 : ∀ a, 0 < τ a := by
intro a
dsimp [τ]
by_cases ha : 0 < g a ∧ g a < 1
· simp [ha]
· simp [ha]
have hτ1 : ∀ a, τ a < 1 := by
intro a
dsimp [τ]
by_cases ha : 0 < g a ∧ g a < 1
· simp [ha]
· simp only [ha, ↓reduceIte]
norm_num
haveI : IsFiniteMeasure S.treatedXYLaw := by
unfold POBackdoorSystem.treatedXYLaw
infer_instance
obtain ⟨hq_meas, hq_attain⟩ :=
measurable_condQuantile_and_attains
S.treatedXYLaw τ hτ_meas hτ0 hτ1 (fun a => (hatomless a).continuousAt)
let c : P.Ω → ℝ := fun ω =>
condQuantile S.treatedXYLaw τ (S.factualX ω)
have hc_meas : Measurable[S.sigmaX] c := by
rw [POBackdoorSystem.sigmaX]
exact hq_meas.comp (comap_measurable S.factualX)
refine ⟨c, hc_meas, ?_⟩
have hτ_eq_level : ∀ᵐ ω ∂P.μ, τ (S.factualX ω) = S.calibLevelLower Λ ω := by
filter_upwards [hlevel] with ω hω
have hgx : g (S.factualX ω) = S.calibLevelLower Λ ω := by
exact (congrFun hg_eq ω).symm
dsimp [τ]
rw [hgx]
simp [hω]
have hsurv := S.treatedSurv_eq c hc_meas
filter_upwards [hsurv, hτ_eq_level, hoverlap] with ω hsurvω hτω hoverlapω
rw [hsurvω]
have hcdf :
S.treatedCondCDF ω (c ω) = τ (S.factualX ω) := by
unfold POBackdoorSystem.treatedCondCDF c
exact hq_attain (S.factualX ω)
rw [hcdf, hτω]
unfold POBackdoorSystem.calibLevelLower
have hpos : S.propScore true ω ≠ 0 := ne_of_gt hoverlapω.1
field_simp [hpos]
ring
theorem msmLowerCalib_eq_cutoff_unconditional reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp lower bound, unconditionally. Fix a sensitivity parameter Λ strictly greater than 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). If the treated outcome's conditional distribution given each covariate value has a continuous cumulative distribution function, the lower calibration quantile level lies strictly between 0 and 1 almost surely, every candidate complete propensity in the calibrated ambiguity set is almost-everywhere measurable, and the regularity conditions needed for the lower-cutoff candidate mean and calibration to be well defined hold for every σ(X)-measurable cutoff, then there exists a σ(X)-measurable, calibrated, box-feasible cutoff function at which the sharp lower bound on E[Y(1)] equals the candidate mean of the induced lower-cutoff propensity. The sInf-mirror of msmUpperCalib_eq_cutoff_unconditional.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomless :
∀ a : γ, Continuous (condCDF S.treatedXYLaw a)
hlevel :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1
hmeas :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
hreg :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
conclusion
∃ c : P.Ω → ℝ,
conclusion 1
Measurable[S.sigmaX] c
conclusion 2
S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ
conclusion 3
S.msmLowerCalib Λ = S.candMean (S.lowerCutoffProp Λ c)
Proof (Lean source)
theorem msmLowerCalib_eq_cutoff_unconditional (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hatomless : ∀ a : γ, Continuous (condCDF S.treatedXYLaw a))
(hlevel : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1)
(hmeas : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ)
(hreg : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ) :
∃ c : P.Ω → ℝ, Measurable[S.sigmaX] c ∧
S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ ∧
S.msmLowerCalib Λ = S.candMean (S.lowerCutoffProp Λ c) := by
obtain ⟨c, hc_meas, hsurv⟩ :=
S.exists_calibrating_cutoff_lower Λ hΛ hoverlap hatomless hlevel
obtain ⟨hc_int, hint, hint1, hmax_int, hdiff_int,
henv, hc_env⟩ := hreg c hc_meas
have hcut_mem : S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ :=
S.lowerCutoffProp_mem_MSMSetCalib_of_survival Λ hΛ hoverlap c hc_meas
hint hint1 hmax_int hdiff_int hsurv
have heq : S.msmLowerCalib Λ = S.candMean (S.lowerCutoffProp Λ c) :=
S.msmLowerCalib_eq_cutoff Λ (le_of_lt hΛ) hoverlap c hc_meas
hc_int hcut_mem henv hmax_int hc_env hmeas
exact ⟨c, hc_meas, hcut_mem, heq⟩
7 supporting declarations (lemmas, instances)
-
measurable_survTargetLower_sigmaXlemma — The lower target survival is measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (S.survTargetLower Λ)Proof (Lean source)
@[fun_prop] lemma measurable_survTargetLower_sigmaX (Λ : ℝ) : Measurable[S.sigmaX] (S.survTargetLower Λ) := by have hp : Measurable[S.sigmaX] (S.propScore true) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable unfold POBackdoorSystem.survTargetLower exact (((S.measurable_wMax_sigmaX Λ).mul hp).sub measurable_const).div ((S.measurable_wMax_sigmaX Λ).sub (S.measurable_wMin_sigmaX Λ)) -
measurable_calibLevelLower_sigmaXlemma — The lower calibration quantile level is measurable for the covariate σ-algebra.hypothesesconclusionMeasurable[S.sigmaX] (S.calibLevelLower Λ)Proof (Lean source)
@[fun_prop] lemma measurable_calibLevelLower_sigmaX (Λ : ℝ) : Measurable[S.sigmaX] (S.calibLevelLower Λ) := by have hp : Measurable[S.sigmaX] (S.propScore true) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable unfold POBackdoorSystem.calibLevelLower exact measurable_const.sub ((S.measurable_survTargetLower_sigmaX Λ).div hp) -
msmLowerCalib_eq_cutofftheorem — The sharp lower bound has the quantile-balancing closed form. Given a calibrating lower cutoff, msmLowerCalib Λ = candMean (lowerCutoffProp Λ c).hypothesesγ :sharedType u_1Λ :ℝhΛ :1 ≤ Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chc_int :Integrable c P.μhcut_mem :S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λhenv :Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μhweight_env :Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μhc_env :Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μhmeas :∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μconclusionS.msmLowerCalib Λ = S.candMean (S.lowerCutoffProp Λ c)Proof (Lean source)
theorem msmLowerCalib_eq_cutoff (Λ : ℝ) (hΛ : 1 ≤ Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ) (hcut_mem : S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ) (henv : Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ) (hweight_env : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ) (hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ) (hmeas : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ) : S.msmLowerCalib Λ = S.candMean (S.lowerCutoffProp Λ c) := by classical have hne : (S.candMean '' S.MSMSetCalib Λ).Nonempty := ⟨S.candMean (S.lowerCutoffProp Λ c), Set.mem_image_of_mem _ hcut_mem⟩ have hle_all : ∀ x ∈ S.candMean '' S.MSMSetCalib Λ, S.candMean (S.lowerCutoffProp Λ c) ≤ x := by rintro x ⟨etilde, hmem, rfl⟩ exact S.cutoff_optimal_lower Λ hΛ hoverlap c hc_meas hc_int hcut_mem henv hweight_env hc_env hmem (hmeas etilde hmem) have hbdd : BddBelow (S.candMean '' S.MSMSetCalib Λ) := ⟨S.candMean (S.lowerCutoffProp Λ c), hle_all⟩ refine le_antisymm ?_ ?_ · unfold POBackdoorSystem.msmLowerCalib exact csInf_le hbdd (Set.mem_image_of_mem _ hcut_mem) · unfold POBackdoorSystem.msmLowerCalib exact le_csInf hne hle_all -
lowerCutoff_calibValue_eqtheorem — Decomposition of the lower-cutoff calibration value. E[Z/lowerCutoffProp Λ c | σ(X)] = wMax·e − (wMax − wMin)·G(c) (with G(c) = treatedSurv c).hypothesesγ :sharedType u_1Λ :ℝc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmax_int :Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μProof (Lean source)
theorem lowerCutoff_calibValue_eq (Λ : ℝ) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmax_int : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) : P.μ[fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω | S.sigmaX] =ᵐ[P.μ] (fun ω => S.wMax Λ ω * S.propScore true ω - (S.wMax Λ ω - S.wMin Λ ω) * S.treatedSurv c ω) := by classical have _hc_meas_used := hc_meas have _hint_used := hint set A : P.Ω → ℝ := S.dVar.indicator true with hA_def set I : P.Ω → ℝ := fun ω => if c ω < S.factualY ω then (1 : ℝ) else 0 with hI_def have _hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by unfold POBackdoorSystem.propScore exact stronglyMeasurable_condExp.measurable have hwMin_smeas : StronglyMeasurable[S.sigmaX] (S.wMin Λ) := by fun_prop have hwMax_smeas : StronglyMeasurable[S.sigmaX] (S.wMax Λ) := by fun_prop have hdiff_smeas : StronglyMeasurable[S.sigmaX] (fun ω => S.wMax Λ ω - S.wMin Λ ω) := by fun_prop have hA_int : Integrable A P.μ := by fun_prop have hI_int : Integrable (fun ω => A ω * I ω) P.μ := by fun_prop have hmax_int' : Integrable (fun ω => S.wMax Λ ω * A ω) P.μ := by refine hmax_int.congr (Filter.Eventually.of_forall ?_) intro ω rw [hA_def] exact mul_comm _ _ have hpoint : (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) =ᵐ[P.μ] (fun ω => S.wMax Λ ω * A ω - (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω)) := by refine Filter.Eventually.of_forall ?_ intro ω rw [hA_def, hI_def] by_cases hcy : c ω < S.factualY ω · simp only [POBackdoorSystem.lowerCutoffProp, if_pos hcy] rw [div_div_eq_mul_div, div_one] ring · simp only [POBackdoorSystem.lowerCutoffProp, if_neg hcy] rw [div_div_eq_mul_div, div_one] ring refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ) hpoint).trans ?_ have hsplit : P.μ[fun ω => S.wMax Λ ω * A ω - (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX] =ᵐ[P.μ] P.μ[fun ω => S.wMax Λ ω * A ω | S.sigmaX] - P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX] := by condexp_linearity have hpullMax : P.μ[fun ω => S.wMax Λ ω * A ω | S.sigmaX] =ᵐ[P.μ] (fun ω => S.wMax Λ ω * S.propScore true ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaX) (μ := P.μ) hwMax_smeas hmax_int' hA_int exact h.trans (Filter.EventuallyEq.of_eq (by funext ω rfl)) have hpullDiff : P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX] =ᵐ[P.μ] (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * S.treatedSurv c ω) := by have h := MeasureTheory.condExp_mul_of_stronglyMeasurable_left (m := S.sigmaX) (μ := P.μ) hdiff_smeas hdiff_int hI_int exact h.trans (Filter.EventuallyEq.of_eq (by funext ω rfl)) filter_upwards [hsplit, hpullMax, hpullDiff] with ω hsplitω hmaxω hdiffω rw [hsplitω] change P.μ[fun ω => S.wMax Λ ω * A ω | S.sigmaX] ω - P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (A ω * I ω) | S.sigmaX] ω = S.wMax Λ ω * S.propScore true ω - (S.wMax Λ ω - S.wMin Λ ω) * S.treatedSurv c ω rw [hmaxω, hdiffω] -
lowerCutoffProp_calibrated_of_survivaltheorem — Lower-cutoff calibration from the survival equation.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmax_int :Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μhsurv :S.treatedSurv c =ᵐ[P.μ] S.survTargetLower ΛconclusionS.Calibrated (S.lowerCutoffProp Λ c)Proof (Lean source)
theorem lowerCutoffProp_calibrated_of_survival (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmax_int : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) (hsurv : S.treatedSurv c =ᵐ[P.μ] S.survTargetLower Λ) : S.Calibrated (S.lowerCutoffProp Λ c) := by unfold POBackdoorSystem.Calibrated have hΛ0 : 0 < Λ := lt_trans zero_lt_one hΛ refine (S.lowerCutoff_calibValue_eq Λ c hc_meas hint hint1 hmax_int hdiff_int).trans ?_ filter_upwards [hoverlap, hsurv] with ω hω hsurvω rw [hsurvω] set e : ℝ := S.propScore true ω with he_def have he0 : 0 < e := by simpa [he_def] using hω.1 have he1 : e < 1 := by simpa [he_def] using hω.2 have hdiff_pos : 0 < S.wMax Λ ω - S.wMin Λ ω := by simp only [POBackdoorSystem.wMax, POBackdoorSystem.wMin, ← he_def] have h1e : 0 < 1 - e := by linarith have hΛsq : 0 < Λ * Λ - 1 := by nlinarith field_simp [hΛ0.ne', he0.ne'] nlinarith [h1e, hΛsq, hΛ0, he0] have hdiff_ne : S.wMax Λ ω - S.wMin Λ ω ≠ 0 := hdiff_pos.ne' unfold POBackdoorSystem.survTargetLower field_simp [hdiff_ne] ring -
lowerCutoffProp_mem_MSMSettheorem — The lower cutoff propensity is always in the odds-ratio box.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 ≤ Λc :P.Ω → ℝconclusionS.lowerCutoffProp Λ c ∈ S.MSMSet ΛProof (Lean source)
theorem lowerCutoffProp_mem_MSMSet (Λ : ℝ) (hΛ : 1 ≤ Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) (c : P.Ω → ℝ) : S.lowerCutoffProp Λ c ∈ S.MSMSet Λ := by classical have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le zero_lt_one hΛ have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 → ((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ) ↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et ∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by intro e et he0 he1 het0 het1 have h1e : 0 < 1 - e := by linarith have h1et : 0 < 1 - et := by linarith have hOReq : OR et e = et * (1 - e) / ((1 - et) * e) := by rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm] ring_nf rw [hOReq] have hMax : (1 / Λ ≤ et * (1 - e) / ((1 - et) * e)) ↔ (1 / et ≤ 1 + Λ * (1 - e) / e) := by rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e), show (1 : ℝ) + Λ * (1 - e) / e = (e + Λ * (1 - e)) / e by field_simp, div_le_div_iff₀ het0 he0] constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0] have hMin : (et * (1 - e) / ((1 - et) * e) ≤ Λ) ↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et) := by rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e), show (1 : ℝ) + (1 - e) / (Λ * e) = (Λ * e + (1 - e)) / (Λ * e) by field_simp, div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e) het0] constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0] rw [hMax, hMin, and_comm] have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin Λ ω ∧ S.wMin Λ ω ≤ S.wMax Λ ω := by filter_upwards [hoverlap] with ω hω set e : ℝ := S.propScore true ω with he_def have he0 : 0 < e := by simpa [he_def] using hω.1 have he1 : e < 1 := by simpa [he_def] using hω.2 have h1e : 0 < 1 - e := by linarith refine ⟨?_, ?_⟩ · have : 0 < (1 - e) / (Λ * e) := by positivity simp only [POBackdoorSystem.wMin, ← he_def] linarith · simp only [POBackdoorSystem.wMin, POBackdoorSystem.wMax, ← he_def] have hd1 : (1 - e) / (Λ * e) ≤ Λ * (1 - e) / e := by rw [div_le_div_iff₀ (by positivity) he0] nlinarith [hΛ, mul_pos h1e he0, mul_pos hΛ0 he0, mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0)) (sub_nonneg.mpr hΛ)] linarith have hboxC : ∀ᵐ ω ∂P.μ, S.wMin Λ ω ≤ (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω) ∧ (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω) ≤ S.wMax Λ ω ∧ 1 < (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω) := by filter_upwards [hae] with ω hω obtain ⟨hmin1, hminmax⟩ := hω by_cases hcy : c ω < S.factualY ω · simp only [if_pos hcy] exact ⟨le_rfl, hminmax, hmin1⟩ · simp only [if_neg hcy] exact ⟨hminmax, le_rfl, lt_of_lt_of_le hmin1 hminmax⟩ refine ⟨?_, ?_⟩ · filter_upwards [hboxC] with ω hω obtain ⟨_, _, hwgt⟩ := hω unfold POBackdoorSystem.lowerCutoffProp constructor · positivity · rw [div_lt_one (by linarith)] linarith · filter_upwards [hoverlap, hboxC] with ω hov hw obtain ⟨he0, he1⟩ := hov obtain ⟨hmin, hmax, hwgt⟩ := hw set wC : ℝ := if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω with hwC_def have hcut : S.lowerCutoffProp Λ c ω = 1 / wC := by rw [POBackdoorSystem.lowerCutoffProp, hwC_def] have het0 : 0 < S.lowerCutoffProp Λ c ω := by rw [hcut] positivity have het1 : S.lowerCutoffProp Λ c ω < 1 := by rw [hcut, div_lt_one (by linarith)] linarith rw [(hOR_box he0 he1 het0 het1)] have hinv : 1 / S.lowerCutoffProp Λ c ω = wC := by rw [hcut, one_div_one_div] rw [hinv] simpa [POBackdoorSystem.wMin, POBackdoorSystem.wMax, hwC_def] using ⟨hmin, hmax⟩ -
lowerCutoffProp_mem_MSMSetCalib_of_survivaltheorem — The lower cutoff is calibrated-feasible given the survival equation.hypothesesγ :sharedType u_1Λ :ℝhΛ :1 < Λc :P.Ω → ℝhc_meas :Measurable[S.sigmaX] chint :Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μhint1 :Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μhmax_int :Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μhdiff_int :Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μhsurv :S.treatedSurv c =ᵐ[P.μ] S.survTargetLower ΛconclusionS.lowerCutoffProp Λ c ∈ S.MSMSetCalib ΛProof (Lean source)
theorem lowerCutoffProp_mem_MSMSetCalib_of_survival (Λ : ℝ) (hΛ : 1 < Λ) (hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) (c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hint : Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ) (hint1 : Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ) (hmax_int : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ) (hdiff_int : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) (hsurv : S.treatedSurv c =ᵐ[P.μ] S.survTargetLower Λ) : S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ := by exact ⟨S.lowerCutoffProp_mem_MSMSet Λ (le_of_lt hΛ) hoverlap c, S.lowerCutoffProp_calibrated_of_survival Λ hΛ hoverlap c hc_meas hint hint1 hmax_int hdiff_int hsurv⟩
ATEClosedForm 2 core · 0 supporting This file combines the four arm-level quantile-cutoff closed forms into closed-form endpoints for the calibrated ATE interval. ★ ate_endpoints_eq_cutoff★ ate_mem_Icc_cutoff
Closed-form marginal-sensitivity-model ATE endpoints
This file combines the four arm-level quantile-cutoff closed forms into closed-form endpoints for the calibrated ATE interval. The true ATE is then placed in the interval whose endpoints are the appropriate differences of the treated and control cutoff candidate means.
The theorem ate_endpoints_eq_cutoff gives the endpoint representation using
treated upper/lower cutoffs and control upper/lower cutoffs. The theorem
ate_mem_Icc_cutoff combines those endpoint equalities with armwise interval
validity to put ate in the resulting closed-form interval.
theorem ate_endpoints_eq_cutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp ATE interval endpoints in closed form. Fix a sensitivity parameter Λ greater than 1. Given, for the treated arm, two-sided propensity overlap, an atomless conditional outcome distribution, that the upper and lower calibration levels each lie strictly between 0 and 1 almost everywhere, that the calibrated candidate mean is bounded above over its ambiguity set, that every candidate propensity in that ambiguity set is measurable up to null sets, and integrability regularity, for every σ(X)-measurable cutoff candidate, feeding both the upper and lower calibration constructions — together with the symmetric conditions for the control arm (overlap, atomlessness, calibration-level regularity, boundedness, measurability, and cutoff integrability regularity) — then there exist σ(X)-measurable conditional-quantile cutoffs cTU, cTL, cCU, cCL such that the sharp calibrated ATE upper endpoint equals the treated upper-cutoff candidate mean minus the control lower-cutoff candidate mean, and the sharp calibrated ATE lower endpoint equals the treated lower-cutoff candidate mean minus the control upper-cutoff candidate mean.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
treated arm regularity
hatomlessT :
∀ a : γ, Continuous (condCDF S.treatedXYLaw a)
hlevelTU :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1
hlevelTL :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1
hbddT :
BddAbove (S.candMean '' S.MSMSetCalib Λ)
hmeasT :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
hregTU :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hregTL :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
control arm regularity
hatomlessC :
∀ a : γ, Continuous (condCDF S.controlXYLaw a)
hlevelCU :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1
hlevelCL :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1
hbddC :
BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ)
hmeasC :
∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ
hregCU :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hregCL :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
conclusion
∃ cTU cTL cCU cCL : P.Ω → ℝ,
conclusion 1
conclusion 2
S.ateUpperCalib Λ
= S.candMean (S.cutoffProp Λ cTU) - S.candMean0 (S.lowerCutoffProp0 Λ cCL)
conclusion 3
S.ateLowerCalib Λ
= S.candMean (S.lowerCutoffProp Λ cTL) - S.candMean0 (S.cutoffProp0 Λ cCU)
Proof (Lean source)
theorem ate_endpoints_eq_cutoff (Λ : ℝ) (hΛ : 1 < Λ)
-- treated arm regularity
(hoverlapT : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hatomlessT : ∀ a : γ, Continuous (condCDF S.treatedXYLaw a))
(hlevelTU : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1)
(hlevelTL : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1)
(hbddT : BddAbove (S.candMean '' S.MSMSetCalib Λ))
(hmeasT : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ)
(hregTU : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hregTL : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
-- control arm regularity
(hoverlapC : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(hatomlessC : ∀ a : γ, Continuous (condCDF S.controlXYLaw a))
(hlevelCU : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1)
(hlevelCL : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1)
(hbddC : BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ))
(hmeasC : ∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ)
(hregCU : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hregCL : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ) :
∃ cTU cTL cCU cCL : P.Ω → ℝ,
(Measurable[S.sigmaX] cTU ∧ Measurable[S.sigmaX] cTL ∧
Measurable[S.sigmaX] cCU ∧ Measurable[S.sigmaX] cCL) ∧
S.ateUpperCalib Λ =
S.candMean (S.cutoffProp Λ cTU) - S.candMean0 (S.lowerCutoffProp0 Λ cCL) ∧
S.ateLowerCalib Λ =
S.candMean (S.lowerCutoffProp Λ cTL) - S.candMean0 (S.cutoffProp0 Λ cCU) := by
obtain ⟨cTU, hcTU, _, hTU⟩ :=
S.msmUpperCalib_eq_cutoff_unconditional Λ hΛ hoverlapT hatomlessT hlevelTU hbddT hmeasT hregTU
obtain ⟨cTL, hcTL, _, hTL⟩ :=
S.msmLowerCalib_eq_cutoff_unconditional Λ hΛ hoverlapT hatomlessT hlevelTL hmeasT hregTL
obtain ⟨cCU, hcCU, _, hCU⟩ :=
S.msmUpperCalib0_eq_cutoff_unconditional Λ hΛ hoverlapC hatomlessC hlevelCU hbddC hmeasC hregCU
obtain ⟨cCL, hcCL, _, hCL⟩ :=
S.msmLowerCalib0_eq_cutoff_unconditional Λ hΛ hoverlapC hatomlessC hlevelCL hmeasC hregCL
refine ⟨cTU, cTL, cCU, cCL, ⟨hcTU, hcTL, hcCU, hcCL⟩, ?_, ?_⟩
· unfold POBackdoorSystem.ateUpperCalib
rw [hTU, hCL]
· unfold POBackdoorSystem.ateLowerCalib
rw [hTL, hCU]
theorem ate_mem_Icc_cutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The true ATE lies in the sharp closed-form interval. Under the same treated-arm and control-arm regularity conditions as ate_endpoints_eq_cutoff — a sensitivity parameter Λ greater than 1; for the treated arm, propensity overlap, an atomless conditional outcome distribution, calibration-level regularity, boundedness of the calibrated candidate mean, measurability of every candidate propensity, and cutoff integrability regularity; and symmetrically for the control arm (overlap, atomlessness, calibration-level regularity, boundedness, measurability, and cutoff integrability regularity) — together with validity of the treated arm's calibrated sharp interval for E[Y(1)] and validity of the control arm's calibrated sharp interval for E[Y(0)], there exist σ(X)-measurable conditional-quantile cutoffs cTU, cTL, cCU, cCL such that the true average treatment effect τ = E[Y(1)] − E[Y(0)] lies between the closed-form lower endpoint (treated lower-cutoff candidate mean minus control upper-cutoff candidate mean) and the closed-form upper endpoint (treated upper-cutoff candidate mean minus control lower-cutoff candidate mean).
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
hatomlessT :
∀ a : γ, Continuous (condCDF S.treatedXYLaw a)
hlevelTU :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1
hlevelTL :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1
hbddT :
BddAbove (S.candMean '' S.MSMSetCalib Λ)
hmeasT :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
hregTU :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hregTL :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hatomlessC :
∀ a : γ, Continuous (condCDF S.controlXYLaw a)
hlevelCU :
∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1
hlevelCL :
∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1
hbddC :
BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ)
hmeasC :
∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ
hregCU :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hregCL :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) * (S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hT :
S.Y1mean ∈ Icc (S.msmLowerCalib Λ) (S.msmUpperCalib Λ)
hC :
S.Y0mean ∈ Icc (S.msmLowerCalib0 Λ) (S.msmUpperCalib0 Λ)
conclusion
∃ cTU cTL cCU cCL : P.Ω → ℝ,
conclusion 1
conclusion 2
S.ate ∈ Icc (S.candMean (S.lowerCutoffProp Λ cTL) - S.candMean0 (S.cutoffProp0 Λ cCU)) (S.candMean (S.cutoffProp Λ cTU) - S.candMean0 (S.lowerCutoffProp0 Λ cCL))
Proof (Lean source)
theorem ate_mem_Icc_cutoff (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlapT : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
(hatomlessT : ∀ a : γ, Continuous (condCDF S.treatedXYLaw a))
(hlevelTU : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel Λ ω ∧ S.calibLevel Λ ω < 1)
(hlevelTL : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower Λ ω ∧ S.calibLevelLower Λ ω < 1)
(hbddT : BddAbove (S.candMean '' S.MSMSetCalib Λ))
(hmeasT : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ)
(hregTU : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hregTL : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.lowerCutoffProp Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hoverlapC : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(hatomlessC : ∀ a : γ, Continuous (condCDF S.controlXYLaw a))
(hlevelCU : ∀ᵐ ω ∂P.μ, 0 < S.calibLevel0 Λ ω ∧ S.calibLevel0 Λ ω < 1)
(hlevelCL : ∀ᵐ ω ∂P.μ, 0 < S.calibLevelLower0 Λ ω ∧ S.calibLevelLower0 Λ ω < 1)
(hbddC : BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ))
(hmeasC : ∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ)
(hregCU : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.cutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMin0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hregCL : ∀ c : P.Ω → ℝ, Measurable[S.sigmaX] c →
Integrable c P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω / S.lowerCutoffProp0 Λ c ω) P.μ ∧
Integrable (fun ω =>
S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax0 Λ ω - S.wMin0 Λ ω) *
(S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ ∧
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hT : S.Y1mean ∈ Icc (S.msmLowerCalib Λ) (S.msmUpperCalib Λ))
(hC : S.Y0mean ∈ Icc (S.msmLowerCalib0 Λ) (S.msmUpperCalib0 Λ)) :
∃ cTU cTL cCU cCL : P.Ω → ℝ,
(Measurable[S.sigmaX] cTU ∧ Measurable[S.sigmaX] cTL ∧
Measurable[S.sigmaX] cCU ∧ Measurable[S.sigmaX] cCL) ∧
S.ate ∈ Icc
(S.candMean (S.lowerCutoffProp Λ cTL) - S.candMean0 (S.cutoffProp0 Λ cCU))
(S.candMean (S.cutoffProp Λ cTU) - S.candMean0 (S.lowerCutoffProp0 Λ cCL)) := by
obtain ⟨cTU, cTL, cCU, cCL, hmeas, hUp, hLo⟩ :=
S.ate_endpoints_eq_cutoff Λ hΛ hoverlapT hatomlessT hlevelTU hlevelTL hbddT hmeasT hregTU hregTL
hoverlapC hatomlessC hlevelCU hlevelCL hbddC hmeasC hregCU hregCL
have hval := S.ate_mem_Icc_calib Λ hT hC
rw [hUp, hLo] at hval
exact ⟨cTU, cTL, cCU, cCL, hmeas, hval⟩
ControlQuantileBalance 2 core · 0 supporting This file mirrors the treated-arm quantile-balancing closed form for the control arm: calibrated feasible control propensities are dominated by the control cutoff propensity, so the calibrated control upper bound is atta ★ cutoff_optimal0★ msmUpperCalib0_eq_cutoff
Marginal Sensitivity Model — control-arm quantile balancing
This file mirrors the treated-arm quantile-balancing closed form for the control arm: calibrated feasible control propensities are dominated by the control cutoff propensity, so the calibrated control upper bound is attained at that cutoff.
The theorem cutoff_optimal0 proves optimality of a calibrated control cutoff
against every member of MSMSetCalib0. The theorem msmUpperCalib0_eq_cutoff
then identifies the sharp calibrated control upper bound with the cutoff
candidate mean.
theorem cutoff_optimal0 reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Optimality of the control quantile-cutoff weight. Fix a sensitivity parameter Λ at least one. Assume the control propensity score is almost surely strictly between 0 and 1 (two-sided overlap), and let c be a σ(X)-measurable, integrable cutoff function such that the quantile-cutoff propensity it induces lies in the calibrated control ambiguity set. If the envelope, weighted-indicator, and cutoff-weighted envelope integrability conditions bounding the IPW integrands hold, then for any almost-everywhere measurable candidate complete control propensity ẽ in the calibrated ambiguity set, the candidate mean at ẽ is no greater than the candidate mean at the quantile-cutoff weight: the control cutoff attains the maximum over all calibrated candidates.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
henv :
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
etilde :
P.Ω → ℝ
hmem :
etilde ∈ S.MSMSetCalib0 Λ
hmeas :
AEMeasurable etilde P.μ
conclusion
S.candMean0 etilde ≤ S.candMean0 (S.cutoffProp0 Λ c)
Proof (Lean source)
theorem cutoff_optimal0 (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ)
(henv : Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
{etilde : P.Ω → ℝ} (hmem : etilde ∈ S.MSMSetCalib0 Λ)
(hmeas : AEMeasurable etilde P.μ) :
S.candMean0 etilde ≤ S.candMean0 (S.cutoffProp0 Λ c) := by
classical
have _ : Integrable c P.μ := hc_int
have hΛ0 : (0 : ℝ) < Λ := lt_of_lt_of_le one_pos hΛ
set A : P.Ω → ℝ := S.dVar.indicator false with hA_def
set Y : P.Ω → ℝ := S.factualY with hY_def
set e : P.Ω → ℝ := S.propScore false with he_def
set wE : P.Ω → ℝ := fun ω => 1 / etilde ω with hwE_def
set wC : P.Ω → ℝ :=
fun ω => if c ω < Y ω then S.wMax0 Λ ω else S.wMin0 Λ ω with hwC_def
have hOR_box : ∀ {e et : ℝ}, 0 < e → e < 1 → 0 < et → et < 1 →
((1 / Λ ≤ OR et e ∧ OR et e ≤ Λ)
↔ (1 + (1 - e) / (Λ * e) ≤ 1 / et
∧ 1 / et ≤ 1 + Λ * (1 - e) / e)) := by
intro e0 et he0 he1 het0 het1
have h1e : 0 < 1 - e0 := by linarith
have h1et : 0 < 1 - et := by linarith
have hOReq : OR et e0 = et * (1 - e0) / ((1 - et) * e0) := by
rw [OR, div_div_eq_mul_div, div_mul_eq_mul_div, mul_comm, mul_div_mul_comm]
ring_nf
rw [hOReq]
have hMax : (1 / Λ ≤ et * (1 - e0) / ((1 - et) * e0))
↔ (1 / et ≤ 1 + Λ * (1 - e0) / e0) := by
rw [div_le_div_iff₀ hΛ0 (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + Λ * (1 - e0) / e0 = (e0 + Λ * (1 - e0)) / e0 by
field_simp,
div_le_div_iff₀ het0 he0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
have hMin : (et * (1 - e0) / ((1 - et) * e0) ≤ Λ)
↔ (1 + (1 - e0) / (Λ * e0) ≤ 1 / et) := by
rw [div_le_iff₀ (by positivity : (0 : ℝ) < (1 - et) * e0),
show (1 : ℝ) + (1 - e0) / (Λ * e0) = (Λ * e0 + (1 - e0)) / (Λ * e0) by
field_simp,
div_le_div_iff₀ (by positivity : (0 : ℝ) < Λ * e0) het0]
constructor <;> intro h <;> nlinarith [h, mul_pos hΛ0 he0]
rw [hMax, hMin, and_comm]
have hAm : Measurable A := by
rw [hA_def]
exact S.dVar.measurable_indicator false (MeasurableSet.singleton _)
have hYm : Measurable Y := by
rw [hY_def]
exact S.measurable_factualY
have hem : Measurable e := by
rw [he_def]
unfold POBackdoorSystem.propScore
exact (stronglyMeasurable_condExp.mono S.sigmaX_le).measurable
have hwMax0m : Measurable (S.wMax0 Λ) := by
unfold POBackdoorSystem.wMax0
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hem)).div hem))
have hwMin0m : Measurable (S.wMin0 Λ) := by
unfold POBackdoorSystem.wMin0
exact (measurable_const.add
((measurable_const.sub hem).div (measurable_const.mul hem)))
have hwCm : Measurable wC := by
rw [hwC_def]
exact Measurable.ite (measurableSet_lt (hc_meas.mono S.sigmaX_le le_rfl) hYm)
hwMax0m hwMin0m
have hA0 : ∀ ω, 0 ≤ A ω := fun ω => by
rcases S.dVar.indicator_eq_one_or_zero false ω with h | h <;> simp [hA_def, h]
have hae : ∀ᵐ ω ∂P.μ, (1 : ℝ) < S.wMin0 Λ ω ∧ S.wMin0 Λ ω ≤ S.wMax0 Λ ω := by
filter_upwards [hoverlap] with ω hω
obtain ⟨he0ω, he1ω⟩ := hω
have h1e : 0 < 1 - e ω := by rw [he_def] at *; linarith
have he0' : 0 < e ω := by rw [he_def] at *; exact he0ω
refine ⟨?_, ?_⟩
· have : 0 < (1 - e ω) / (Λ * e ω) := by positivity
simp only [POBackdoorSystem.wMin0, ← he_def]
linarith
· simp only [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, ← he_def]
have hd1 : (1 - e ω) / (Λ * e ω) ≤ Λ * (1 - e ω) / e ω := by
rw [div_le_div_iff₀ (by positivity) he0']
nlinarith [hΛ, mul_pos h1e he0', mul_pos hΛ0 he0',
mul_nonneg (mul_nonneg (le_of_lt h1e) (le_of_lt he0')) (sub_nonneg.mpr hΛ)]
linarith
have hboxE : ∀ᵐ ω ∂P.μ,
S.wMin0 Λ ω ≤ wE ω ∧ wE ω ≤ S.wMax0 Λ ω := by
obtain ⟨hinterior, hor⟩ := hmem.1
filter_upwards [hoverlap, hinterior, hor] with ω hov het hOR
obtain ⟨he0ω, he1ω⟩ := hov
obtain ⟨het0, het1⟩ := het
have hbox := (hOR_box he0ω he1ω het0 het1).mp hOR
simpa [POBackdoorSystem.wMin0, POBackdoorSystem.wMax0, he_def, hwE_def] using hbox
have hboxC : ∀ᵐ ω ∂P.μ,
S.wMin0 Λ ω ≤ wC ω ∧ wC ω ≤ S.wMax0 Λ ω ∧ 0 < wC ω := by
filter_upwards [hae] with ω hω
obtain ⟨hmin1, hminmax⟩ := hω
rw [hwC_def]
by_cases hcy : c ω < Y ω
· simp only [if_pos hcy]
exact ⟨hminmax, le_rfl, lt_of_lt_of_le (by linarith) hminmax⟩
· simp only [if_neg hcy]
exact ⟨le_rfl, hminmax, by linarith⟩
have hYE_int : Integrable (fun ω => A ω * Y ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by
rw [hwE_def]
exact aemeasurable_const.div hmeas
refine Integrable.mono' henv
(((hAm.mul hYm).aemeasurable.mul hwE_aem).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hYC_int : Integrable (fun ω => A ω * Y ω * wC ω) P.μ := by
refine Integrable.mono' henv
(((hAm.mul hYm).mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
apply mul_le_mul_of_nonneg_left _ (hA0 ω)
exact mul_le_mul_of_nonneg_left hmax (abs_nonneg _)
have hXE_int : Integrable (fun ω => A ω / etilde ω) P.μ := by
refine Integrable.mono' hweight_env
((hAm.aemeasurable.div hmeas).aestronglyMeasurable) ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_div, abs_of_nonneg (hA0 ω), abs_of_pos het0,
div_eq_mul_inv, ← one_div, hA_def]
simpa [hA_def, hwE_def] using mul_le_mul_of_nonneg_left hmax (hA0 ω)
have hXC_int : Integrable (fun ω => A ω / S.cutoffProp0 Λ c ω) P.μ := by
have hAwC_int : Integrable (fun ω => A ω * wC ω) P.μ := by
refine Integrable.mono' hweight_env ((hAm.mul hwCm).aestronglyMeasurable) ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_of_nonneg (hA0 ω), abs_of_nonneg (le_of_lt hpos)]
exact mul_le_mul_of_nonneg_left hmax (hA0 ω)
refine hAwC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change A ω * wC ω =
A ω / (1 / (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
have hcE_int : Integrable (fun ω => c ω * A ω * wE ω) P.μ := by
have hwE_aem : AEMeasurable wE P.μ := by
rw [hwE_def]
exact aemeasurable_const.div hmeas
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).aemeasurable.mul hwE_aem).aestronglyMeasurable ?_
filter_upwards [hboxE, hmem.1.1] with ω hbox hint
obtain ⟨_, hmax⟩ := hbox
obtain ⟨het0, _⟩ := hint
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω), hwE_def,
abs_of_nonneg (by positivity : 0 ≤ 1 / etilde ω), mul_assoc, mul_assoc]
simpa [mul_assoc, hwE_def, one_div] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hcC_int : Integrable (fun ω => c ω * A ω * wC ω) P.μ := by
refine Integrable.mono' hc_env
(((hc_meas.mono S.sigmaX_le le_rfl).mul hAm).mul hwCm).aestronglyMeasurable ?_
filter_upwards [hboxC] with ω hbox
obtain ⟨_, hmax, hpos⟩ := hbox
rw [Real.norm_eq_abs, abs_mul, abs_mul, abs_of_nonneg (hA0 ω),
abs_of_nonneg (le_of_lt hpos), mul_assoc, mul_assoc]
simpa [mul_assoc] using
mul_le_mul_of_nonneg_left hmax (mul_nonneg (abs_nonneg (c ω)) (hA0 ω))
have hfirstE_int : Integrable (fun ω => A ω * (Y ω - c ω) * wE ω) P.μ := by
refine (hYE_int.sub hcE_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wE ω - c ω * A ω * wE ω = A ω * (Y ω - c ω) * wE ω
ring
have hfirstC_int : Integrable (fun ω => A ω * (Y ω - c ω) * wC ω) P.μ := by
refine (hYC_int.sub hcC_int).congr (Filter.Eventually.of_forall ?_)
intro ω
change A ω * Y ω * wC ω - c ω * A ω * wC ω = A ω * (Y ω - c ω) * wC ω
ring
have hctermE_eq : ∫ ω, c ω * A ω * wE ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / etilde ω)) P.μ := by
refine hcE_int.congr (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω => c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXE_int
have hcal : P.μ[fun ω => A ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated0, hA_def] using hmem.2
have hmain : ∫ ω, c ω * (A ω / etilde ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / etilde ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
calc
∫ ω, P.μ[fun ω => c ω * (A ω / etilde ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * P.μ[fun ω => A ω / etilde ω | S.sigmaX] ω ∂P.μ :=
integral_congr_ae hpull
_ = ∫ ω, c ω * 1 ∂P.μ := by
refine integral_congr_ae ?_
filter_upwards [hcal] with ω hω
rw [hω]
_ = ∫ ω, c ω ∂P.μ := by simp
rw [← hmain]
refine integral_congr_ae (Filter.Eventually.of_forall ?_)
intro ω
change c ω * A ω * (1 / etilde ω) = c ω * (A ω / etilde ω)
rw [div_eq_mul_inv]
ring
have hctermC_eq : ∫ ω, c ω * A ω * wC ω ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hprod_int : Integrable (fun ω => c ω * (A ω / S.cutoffProp0 Λ c ω)) P.μ := by
refine hcC_int.congr ?_
filter_upwards [hboxC] with ω hbox
change c ω * A ω * wC ω =
c ω * (A ω / (1 / (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω)))
rw [hwC_def, hY_def, div_div_eq_mul_div, div_one]
ring
have hpull :
P.μ[fun ω => c ω * (A ω / S.cutoffProp0 Λ c ω) | S.sigmaX]
=ᵐ[P.μ] (fun ω =>
c ω * P.μ[fun ω => A ω / S.cutoffProp0 Λ c ω | S.sigmaX] ω) := by
exact MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hc_meas.stronglyMeasurable hprod_int hXC_int
have hcal :
P.μ[fun ω => A ω / S.cutoffProp0 Λ c ω | S.sigmaX]
=ᵐ[P.μ] (fun _ => (1 : ℝ)) := by
simpa [POBackdoorSystem.Calibrated0, hA_def] using hcut_mem.2
have hmain :
∫ ω, c ω * (A ω / S.cutoffProp0 Λ c ω) ∂P.μ = ∫ ω, c ω ∂P.μ := by
have hcond :
∫ ω, P.μ[fun ω => c ω * (A ω / S.cutoffProp0 Λ c ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω * (A ω / S.cutoffProp0 Λ c ω) ∂P.μ :=
MeasureTheory.integral_condExp S.sigmaX_le
rw [← hcond]
calc
∫ ω, P.μ[fun ω => c ω * (A ω / S.cutoffProp0 Λ c ω) | S.sigmaX] ω ∂P.μ
= ∫ ω, c ω *
-- … truncated; follow the source link for the rest …
theorem msmUpperCalib0_eq_cutoff reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The sharp calibrated control upper bound has the quantile-balancing closed form. Fix a sensitivity parameter Λ at least one. Under two-sided overlap of the control propensity score, given a σ(X)-measurable, integrable cutoff c whose induced quantile-cutoff propensity is itself calibrated-feasible, and assuming the envelope, weighted-indicator, and cutoff-weighted envelope integrability conditions bounding the IPW integrands together with almost-everywhere measurability of every calibrated candidate propensity, the sharp (supremum) upper bound for E[Y(0)] over the calibrated ambiguity set equals the candidate mean evaluated at the quantile-cutoff propensity.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
c :
P.Ω → ℝ
hc_meas :
Measurable[S.sigmaX] c
hc_int :
Integrable c P.μ
hcut_mem :
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ
henv :
Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ
hweight_env :
Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hc_env :
Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ
hmeas :
∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ
conclusion
S.msmUpperCalib0 Λ = S.candMean0 (S.cutoffProp0 Λ c)
Proof (Lean source)
theorem msmUpperCalib0_eq_cutoff (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1)
(c : P.Ω → ℝ) (hc_meas : Measurable[S.sigmaX] c) (hc_int : Integrable c P.μ)
(hcut_mem : S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ)
(henv : Integrable (fun ω => S.dVar.indicator false ω * |S.factualY ω| * S.wMax0 Λ ω) P.μ)
(hweight_env : Integrable (fun ω => S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hc_env : Integrable (fun ω => |c ω| * S.dVar.indicator false ω * S.wMax0 Λ ω) P.μ)
(hmeas : ∀ etilde ∈ S.MSMSetCalib0 Λ, AEMeasurable etilde P.μ) :
S.msmUpperCalib0 Λ = S.candMean0 (S.cutoffProp0 Λ c) := by
classical
have hne : (S.candMean0 '' S.MSMSetCalib0 Λ).Nonempty :=
⟨S.candMean0 (S.cutoffProp0 Λ c), Set.mem_image_of_mem _ hcut_mem⟩
have hle_all :
∀ x ∈ S.candMean0 '' S.MSMSetCalib0 Λ,
x ≤ S.candMean0 (S.cutoffProp0 Λ c) := by
rintro x ⟨etilde, hmem, rfl⟩
exact S.cutoff_optimal0 Λ hΛ hoverlap c hc_meas hc_int hcut_mem henv hweight_env hc_env
hmem (hmeas etilde hmem)
have hbdd : BddAbove (S.candMean0 '' S.MSMSetCalib0 Λ) :=
⟨S.candMean0 (S.cutoffProp0 Λ c), hle_all⟩
refine le_antisymm ?_ ?_
· unfold POBackdoorSystem.msmUpperCalib0
exact csSup_le hne hle_all
· unfold POBackdoorSystem.msmUpperCalib0
exact le_csSup hbdd (Set.mem_image_of_mem _ hcut_mem)
CutoffExists 4 core · 0 supporting This file isolates the existence and regularity assumptions for treated-arm calibrating cutoffs. ★ wMin_mul_propScore_le_one★ one_le_wMax_mul_propScore★ condExp_treat_wMin_eq★ condExp_treat_wMax_eq
Existence interface for calibrated MSM cutoffs
This file isolates the existence and regularity assumptions for treated-arm calibrating cutoffs. It packages the facts needed to turn a conditional-quantile cutoff into a calibrated candidate weight for the sharp MSM upper bound.
The public results are the endpoint bracket inequalities
wMin_mul_propScore_le_one and one_le_wMax_mul_propScore, together with the
conditional-expectation pullout identities condExp_treat_wMin_eq and
condExp_treat_wMax_eq.
theorem wMin_mul_propScore_le_one reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Lower calibration bracket (algebraic). Fix a sensitivity parameter Λ at least 1. Assuming the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap), almost surely the lower marginal-sensitivity-model weight satisfies wMin(X)·e(X) = e(X) + (1 − e(X))/Λ ≤ 1, where e(X) denotes the propensity score.
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
conclusion
∀ᵐ ω ∂P.μ, S.wMin Λ ω * S.propScore true ω ≤ 1
Proof (Lean source)
theorem wMin_mul_propScore_le_one (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) :
∀ᵐ ω ∂P.μ, S.wMin Λ ω * S.propScore true ω ≤ 1 := by
have hΛ0 : 0 < Λ := lt_of_lt_of_le zero_lt_one hΛ
filter_upwards [hoverlap] with ω hω
set e : ℝ := S.propScore true ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have hw :
S.wMin Λ ω * S.propScore true ω = e + (1 - e) / Λ := by
simp only [POBackdoorSystem.wMin, ← he_def]
field_simp [hΛ0.ne', he0.ne']
have hdiv : (1 - e) / Λ ≤ 1 - e := by
rw [div_le_iff₀ hΛ0]
nlinarith [hΛ, le_of_lt he1]
calc
S.wMin Λ ω * S.propScore true ω = e + (1 - e) / Λ := hw
_ ≤ e + (1 - e) := by linarith
_ = 1 := by ring
theorem one_le_wMax_mul_propScore reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
Upper calibration bracket (algebraic). Fix a sensitivity parameter Λ at least 1. Assuming the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap), almost surely the upper marginal-sensitivity-model weight satisfies 1 ≤ wMax(X)·e(X) = e(X) + Λ·(1 − e(X)).
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 ≤ Λ
conclusion
∀ᵐ ω ∂P.μ, 1 ≤ S.wMax Λ ω * S.propScore true ω
Proof (Lean source)
theorem one_le_wMax_mul_propScore (Λ : ℝ) (hΛ : 1 ≤ Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1) :
∀ᵐ ω ∂P.μ, 1 ≤ S.wMax Λ ω * S.propScore true ω := by
filter_upwards [hoverlap] with ω hω
set e : ℝ := S.propScore true ω with he_def
have he0 : 0 < e := by simpa [he_def] using hω.1
have he1 : e < 1 := by simpa [he_def] using hω.2
have hw :
S.wMax Λ ω * S.propScore true ω = e + Λ * (1 - e) := by
simp only [POBackdoorSystem.wMax, ← he_def]
field_simp [he0.ne']
have hmul : 1 - e ≤ Λ * (1 - e) := by
nlinarith [hΛ, le_of_lt he1]
calc
1 = e + (1 - e) := by ring
_ ≤ e + Λ * (1 - e) := by linarith
_ = S.wMax Λ ω * S.propScore true ω := hw.symm
theorem condExp_treat_wMin_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The all-wMin conditional calibration value is wMin·e. Assuming the product of the treatment indicator and the lower marginal-sensitivity-model weight wMin is integrable, the conditional expectation, given the σ-algebra generated by the covariates, of the treatment indicator times wMin equals wMin times the propensity score, almost everywhere.
Formal statement
hypotheses
Proof (Lean source)
theorem condExp_treat_wMin_eq (Λ : ℝ)
(hint : Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ) :
P.μ[fun ω => S.dVar.indicator true ω * S.wMin Λ ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin Λ ω * S.propScore true ω) := by
have hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hw_smeas : StronglyMeasurable[S.sigmaX] (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact (measurable_const.add
((measurable_const.sub hprop_meas).div (measurable_const.mul hprop_meas))).stronglyMeasurable
have hind_int : Integrable (S.dVar.indicator true) P.μ :=
S.dVar.integrable_indicator true (measurableSet_singleton true)
have hcomm :
(fun ω => S.dVar.indicator true ω * S.wMin Λ ω)
= (fun ω => S.wMin Λ ω * S.dVar.indicator true ω) := by
funext ω
exact mul_comm _ _
refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ)
(Filter.EventuallyEq.of_eq hcomm)).trans ?_
have hpull :
P.μ[fun ω => S.wMin Λ ω * S.dVar.indicator true ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMin Λ ω * P.μ[S.dVar.indicator true | S.sigmaX] ω) :=
MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hw_smeas (hint.congr (Filter.EventuallyEq.of_eq hcomm))
hind_int
exact hpull.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
theorem condExp_treat_wMax_eq reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The all-wMax conditional calibration value is wMax·e. Assuming the product of the treatment indicator and the upper marginal-sensitivity-model weight wMax is integrable, the conditional expectation, given the σ-algebra generated by the covariates, of the treatment indicator times wMax equals wMax times the propensity score, almost everywhere.
Formal statement
hypotheses
Proof (Lean source)
theorem condExp_treat_wMax_eq (Λ : ℝ)
(hint : Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ) :
P.μ[fun ω => S.dVar.indicator true ω * S.wMax Λ ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMax Λ ω * S.propScore true ω) := by
have hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hw_smeas : StronglyMeasurable[S.sigmaX] (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hprop_meas)).div hprop_meas)).stronglyMeasurable
have hind_int : Integrable (S.dVar.indicator true) P.μ :=
S.dVar.integrable_indicator true (measurableSet_singleton true)
have hcomm :
(fun ω => S.dVar.indicator true ω * S.wMax Λ ω)
= (fun ω => S.wMax Λ ω * S.dVar.indicator true ω) := by
funext ω
exact mul_comm _ _
refine (MeasureTheory.condExp_congr_ae (m := S.sigmaX) (μ := P.μ)
(Filter.EventuallyEq.of_eq hcomm)).trans ?_
have hpull :
P.μ[fun ω => S.wMax Λ ω * S.dVar.indicator true ω | S.sigmaX]
=ᵐ[P.μ] (fun ω => S.wMax Λ ω * P.μ[S.dVar.indicator true | S.sigmaX] ω) :=
MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hw_smeas (hint.congr (Filter.EventuallyEq.of_eq hcomm))
hind_int
exact hpull.trans (Filter.EventuallyEq.of_eq (by
funext ω
rfl))
GaussianHalfWidth 3 core · 0 supporting This file evaluates the calibrated Gaussian MSM upper endpoint in closed form. ★ msmUpperCalib_gaussian_halfWidth
Gaussian MSM half-width formula
This file evaluates the calibrated Gaussian MSM upper endpoint in closed form.
It defines the scalar gaussianMSMHalfWidthFactor, strengthens the CDF-only
Gaussian cutoff model to GaussianOutcomeModel with conditional mean and
truncated-mean identities, and proves msmUpperCalib_gaussian_halfWidth: the
sharp upper bound is the point-identified conditional mean plus the Dorn-Guo
half-width contribution.
def gaussianMSMHalfWidthFactor reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
For a real sensitivity parameter, the Dorn–Guo Gaussian half-width factor is , where and are the standard normal distribution and density functions, respectively.
Definition (Lean source)
parameters
Λ :
ℝ
def
gaussianMSMHalfWidthFactor Λ :
ℝ
given by
(Λ ^ 2 - 1) / Λ * stdNormalPDF (probit (Λ / (Λ + 1)))
structure GaussianOutcomeModel reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The conditional-Gaussian outcome model. Strengthens GaussianTreatedModel (conditional CDF Φ((·−m)/σ)) with the two conditional moments it implies: the treated conditional mean E[A·Y|σX] = e(X)·m(X) and the truncated mean above any σ(X)-measurable cutoff. This is the faithful "treated outcomes are conditionally Gaussian N(m(X), σ(X)²)" premise of the Dorn–Guo corollary.
Definition (Lean source)
parameters
fields
condMean_eq :
condTruncMean_eq :
∀ c : P.Ω → ℝ
if
Measurable[S.sigmaX] c
then
P.μ[fun ω => S.dVar.indicator true ω * S.factualY ω * (if c ω < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX]
=ᵐ[P.μ] fun ω => S.propScore true ω * (m (S.factualX ω) * (1 - stdNormalCDF ((c ω - m (S.factualX ω)) / σ (S.factualX ω))) + σ (S.factualX ω) * stdNormalPDF ((c ω - m (S.factualX ω)) / σ (S.factualX ω)))
theorem msmUpperCalib_gaussian_halfWidth reviewed
⚑ flagged
Causalean.PO.POBackdoorSystem
The Dorn–Guo Gaussian sharp upper bound, closed form. Fix a sensitivity parameter Λ strictly greater than 1 and assume the propensity score for treatment given the covariates lies strictly between 0 and 1 almost surely (overlap). Under the conditional-Gaussian treated-outcome model with conditional mean m and conditional standard deviation σ, strengthened with the implied treated conditional mean and truncated-mean identities, assuming every candidate complete propensity in the calibrated ambiguity set is almost-everywhere measurable, the conditional mean m(X) is integrable, (1 − e(X))·σ(X) is integrable, the regularity conditions making the Gaussian-cutoff candidate mean and survival decomposition well defined, and the candidate-mean integrability at the lower weight and at the truncated difference, then the sharp upper bound on E[Y(1)] equals the point-identified mean ∫ m(X) plus the half-width (Λ²−1)/Λ · φ(Φ⁻¹(Λ/(Λ+1))) · ∫ (1 − e(X))·σ(X).
Formal statement
hypotheses
γ :
Type u_1
Λ :
ℝ
hΛ :
1 < Λ
m σ :
γ → ℝ
hmodel :
S.GaussianOutcomeModel m σ
hmeas :
∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ
hint_m :
Integrable (fun ω => m (S.factualX ω)) P.μ
hint_σ :
Integrable (fun ω => (1 - S.propScore true ω) * σ (S.factualX ω)) P.μ
hreg :
Integrable (S.gaussianCutoff m σ Λ) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ (S.gaussianCutoff m σ Λ) ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * (if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * (if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |S.gaussianCutoff m σ Λ ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ
hint_candMin :
Integrable (fun ω => S.wMin Λ ω * (S.dVar.indicator true ω * S.factualY ω)) P.μ
hint_candTrunc :
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) * (S.dVar.indicator true ω * S.factualY ω * (if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0))) P.μ
conclusion
S.msmUpperCalib Λ
= (∫ ω, m (S.factualX ω) ∂P.μ)
+ gaussianMSMHalfWidthFactor Λ * ∫ ω, (1 - S.propScore true ω) * σ (S.factualX ω) ∂P.μ
Proof (Lean source)
theorem msmUpperCalib_gaussian_halfWidth (Λ : ℝ) (hΛ : 1 < Λ)
(hoverlap : ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1)
{m σ : γ → ℝ} (hmodel : S.GaussianOutcomeModel m σ)
(hmeas : ∀ etilde ∈ S.MSMSetCalib Λ, AEMeasurable etilde P.μ)
(hint_m : Integrable (fun ω => m (S.factualX ω)) P.μ)
(hint_σ : Integrable (fun ω => (1 - S.propScore true ω) * σ (S.factualX ω)) P.μ)
(hreg : Integrable (S.gaussianCutoff m σ Λ) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω / S.cutoffProp Λ (S.gaussianCutoff m σ Λ) ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω *
(if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0)) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMin Λ ω) P.μ ∧
Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω *
(if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0))) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * |S.factualY ω| * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => S.dVar.indicator true ω * S.wMax Λ ω) P.μ ∧
Integrable (fun ω => |S.gaussianCutoff m σ Λ ω| * S.dVar.indicator true ω * S.wMax Λ ω) P.μ)
(hint_candMin : Integrable (fun ω => S.wMin Λ ω *
(S.dVar.indicator true ω * S.factualY ω)) P.μ)
(hint_candTrunc : Integrable (fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(S.dVar.indicator true ω * S.factualY ω *
(if S.gaussianCutoff m σ Λ ω < S.factualY ω then (1 : ℝ) else 0))) P.μ) :
S.msmUpperCalib Λ
= (∫ ω, m (S.factualX ω) ∂P.μ)
+ gaussianMSMHalfWidthFactor Λ
* ∫ ω, (1 - S.propScore true ω) * σ (S.factualX ω) ∂P.μ := by
classical
let c : P.Ω → ℝ := S.gaussianCutoff m σ Λ
let A : P.Ω → ℝ := S.dVar.indicator true
let Y : P.Ω → ℝ := S.factualY
let e : P.Ω → ℝ := S.propScore true
let M : P.Ω → ℝ := fun ω => m (S.factualX ω)
let sig : P.Ω → ℝ := fun ω => σ (S.factualX ω)
let z : ℝ := probit (Λ / (Λ + 1))
let K : ℝ := (Λ ^ 2 - 1) / Λ * Causalean.Mathlib.stdNormalPDF z
have hc : Measurable[S.sigmaX] c := by
simpa [c] using S.measurable_gaussianCutoff hmodel.measurable_m hmodel.measurable_σ Λ
have hreg_all := hreg
obtain ⟨_hc_int, _hcut_int, _hI_int, _hmin_int, _hdiff_int,
henvY, _hweight_env, _hc_env⟩ := hreg
have hAY_int : Integrable (fun ω => A ω * Y ω) P.μ := by
simpa [A, Y] using
S.integrable_treatedY_of_wMax_envelope Λ hΛ hoverlap henvY
have hAYI_int : Integrable
(fun ω => A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) P.μ := by
simpa [A, Y, c] using
S.integrable_treatedY_trunc_of_wMax_envelope Λ hΛ hoverlap c hc henvY
have hprop_meas : Measurable[S.sigmaX] (S.propScore true) := by
unfold POBackdoorSystem.propScore
exact stronglyMeasurable_condExp.measurable
have hwMin_smeas : StronglyMeasurable[S.sigmaX] (S.wMin Λ) := by
unfold POBackdoorSystem.wMin
exact (measurable_const.add
((measurable_const.sub hprop_meas).div
(measurable_const.mul hprop_meas))).stronglyMeasurable
have hwMax_smeas : StronglyMeasurable[S.sigmaX] (S.wMax Λ) := by
unfold POBackdoorSystem.wMax
exact (measurable_const.add
((measurable_const.mul (measurable_const.sub hprop_meas)).div
hprop_meas)).stronglyMeasurable
have hdiff_smeas :
StronglyMeasurable[S.sigmaX] (fun ω => S.wMax Λ ω - S.wMin Λ ω) :=
(hwMax_smeas.measurable.sub hwMin_smeas.measurable).stronglyMeasurable
have hmain :
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c) := by
simpa [c] using
S.msmUpperCalib_gaussian Λ hΛ hoverlap hmodel.toGaussianTreatedModel hmeas hreg_all
have hcand_split :
S.candMean (S.cutoffProp Λ c) =
∫ ω, S.wMin Λ ω * (A ω * Y ω) ∂P.μ +
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) ∂P.μ := by
unfold POBackdoorSystem.candMean
rw [← integral_add hint_candMin hint_candTrunc]
refine integral_congr_ae (Filter.Eventually.of_forall ?_)
intro ω
by_cases hcy : c ω < Y ω
· have hcy' : S.gaussianCutoff m σ Λ ω < S.factualY ω := by
simpa [c, Y] using hcy
simp only [c, A, Y, POBackdoorSystem.cutoffProp, if_pos hcy, if_pos hcy']
rw [div_div_eq_mul_div, div_one]
ring
· have hcy' : ¬S.gaussianCutoff m σ Λ ω < S.factualY ω := by
simpa [c, Y] using hcy
simp only [c, A, Y, POBackdoorSystem.cutoffProp, if_neg hcy, if_neg hcy']
rw [div_div_eq_mul_div, div_one]
ring
have hint_candTrunc_prod :
Integrable
((fun ω => S.wMax Λ ω - S.wMin Λ ω) *
fun ω => A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) P.μ := by
refine hint_candTrunc.congr (Filter.Eventually.of_forall ?_)
intro ω
by_cases hcy : c ω < Y ω
· simp [A, Y, c, hcy]
· simp [A, Y, c, hcy]
have hmin_pull :
∫ ω, S.wMin Λ ω * (A ω * Y ω) ∂P.μ =
∫ ω, S.wMin Λ ω *
P.μ[fun ω => A ω * Y ω | S.sigmaX] ω ∂P.μ := by
simpa [Pi.mul_apply] using
integral_mul_condExp_eq (μ := P.μ) (m0 := S.sigmaX) S.sigmaX_le
hwMin_smeas hAY_int (by exact hint_candMin)
have hmin_ae :
(fun ω => S.wMin Λ ω *
P.μ[fun ω => A ω * Y ω | S.sigmaX] ω)
=ᵐ[P.μ] fun ω => S.wMin Λ ω * (e ω * M ω) := by
filter_upwards [hmodel.condMean_eq] with ω hω
simpa [A, Y, e, M] using congrArg (fun t => S.wMin Λ ω * t) hω
have hmin_int_eval : Integrable (fun ω => S.wMin Λ ω * (e ω * M ω)) P.μ := by
have hpull :
P.μ[fun ω => S.wMin Λ ω * (A ω * Y ω) | S.sigmaX]
=ᵐ[P.μ] fun ω => S.wMin Λ ω *
P.μ[fun ω => A ω * Y ω | S.sigmaX] ω :=
MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hwMin_smeas
(by exact hint_candMin) hAY_int
exact (MeasureTheory.integrable_condExp
(μ := P.μ) (m := S.sigmaX)
(f := fun ω => S.wMin Λ ω * (A ω * Y ω))).congr
(hpull.trans hmin_ae)
have hmin_eval :
∫ ω, S.wMin Λ ω * (A ω * Y ω) ∂P.μ =
∫ ω, S.wMin Λ ω * (e ω * M ω) ∂P.μ := by
rw [hmin_pull]
exact integral_congr_ae hmin_ae
have htrunc_pull :
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) ∂P.μ =
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
P.μ[fun ω => A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0) |
S.sigmaX] ω ∂P.μ := by
simpa [Pi.mul_apply] using
integral_mul_condExp_eq (μ := P.μ) (m0 := S.sigmaX) S.sigmaX_le
hdiff_smeas hAYI_int hint_candTrunc_prod
have htrunc_ae :
(fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
P.μ[fun ω => A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0) |
S.sigmaX] ω)
=ᵐ[P.μ] fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(e ω * (M ω *
(1 - stdNormalCDF ((c ω - M ω) / sig ω))
+ sig ω *
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω))) := by
filter_upwards [hmodel.condTruncMean_eq c hc] with ω hω
simpa [A, Y, e, M, sig] using
congrArg (fun t => (S.wMax Λ ω - S.wMin Λ ω) * t) hω
have htrunc_int_eval : Integrable
(fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(e ω * (M ω *
(1 - stdNormalCDF ((c ω - M ω) / sig ω))
+ sig ω *
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω)))) P.μ := by
have hpull :
P.μ[fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) | S.sigmaX]
=ᵐ[P.μ] fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
P.μ[fun ω => A ω * Y ω *
(if c ω < Y ω then (1 : ℝ) else 0) | S.sigmaX] ω :=
MeasureTheory.condExp_mul_of_stronglyMeasurable_left
(m := S.sigmaX) (μ := P.μ) hdiff_smeas
hint_candTrunc_prod hAYI_int
exact (MeasureTheory.integrable_condExp
(μ := P.μ) (m := S.sigmaX)
(f := fun ω => (S.wMax Λ ω - S.wMin Λ ω) *
(A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)))).congr
(hpull.trans htrunc_ae)
have htrunc_eval :
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) ∂P.μ =
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(e ω * (M ω *
(1 - stdNormalCDF ((c ω - M ω) / sig ω))
+ sig ω *
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω))) ∂P.μ := by
rw [htrunc_pull]
exact integral_congr_ae htrunc_ae
have hp0 : 0 < Λ / (Λ + 1) := by positivity
have hp1 : Λ / (Λ + 1) < 1 := by
have hΛp : 0 < Λ + 1 := by linarith
rw [div_lt_one hΛp]
linarith
have honeMinus : 1 - Λ / (Λ + 1) = 1 / (Λ + 1) := by
have hΛp : Λ + 1 ≠ 0 := by linarith
field_simp [hΛp]
ring
have hscalar_ae :
(fun ω => S.wMin Λ ω * (e ω * M ω) +
(S.wMax Λ ω - S.wMin Λ ω) *
(e ω * (M ω *
(1 - stdNormalCDF ((c ω - M ω) / sig ω))
+ sig ω *
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω))))
=ᵐ[P.μ] fun ω => M ω + K * ((1 - e ω) * sig ω) := by
filter_upwards [hoverlap] with ω hω
have harg :
(c ω - M ω) / sig ω = z := by
simpa [c, M, sig, z] using
S.gaussianCutoff_standardized hmodel.toGaussianTreatedModel Λ ω
have hcdf :
stdNormalCDF ((c ω - M ω) / sig ω) = Λ / (Λ + 1) := by
rw [harg]
exact Causalean.Mathlib.stdNormalCDF_probit hp0 hp1
have hpdf :
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω) =
Causalean.Mathlib.stdNormalPDF z := by
rw [harg]
have hscalar := gaussian_halfWidth_scalar Λ (e ω) (M ω) (sig ω)
(Causalean.Mathlib.stdNormalPDF z) hΛ hω.1 hω.2
unfold POBackdoorSystem.wMin POBackdoorSystem.wMax
rw [hcdf, hpdf, honeMinus]
simpa [e, K, z, mul_assoc, mul_left_comm, mul_comm] using hscalar
have hcombined :
(∫ ω, S.wMin Λ ω * (e ω * M ω) ∂P.μ) +
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(e ω * (M ω *
(1 - stdNormalCDF ((c ω - M ω) / sig ω))
+ sig ω *
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω))) ∂P.μ =
∫ ω, M ω + K * ((1 - e ω) * sig ω) ∂P.μ := by
rw [← integral_add hmin_int_eval htrunc_int_eval]
exact integral_congr_ae hscalar_ae
have hsplit_final :
∫ ω, M ω + K * ((1 - e ω) * sig ω) ∂P.μ =
(∫ ω, M ω ∂P.μ) + K * ∫ ω, (1 - e ω) * sig ω ∂P.μ := by
integral_linearity
calc
S.msmUpperCalib Λ = S.candMean (S.cutoffProp Λ c) := hmain
_ = (∫ ω, S.wMin Λ ω * (A ω * Y ω) ∂P.μ) +
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(A ω * Y ω * (if c ω < Y ω then (1 : ℝ) else 0)) ∂P.μ := hcand_split
_ = (∫ ω, S.wMin Λ ω * (e ω * M ω) ∂P.μ) +
∫ ω, (S.wMax Λ ω - S.wMin Λ ω) *
(e ω * (M ω *
(1 - stdNormalCDF ((c ω - M ω) / sig ω))
+ sig ω *
Causalean.Mathlib.stdNormalPDF ((c ω - M ω) / sig ω))) ∂P.μ := by
-- … truncated; follow the source link for the rest …