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 · 5 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
Causalean.PO

The odds ratio of two probabilities p₁, p₂ ∈ (0,1): OR(p₁, p₂) = (p₁/(1-p₁)) / (p₂/(1-p₂)). The MSM measures the discrepancy between the complete propensity and the observed propensity by this quantity.

Definition (Lean source)
noncomputable def OR (p₁ p₂ : ℝ) : ℝ := (p₁ / (1 - p₁)) / (p₂ / (1 - p₂))
def sigmaXY1 reviewed
Causalean.PO.POBackdoorSystem

σ-algebra generated by BOTH the factual covariate X and the treated potential outcome Y(1). Conditioning on this richer information set defines the complete propensity; it always refines σ(X).

Definition (Lean source)
noncomputable def sigmaXY1 : MeasurableSpace P.Ω := comap S.factualX inferInstancecomap (S.YofD true) inferInstance
def completeProp reviewed
Causalean.PO.POBackdoorSystem

The complete propensity e₀(X, Y(1)) = P[D=1 | σ(X, Y(1))]: the conditional probability of treatment given covariates and the treated potential outcome. Under unconfoundedness it collapses (a.e.) to the observed propensity e(X); in general it is the unobservable object the MSM bounds.

Definition (Lean source)
noncomputable def completeProp : P.Ω → ℝ := P.μ[S.dVar.indicator true | S.sigmaXY1]
def candMean reviewed
Causalean.PO.POBackdoorSystem

The candidate IPW mean E[A · Y / ẽ] for a candidate complete propensity , where A = 1_{D=1} is the treatment indicator and Y the factual outcome. Evaluated at the true complete propensity this returns E[Y(1)]; traced over the ambiguity set it sweeps out the MSM interval.

Definition (Lean source)
noncomputable def candMean (etilde : P.Ω → ℝ) : ℝ := ∫ ω, S.dVar.indicator true ω * S.factualY ω / etilde ω ∂P.μ
def Y1mean reviewed
Causalean.PO.POBackdoorSystem

The estimand μ = E[Y(1)], the mean of the treated potential outcome.

Definition (Lean source)
noncomputable def Y1mean : ℝ := ∫ ω, S.YofD true ω ∂P.μ
def MSMSet reviewed
Causalean.PO.POBackdoorSystem

The MSM ambiguity set at sensitivity level Λ: the set of candidate complete propensities that are a.e. in (0,1) and whose odds ratio against the observed propensity e(X) = P[D=1 | σ(X)] is a.e. bounded within [1/Λ, Λ]. Larger Λ admits more candidates, widening the resulting interval.

Definition (Lean source)
def MSMSet (Λ : ℝ) : Set (P.Ω → ℝ) := { etilde | (∀ᵐ ω ∂P.μ, 0 < etilde ω ∧ etilde ω < 1) ∧ (∀ᵐ ω ∂P.μ, 1 / Λ ≤ OR (etilde ω) (S.propScore true ω) ∧ OR (etilde ω) (S.propScore true ω) ≤ Λ) }
def msmUpper reviewed
Causalean.PO.POBackdoorSystem

The MSM upper bound: the supremum of the candidate mean over the ambiguity set. The largest value of E[Y(1)] consistent with the sensitivity budget Λ.

Definition (Lean source)
noncomputable def msmUpper (Λ : ℝ) : ℝ := sSup (S.candMean '' S.MSMSet Λ)
def msmLower reviewed
Causalean.PO.POBackdoorSystem

The MSM lower bound: the infimum of the candidate mean over the ambiguity set. The smallest value of E[Y(1)] consistent with the sensitivity budget Λ.

Definition (Lean source)
noncomputable def msmLower (Λ : ℝ) : ℝ := sInf (S.candMean '' S.MSMSet Λ)
theorem candMean_completeProp_eq_Y1mean reviewed
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
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
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
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
Λ :
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 Λ)
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
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
etilde :
P.Ω → ℝ
hprop :
∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
hmem :
etilde ∈ S.MSMSet 1
∀ᵐ ω ∂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]
5 supporting declarations (lemmas, instances)
  • sigmaXY1_le lemma — The joint σ-algebra σ(X, Y(1)) is coarser than the ambient σ-algebra on Ω.
    S.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
    Causalean.PO.POBackdoorSystem.sigmaXY1_le · Causalean/PO/ID/Partial/Sensitivity/MSM/Setup.lean:54
  • completeProp_mem_MSMSet theorem — 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.
    Λ :
    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 Λ
    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
    Causalean.PO.POBackdoorSystem.completeProp_mem_MSMSet · Causalean/PO/ID/Partial/Sensitivity/MSM/Setup.lean:189
  • MSMSet_mono theorem — 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 Λ.
    Λ Λ' :
    :
    1 ≤ Λ
    hΛΛ' :
    Λ ≤ Λ'
    S.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ΛΛ'
    Causalean.PO.POBackdoorSystem.MSMSet_mono · Causalean/PO/ID/Partial/Sensitivity/MSM/Setup.lean:225
  • msmUpper_mono theorem — 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.
    Λ Λ' :
    :
    1 ≤ Λ
    hΛΛ' :
    Λ ≤ Λ'
    hne :
    (S.candMean '' S.MSMSet Λ).Nonempty
    hbdd' :
    BddAbove (S.candMean '' S.MSMSet Λ')
    S.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
    Causalean.PO.POBackdoorSystem.msmUpper_mono · Causalean/PO/ID/Partial/Sensitivity/MSM/Setup.lean:241
  • msmLower_anti theorem — 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.
    Λ Λ' :
    :
    1 ≤ Λ
    hΛΛ' :
    Λ ≤ Λ'
    hne :
    (S.candMean '' S.MSMSet Λ).Nonempty
    hbdd' :
    BddBelow (S.candMean '' S.MSMSet Λ')
    S.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
    Causalean.PO.POBackdoorSystem.msmLower_anti · Causalean/PO/ID/Partial/Sensitivity/MSM/Setup.lean:253
Bounds 6 core · 0 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
Causalean.PO.POBackdoorSystem

The smallest admissible inverse-propensity weight at sensitivity level Λ: wMin = 1 + (1 − e(X)) / (Λ · e(X)), the OR = 1/Λ endpoint of the odds-ratio box.

Definition (Lean source)
noncomputable def wMin (Λ : ℝ) (ω : P.Ω) : ℝ := 1 + (1 - S.propScore true ω) / (Λ * S.propScore true ω)
def wMax reviewed
Causalean.PO.POBackdoorSystem

The largest admissible inverse-propensity weight at sensitivity level Λ: wMax = 1 + Λ · (1 − e(X)) / e(X), the OR = Λ endpoint of the odds-ratio box.

Definition (Lean source)
noncomputable def wMax (Λ : ℝ) (ω : P.Ω) : ℝ := 1 + Λ * (1 - S.propScore true ω) / S.propScore true ω
def msmUpperForm reviewed
Causalean.PO.POBackdoorSystem

The closed-form upper integrand: wMax where Y ≥ 0, wMin where Y < 0.

Definition (Lean source)
noncomputable def msmUpperForm (Λ : ℝ) : ℝ := ∫ ω, S.dVar.indicator true ω * S.factualY ω * (if 0 ≤ S.factualY ω then S.wMax Λ ω else S.wMin Λ ω) ∂P.μ
def msmLowerForm reviewed
Causalean.PO.POBackdoorSystem

The closed-form lower bound: wMin where Y ≥ 0, wMax where Y < 0.

Definition (Lean source)
noncomputable def msmLowerForm (Λ : ℝ) : ℝ := ∫ ω, S.dVar.indicator true ω * S.factualY ω * (if 0 ≤ S.factualY ω then S.wMin Λ ω else S.wMax Λ ω) ∂P.μ
theorem msmUpper_eq reviewed
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
Λ :
:
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 Λ
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`, `wMaxwMin`). 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
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
Λ :
:
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 Λ
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
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
Causalean.PO.POBackdoorSystem

Calibration (data-compatibility). A candidate complete propensity is calibrated if the inverse-propensity weighting of the treatment indicator averages to one within every covariate stratum: E[ Z / ẽ | σ(X) ] = 1 a.e. This is the only restriction on beyond the odds-ratio box implied by the observed-data distribution.

Definition (Lean source)
def Calibrated (etilde : P.Ω → ℝ) : Prop := P.μ[fun ω => S.dVar.indicator true ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => 1)
def MSMSetCalib reviewed
Causalean.PO.POBackdoorSystem

The calibrated (sharp) MSM ambiguity set: odds-ratio-box members that also satisfy calibration.

Definition (Lean source)
def MSMSetCalib (Λ : ℝ) : Set (P.Ω → ℝ) := { etilde | etilde ∈ S.MSMSet Λ ∧ S.Calibrated etilde }
def msmUpperCalib reviewed
Causalean.PO.POBackdoorSystem

The sharp upper bound: the supremum of the candidate mean over the calibrated set.

Definition (Lean source)
noncomputable def msmUpperCalib (Λ : ℝ) : ℝ := sSup (S.candMean '' S.MSMSetCalib Λ)
def msmLowerCalib reviewed
Causalean.PO.POBackdoorSystem

The sharp lower bound: the infimum of the candidate mean over the calibrated set.

Definition (Lean source)
noncomputable def msmLowerCalib (Λ : ℝ) : ℝ := sInf (S.candMean '' S.MSMSetCalib Λ)
theorem Y1mean_mem_Icc_calib reviewed
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
Λ :
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 Λ)
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
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
Λ :
hne :
(S.candMean '' S.MSMSetCalib Λ).Nonempty
hbdd :
BddAbove (S.candMean '' S.MSMSet Λ)
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_calibrated theorem — 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.
    hpos :
    ∀ᵐ ω ∂P.μ, 0 < S.completeProp ω
    hint :
    Integrable (fun ω => S.dVar.indicator true ω / S.completeProp ω) P.μ
    S.Calibrated S.completeProp
    Proof (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 : ℝ))
    Causalean.PO.POBackdoorSystem.completeProp_calibrated · Causalean/PO/ID/Partial/Sensitivity/MSM/Sharp.lean:70
  • completeProp_mem_MSMSetCalib theorem — The true complete propensity lies in the calibrated set when it satisfies MSM membership and calibration.
    Λ :
    hmem :
    S.completeProp ∈ S.MSMSet Λ
    hcalib :
    S.Calibrated S.completeProp
    S.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⟩
    Causalean.PO.POBackdoorSystem.completeProp_mem_MSMSetCalib · Causalean/PO/ID/Partial/Sensitivity/MSM/Sharp.lean:132
  • MSMSetCalib_subset theorem — The calibrated set is a subset of the odds-ratio box.
    Λ :
    S.MSMSetCalib Λ ⊆ S.MSMSet Λ
    Proof (Lean source)
    theorem MSMSetCalib_subset (Λ : ℝ) : S.MSMSetCalib Λ ⊆ S.MSMSet Λ := fun _ h => h.1
    Causalean.PO.POBackdoorSystem.MSMSetCalib_subset · Causalean/PO/ID/Partial/Sensitivity/MSM/Sharp.lean:157
  • msmLower_le_msmLowerCalib theorem — The sharp lower bound is tighter than the ZSB bound: msmLower Λ ≤ msmLowerCalib Λ.
    Λ :
    hne :
    (S.candMean '' S.MSMSetCalib Λ).Nonempty
    hbdd :
    BddBelow (S.candMean '' S.MSMSet Λ)
    S.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
    Causalean.PO.POBackdoorSystem.msmLower_le_msmLowerCalib · Causalean/PO/ID/Partial/Sensitivity/MSM/Sharp.lean:175
Control­Setup 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
Causalean.PO.POBackdoorSystem

σ-algebra generated by BOTH the factual covariate X and the control potential outcome Y(0). Conditioning on this richer information set defines the complete control propensity; it always refines σ(X).

Definition (Lean source)
noncomputable def sigmaXY0 : MeasurableSpace P.Ω := comap S.factualX inferInstancecomap (S.YofD false) inferInstance
def completeProp0 reviewed
Causalean.PO.POBackdoorSystem

The complete control propensity P[D=0 | σ(X, Y(0))]: the conditional probability of being untreated given covariates and the control potential outcome. Under unconfoundedness it collapses (a.e.) to P[D=0 | σ(X)] = propScore false.

Definition (Lean source)
noncomputable def completeProp0 : P.Ω → ℝ := P.μ[S.dVar.indicator false | S.sigmaXY0]
def candMean0 reviewed
Causalean.PO.POBackdoorSystem

The candidate IPW mean E[(1−A) · Y / ẽ] for a candidate complete control propensity , where 1−A = 1_{D=0} is the control indicator and Y the factual outcome. Evaluated at the true complete control propensity this returns E[Y(0)].

Definition (Lean source)
noncomputable def candMean0 (etilde : P.Ω → ℝ) : ℝ := ∫ ω, S.dVar.indicator false ω * S.factualY ω / etilde ω ∂P.μ
def Y0mean reviewed
Causalean.PO.POBackdoorSystem

The estimand μ₀ = E[Y(0)], the mean of the control potential outcome.

Definition (Lean source)
noncomputable def Y0mean : ℝ := ∫ ω, S.YofD false ω ∂P.μ
def MSMSet0 reviewed
Causalean.PO.POBackdoorSystem

The control MSM ambiguity set at sensitivity level Λ: candidate complete control propensities that are a.e. in (0,1) and whose odds ratio against the observed control propensity P[D=0 | σ(X)] = propScore false is a.e. within [1/Λ, Λ].

Definition (Lean source)
def MSMSet0 (Λ : ℝ) : Set (P.Ω → ℝ) := { etilde | (∀ᵐ ω ∂P.μ, 0 < etilde ω ∧ etilde ω < 1) ∧ (∀ᵐ ω ∂P.μ, 1 / Λ ≤ OR (etilde ω) (S.propScore false ω) ∧ OR (etilde ω) (S.propScore false ω) ≤ Λ) }
def msmUpper0 reviewed
Causalean.PO.POBackdoorSystem

The control MSM upper bound: the supremum of the candidate mean over the ambiguity set.

Definition (Lean source)
noncomputable def msmUpper0 (Λ : ℝ) : ℝ := sSup (S.candMean0 '' S.MSMSet0 Λ)
def msmLower0 reviewed
Causalean.PO.POBackdoorSystem

The control MSM lower bound: the infimum of the candidate mean over the ambiguity set.

Definition (Lean source)
noncomputable def msmLower0 (Λ : ℝ) : ℝ := sInf (S.candMean0 '' S.MSMSet0 Λ)
theorem Y0mean_mem_Icc reviewed
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
Λ :
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 Λ)
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
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
etilde :
P.Ω → ℝ
hprop :
∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1
hmem :
etilde ∈ S.MSMSet0 1
∀ᵐ ω ∂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_le lemma — The joint σ-algebra σ(X, Y(0)) is coarser than the ambient σ-algebra on Ω.
    S.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
    Causalean.PO.POBackdoorSystem.sigmaXY0_le · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSetup.lean:42
  • candMean0_completeProp0_eq_Y0mean theorem — 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.
    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
    Proof (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]
    Causalean.PO.POBackdoorSystem.candMean0_completeProp0_eq_Y0mean · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSetup.lean:81
  • completeProp0_mem_MSMSet0 theorem — The control MSM assumption: the truth lies in the ambiguity set.
    Λ :
    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 Λ
    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
    Causalean.PO.POBackdoorSystem.completeProp0_mem_MSMSet0 · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSetup.lean:155
  • MSMSet0_mono theorem — Monotonicity of the control ambiguity set in the sensitivity parameter.
    Λ Λ' :
    :
    1 ≤ Λ
    hΛΛ' :
    Λ ≤ Λ'
    S.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ΛΛ'
    Causalean.PO.POBackdoorSystem.MSMSet0_mono · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSetup.lean:185
  • msmUpper0_mono theorem — The control MSM interval widens with Λ (upper endpoint).
    Λ Λ' :
    :
    1 ≤ Λ
    hΛΛ' :
    Λ ≤ Λ'
    hne :
    (S.candMean0 '' S.MSMSet0 Λ).Nonempty
    hbdd' :
    BddAbove (S.candMean0 '' S.MSMSet0 Λ')
    S.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
    Causalean.PO.POBackdoorSystem.msmUpper0_mono · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSetup.lean:199
  • msmLower0_anti theorem — The control MSM interval widens with Λ (lower endpoint).
    Λ Λ' :
    :
    1 ≤ Λ
    hΛΛ' :
    Λ ≤ Λ'
    hne :
    (S.candMean0 '' S.MSMSet0 Λ).Nonempty
    hbdd' :
    BddBelow (S.candMean0 '' S.MSMSet0 Λ')
    S.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
    Causalean.PO.POBackdoorSystem.msmLower0_anti · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSetup.lean:209
Control­Sharp 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
Causalean.PO.POBackdoorSystem

Calibration (control arm). A candidate complete control propensity is calibrated if E[ (1−Z) / ẽ | σ(X) ] = 1 a.e., where 1−Z = 1_{D=0}.

Definition (Lean source)
def Calibrated0 (etilde : P.Ω → ℝ) : Prop := P.μ[fun ω => S.dVar.indicator false ω / etilde ω | S.sigmaX] =ᵐ[P.μ] (fun _ => 1)
def MSMSetCalib0 reviewed
Causalean.PO.POBackdoorSystem

The calibrated (sharp) control MSM ambiguity set.

Definition (Lean source)
def MSMSetCalib0 (Λ : ℝ) : Set (P.Ω → ℝ) := { etilde | etilde ∈ S.MSMSet0 Λ ∧ S.Calibrated0 etilde }
def msmUpperCalib0 reviewed
Causalean.PO.POBackdoorSystem

The sharp control upper bound: the supremum of the candidate mean over the calibrated set.

Definition (Lean source)
noncomputable def msmUpperCalib0 (Λ : ℝ) : ℝ := sSup (S.candMean0 '' S.MSMSetCalib0 Λ)
def msmLowerCalib0 reviewed
Causalean.PO.POBackdoorSystem

The sharp control lower bound: the infimum of the candidate mean over the calibrated set.

Definition (Lean source)
noncomputable def msmLowerCalib0 (Λ : ℝ) : ℝ := sInf (S.candMean0 '' S.MSMSetCalib0 Λ)
theorem Y0mean_mem_Icc_calib reviewed
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
Λ :
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 Λ)
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_calibrated theorem — 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.
    hpos :
    ∀ᵐ ω ∂P.μ, 0 < S.completeProp0 ω
    hint :
    Integrable (fun ω => S.dVar.indicator false ω / S.completeProp0 ω) P.μ
    S.Calibrated0 S.completeProp0
    Proof (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 : ℝ))
    Causalean.PO.POBackdoorSystem.completeProp0_calibrated · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSharp.lean:56
  • completeProp0_mem_MSMSetCalib0 theorem — The true complete control propensity lies in the calibrated set.
    Λ :
    hmem :
    S.completeProp0 ∈ S.MSMSet0 Λ
    hcalib :
    S.Calibrated0 S.completeProp0
    S.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⟩
    Causalean.PO.POBackdoorSystem.completeProp0_mem_MSMSetCalib0 · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSharp.lean:110
  • MSMSetCalib0_subset theorem — The calibrated control set is a subset of the odds-ratio box.
    Λ :
    S.MSMSetCalib0 Λ ⊆ S.MSMSet0 Λ
    Proof (Lean source)
    theorem MSMSetCalib0_subset (Λ : ℝ) : S.MSMSetCalib0 Λ ⊆ S.MSMSet0 Λ := fun _ h => h.1
    Causalean.PO.POBackdoorSystem.MSMSetCalib0_subset · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSharp.lean:136
  • msmUpperCalib0_le_msmUpper0 theorem — The sharp control upper bound is tighter than the ZSB bound.
    Λ :
    hne :
    (S.candMean0 '' S.MSMSetCalib0 Λ).Nonempty
    hbdd :
    BddAbove (S.candMean0 '' S.MSMSet0 Λ)
    S.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
    Causalean.PO.POBackdoorSystem.msmUpperCalib0_le_msmUpper0 · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSharp.lean:140
  • msmLower0_le_msmLowerCalib0 theorem — The sharp control lower bound is tighter than the ZSB bound.
    Λ :
    hne :
    (S.candMean0 '' S.MSMSetCalib0 Λ).Nonempty
    hbdd :
    BddBelow (S.candMean0 '' S.MSMSet0 Λ)
    S.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
    Causalean.PO.POBackdoorSystem.msmLower0_le_msmLowerCalib0 · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlSharp.lean:150
Quantile­Balance 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
Causalean.PO.POBackdoorSystem

The quantile-cutoff complete propensity at cutoff function c: the candidate whose inverse weight is wMax above the cutoff and wMin at or below it, 1 / (wMax if Y > c(X) else wMin).

Definition (Lean source)
noncomputable def cutoffProp (Λ : ℝ) (c : P.Ω → ℝ) (ω : P.Ω) : ℝ := 1 / (if c ω < S.factualY ω then S.wMax Λ ω else S.wMin Λ ω)
theorem cutoff_optimal reviewed
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
Λ :
:
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)
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
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
Λ :
:
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)
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)
Control­Cutoff 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
Causalean.PO.POBackdoorSystem

The smallest admissible inverse-propensity weight for untreated units is the lower endpoint of the control odds-ratio box.

Definition (Lean source)
noncomputable def wMin0 (Λ : ℝ) (ω : P.Ω) : ℝ := 1 + (1 - S.propScore false ω) / (Λ * S.propScore false ω)
def wMax0 reviewed
Causalean.PO.POBackdoorSystem

The largest admissible inverse-propensity weight for untreated units is the upper endpoint of the control odds-ratio box.

Definition (Lean source)
noncomputable def wMax0 (Λ : ℝ) (ω : P.Ω) : ℝ := 1 + Λ * (1 - S.propScore false ω) / S.propScore false ω
def cutoffProp0 reviewed
Causalean.PO.POBackdoorSystem

The control quantile-cutoff complete propensity uses the upper weight above the cutoff and the lower weight at or below it.

Definition (Lean source)
noncomputable def cutoffProp0 (Λ : ℝ) (c : P.Ω → ℝ) (ω : P.Ω) : ℝ := 1 / (if c ω < S.factualY ω then S.wMax0 Λ ω else S.wMin0 Λ ω)
def controlSurv reviewed
Causalean.PO.POBackdoorSystem

The conditional control-survival at a cutoff is the conditional mean of untreated units whose outcome lies above the cutoff.

Definition (Lean source)
noncomputable def controlSurv (c : P.Ω → ℝ) : P.Ω → ℝ := P.μ[fun ω => S.dVar.indicator false ω * (if c ω < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX]
def survTarget0 reviewed
Causalean.PO.POBackdoorSystem

The target control survival is the conditional survival value that makes the cutoff calibrated.

Definition (Lean source)
noncomputable def survTarget0 (Λ : ℝ) (ω : P.Ω) : ℝ := (1 - S.wMin0 Λ ω * S.propScore false ω) / (S.wMax0 Λ ω - S.wMin0 Λ ω)
theorem wMin0_mul_propScore_le_one reviewed
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
Λ :
:
1 ≤ Λ
hoverlap :
∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1
∀ᵐ ω ∂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
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
Λ :
:
1 ≤ Λ
hoverlap :
∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1
∀ᵐ ω ∂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
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
Λ :
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 ω)
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
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
Λ :
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 ω)
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
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
Λ :
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 ω)
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
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
Λ :
:
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)
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
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
Λ :
:
1 ≤ Λ
hoverlap :
∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1
c :
P.Ω → ℝ
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
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
Λ :
:
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 Λ
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⟩
Cutoff­Selection 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
Causalean.PO.POBackdoorSystem

The conditional treated-survival at cutoff c: G(c) = E[Z·1{Y > c(X)} | σ(X)].

Definition (Lean source)
noncomputable def treatedSurv (c : P.Ω → ℝ) : P.Ω → ℝ := P.μ[fun ω => S.dVar.indicator true ω * (if c ω < S.factualY ω then (1 : ℝ) else 0) | S.sigmaX]
def survTarget reviewed
Causalean.PO.POBackdoorSystem

The target survival that calibrates the cutoff: (1 − wMin·e)/(wMax − wMin).

Definition (Lean source)
noncomputable def survTarget (Λ : ℝ) (ω : P.Ω) : ℝ := (1 - S.wMin Λ ω * S.propScore true ω) / (S.wMax Λ ω - S.wMin Λ ω)
theorem cutoff_calibValue_eq reviewed
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
Λ :
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 ω)
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
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
Λ :
:
1 ≤ Λ
hoverlap :
∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
c :
P.Ω → ℝ
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_survival theorem — Calibration from the survival equation. If the conditional treated-survival of the cutoff equals the target, the cutoff is calibrated.
    Λ :
    :
    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)
    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
    Causalean.PO.POBackdoorSystem.cutoffProp_calibrated_of_survival · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffSelection.lean:153
  • cutoffProp_mem_MSMSetCalib_of_survival theorem — 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.
    Λ :
    :
    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 Λ
    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⟩
    Causalean.PO.POBackdoorSystem.cutoffProp_mem_MSMSetCalib_of_survival · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffSelection.lean:276
Cutoff­Construct 6 core · 6 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
Causalean.PO.POBackdoorSystem

The treated set {ω | D(ω) = 1}.

Definition (Lean source)
def treatedSet : Set P.Ω := S.factualD ⁻¹' {true}
def treatedXYLaw reviewed
Causalean.PO.POBackdoorSystem

The treated push-forward law of (X, Y): the law of the factual covariate and outcome on the sub-population of treated units, (μ restricted to {D=1}) ∘ (X, Y)⁻¹.

Definition (Lean source)
noncomputable def treatedXYLaw : Measure (γ × ℝ) := (P.μ.restrict S.treatedSet).map (fun ω => (S.factualX ω, S.factualY ω))
def treatedCondCDF reviewed
Causalean.PO.POBackdoorSystem

The treated conditional CDF of Y given X, evaluated along the factual covariate: F(t | X(ω)) = P(Y ≤ t | X = X(ω), D = 1).

Definition (Lean source)
noncomputable def treatedCondCDF (ω : P.Ω) (t : ℝ) : ℝ := condCDF S.treatedXYLaw (S.factualX ω) t
def calibLevel reviewed
Causalean.PO.POBackdoorSystem

The calibration quantile level τ(ω) = 1 − survTarget(ω)/e(ω): the treated-conditional-CDF level whose quantile is the calibrating cutoff.

Definition (Lean source)
noncomputable def calibLevel (Λ : ℝ) (ω : P.Ω) : ℝ := 1 - S.survTarget Λ ω / S.propScore true ω
theorem exists_calibrating_cutoff reviewed
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
Λ :
:
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 Λ
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
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
Λ :
:
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.Ω → ℝ
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.μ
∃ c : P.Ω → ℝ,
Measurable[S.sigmaX] c ∧
S.cutoffProp Λ c ∈ S.MSMSetCalib Λ ∧
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⟩
6 supporting declarations (lemmas, instances)
  • treatedSurv_const_eq theorem — 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.
    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)
    Proof (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
    Causalean.PO.POBackdoorSystem.treatedSurv_const_eq · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffConstruct.lean:302
  • measurable_condCDF_variable lemma — The conditional CDF remains measurable when evaluated at a measurable cutoff.
    ρ :
    Measure (γ × ℝ)
    q :
    γ → ℝ
    hq :
    Measurable (fun a => condCDF ρ a (q a))
    Proof (Lean source)
    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
    Causalean.PO.POBackdoorSystem.measurable_condCDF_variable · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffConstruct.lean:350
  • integrable_condCDF_variable lemma — The conditional CDF evaluated at a measurable cutoff is integrable under the first marginal.
    ρ :
    Measure (γ × ℝ)
    q :
    γ → ℝ
    hq :
    Integrable (fun a => condCDF ρ a (q a)) ρ.fst
    Proof (Lean source)
    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)
    Causalean.PO.POBackdoorSystem.integrable_condCDF_variable · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffConstruct.lean:376
  • setLIntegral_condCDF_variable lemma — Set-lintegral form of the conditional CDF identity at a measurable variable cutoff.
    ρ :
    Measure (γ × ℝ)
    B :
    Set γ
    hB :
    q :
    γ → ℝ
    hq :
    ∫⁻ a in B, ofReal (condCDF ρ a (q a)) ∂ρ.fst
    = ρ {p : γ × ℝ | p.1 ∈ B ∧ p.2 ≤ q p.1}
    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
    Causalean.PO.POBackdoorSystem.setLIntegral_condCDF_variable · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffConstruct.lean:387
  • treatedSurv_eq theorem — 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.
    c :
    P.Ω → ℝ
    hc :
    Measurable[S.sigmaX] c
    S.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
    Causalean.PO.POBackdoorSystem.treatedSurv_eq · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffConstruct.lean:688
  • exists_factor_through_factualX theorem — σ(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.
    f :
    P.Ω → ℝ
    hf :
    Measurable[S.sigmaX] f
    ∃ g : γ → ℝ, Measurable g ∧ f = fun ω => g (S.factualX ω)
    Proof (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⟩
    Causalean.PO.POBackdoorSystem.exists_factor_through_factualX · Causalean/PO/ID/Partial/Sensitivity/MSM/CutoffConstruct.lean:729
Control­Cutoff­Construct 5 core · 3 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
Causalean.PO.POBackdoorSystem

The control set {ω | D(ω) = 0}.

Definition (Lean source)
def controlSet : Set P.Ω := S.factualD ⁻¹' {false}
def controlXYLaw reviewed
Causalean.PO.POBackdoorSystem

The control push-forward law of (X, Y): the law of the factual covariate and outcome on the sub-population of control units, (μ restricted to {D=0}) ∘ (X, Y)⁻¹.

Definition (Lean source)
noncomputable def controlXYLaw : Measure (γ × ℝ) := (P.μ.restrict S.controlSet).map (fun ω => (S.factualX ω, S.factualY ω))
def controlCondCDF reviewed
Causalean.PO.POBackdoorSystem

The control conditional CDF of Y given X, evaluated along the factual covariate: F(t | X(ω)) = P(Y ≤ t | X = X(ω), D = 0).

Definition (Lean source)
noncomputable def controlCondCDF (ω : P.Ω) (t : ℝ) : ℝ := condCDF S.controlXYLaw (S.factualX ω) t
def calibLevel0 reviewed
Causalean.PO.POBackdoorSystem

The calibration quantile level τ(ω) = 1 − survTarget0(ω)/e(ω): the control-conditional-CDF level whose quantile is the calibrating cutoff.

Definition (Lean source)
noncomputable def calibLevel0 (Λ : ℝ) (ω : P.Ω) : ℝ := 1 - S.survTarget0 Λ ω / S.propScore false ω
theorem msmUpperCalib0_eq_cutoff_unconditional reviewed
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
Λ :
:
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.Ω → ℝ
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.μ
∃ c : P.Ω → ℝ,
Measurable[S.sigmaX] c ∧
S.cutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ ∧
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⟩
3 supporting declarations (lemmas, instances)
  • controlSurv_const_eq theorem — 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.
    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)
    Proof (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
    Causalean.PO.POBackdoorSystem.controlSurv_const_eq · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlCutoffConstruct.lean:280
  • controlSurv_eq theorem — 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.
    c :
    P.Ω → ℝ
    hc :
    Measurable[S.sigmaX] c
    S.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_cutoff0 theorem — 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).
    Λ :
    _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 Λ
    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
    Causalean.PO.POBackdoorSystem.exists_calibrating_cutoff0 · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlCutoffConstruct.lean:620
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
Causalean.PO.POBackdoorSystem

The average treatment effect τ = E[Y(1)] − E[Y(0)].

Definition (Lean source)
noncomputable def ate : ℝ := S.Y1mean - S.Y0mean
def ateUpperCalib reviewed
Causalean.PO.POBackdoorSystem

The sharp ATE upper bound τ⁺(Λ) = ψ_T⁺(Λ) − ψ_C⁻(Λ): the treated sharp upper bound minus the control sharp lower bound.

Definition (Lean source)
noncomputable def ateUpperCalib (Λ : ℝ) : ℝ := S.msmUpperCalib Λ - S.msmLowerCalib0 Λ
Causalean.PO.POBackdoorSystem.ateUpperCalib · Causalean/PO/ID/Partial/Sensitivity/MSM/ATE.lean:51 · uses POBackdoorSystem , POSystem
def ateLowerCalib reviewed
Causalean.PO.POBackdoorSystem

The sharp ATE lower bound τ⁻(Λ) = ψ_T⁻(Λ) − ψ_C⁺(Λ): the treated sharp lower bound minus the control sharp upper bound.

Definition (Lean source)
noncomputable def ateLowerCalib (Λ : ℝ) : ℝ := S.msmLowerCalib Λ - S.msmUpperCalib0 Λ
Causalean.PO.POBackdoorSystem.ateLowerCalib · Causalean/PO/ID/Partial/Sensitivity/MSM/ATE.lean:55 · uses POBackdoorSystem , POSystem
def ateUpper reviewed
Causalean.PO.POBackdoorSystem

The ZSB ATE upper bound ψ_T⁺ − ψ_C⁻ formed from the uncalibrated arm bounds.

Definition (Lean source)
noncomputable def ateUpper (Λ : ℝ) : ℝ := S.msmUpper Λ - S.msmLower0 Λ
def ateLower reviewed
Causalean.PO.POBackdoorSystem

The ZSB ATE lower bound ψ_T⁻ − ψ_C⁺ formed from the uncalibrated arm bounds.

Definition (Lean source)
noncomputable def ateLower (Λ : ℝ) : ℝ := S.msmLower Λ - S.msmUpper0 Λ
theorem ate_mem_Icc_calib reviewed
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
Λ :
hT :
S.Y1mean ∈ Icc (S.msmLowerCalib Λ) (S.msmUpperCalib Λ)
hC :
S.Y0mean ∈ Icc (S.msmLowerCalib0 Λ) (S.msmUpperCalib0 Λ)
S.ate ∈ Icc (S.ateLowerCalib Λ) (S.ateUpperCalib Λ)
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
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
Λ :
hT :
S.Y1mean ∈ Icc (S.msmLower Λ) (S.msmUpper Λ)
hC :
S.Y0mean ∈ Icc (S.msmLower0 Λ) (S.msmUpper0 Λ)
S.ate ∈ Icc (S.ateLower Λ) (S.ateUpper Λ)
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
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
Λ :
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 Λ)
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_Icc theorem — 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.
    a aₗ aᵤ b bₗ bᵤ :
    ha :
    a ∈ Icc aₗ aᵤ
    hb :
    b ∈ Icc bₗ bᵤ
    a - 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⟩
    Causalean.PO.POBackdoorSystem.sub_mem_Icc_of_mem_Icc · Causalean/PO/ID/Partial/Sensitivity/MSM/ATE.lean:65
Control­Lower­Bound 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
Causalean.PO.POBackdoorSystem

The lower quantile-cutoff complete propensity: the candidate whose inverse weight is wMin0 above the cutoff and wMax0 at or below it, 1 / (wMin0 if Y > c(X) else wMax0) — the minimizing worst case (opposite of cutoffProp).

Definition (Lean source)
noncomputable def lowerCutoffProp0 (Λ : ℝ) (c : P.Ω → ℝ) (ω : P.Ω) : ℝ := 1 / (if c ω < S.factualY ω then S.wMin0 Λ ω else S.wMax0 Λ ω)
def survTargetLower0 reviewed
Causalean.PO.POBackdoorSystem

The lower target survival that calibrates the lower cutoff: survTargetLower0 = (wMax0·e − 1)/(wMax0 − wMin0) (equal to e − survTarget).

Definition (Lean source)
noncomputable def survTargetLower0 (Λ : ℝ) (ω : P.Ω) : ℝ := (S.wMax0 Λ ω * S.propScore false ω - 1) / (S.wMax0 Λ ω - S.wMin0 Λ ω)
def calibLevelLower0 reviewed
Causalean.PO.POBackdoorSystem

The lower calibration quantile level 1 − survTargetLower0/e (= survTarget/e).

Definition (Lean source)
noncomputable def calibLevelLower0 (Λ : ℝ) (ω : P.Ω) : ℝ := 1 - S.survTargetLower0 Λ ω / S.propScore false ω
theorem cutoff_optimal0_lower reviewed
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
Λ :
:
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
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
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
Λ :
:
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)
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
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
Λ :
:
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.Ω → ℝ
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.μ
∃ c : P.Ω → ℝ,
Measurable[S.sigmaX] c ∧
S.lowerCutoffProp0 Λ c ∈ S.MSMSetCalib0 Λ ∧
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_eq theorem — Decomposition of the lower-cutoff calibration value. E[(1-Z)/lowerCutoffProp0 Λ c | σ(X)] = wMax0·e₀ − (wMax0 − wMin0)·G(c), with G(c) = controlSurv c.
    Λ :
    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 ω)
    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ω]
    Causalean.PO.POBackdoorSystem.lowerControl_calibValue_eq · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlLowerBound.lean:397
  • lowerCutoffProp0_calibrated_of_survival theorem — Lower-cutoff calibration from the survival equation.
    Λ :
    :
    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)
    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
    Causalean.PO.POBackdoorSystem.lowerCutoffProp0_calibrated_of_survival · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlLowerBound.lean:484
  • lowerCutoffProp0_mem_MSMSet0 theorem — The lower cutoff propensity is always in the odds-ratio box.
    Λ :
    :
    1 ≤ Λ
    hoverlap :
    ∀ᵐ ω ∂P.μ, 0 < S.propScore false ω ∧ S.propScore false ω < 1
    c :
    P.Ω → ℝ
    S.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⟩
    Causalean.PO.POBackdoorSystem.lowerCutoffProp0_mem_MSMSet0 · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlLowerBound.lean:515
  • lowerCutoffProp0_mem_MSMSetCalib0_of_survival theorem — The lower cutoff is calibrated-feasible given the survival equation.
    Λ :
    :
    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 Λ
    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⟩
    Causalean.PO.POBackdoorSystem.lowerCutoffProp0_mem_MSMSetCalib0_of_survival · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlLowerBound.lean:601
  • exists_calibrating_cutoff0_lower theorem — Existence of a calibrating lower cutoff. The survTargetLower0 analogue of exists_calibrating_cutoff: a σ(X)-measurable c with controlSurv c =ᵐ survTargetLower0 Λ.
    Λ :
    :
    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 Λ
    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
    Causalean.PO.POBackdoorSystem.exists_calibrating_cutoff0_lower · Causalean/PO/ID/Partial/Sensitivity/MSM/ControlLowerBound.lean:618
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
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)
m σ :
γ → ℝ
measurable_m :
measurable_σ :
σ_pos :
∀ a, 0 < σ a
condCDF_eq :
∀ a t, condCDF S.treatedXYLaw a t = stdNormalCDF ((t - m a) / σ a)
Causalean.PO.POBackdoorSystem.GaussianTreatedModel · Causalean/PO/ID/Partial/Sensitivity/MSM/Gaussian.lean:89 · uses POBackdoorSystem , POSystem
def gaussianCutoff reviewed
Causalean.PO.POBackdoorSystem

The explicit Gaussian cutoff c(X) = m(X) + σ(X)·Φ⁻¹(Λ/(Λ+1)), the Λ/(Λ+1) conditional quantile of the treated Gaussian outcome law.

Definition (Lean source)
noncomputable def gaussianCutoff (m σ : γ → ℝ) (Λ : ℝ) (ω : P.Ω) : ℝ := m (S.factualX ω) + σ (S.factualX ω) * probit (Λ / (Λ + 1))
theorem msmUpperCalib_gaussian reviewed
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
Λ :
:
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 σ Λ))
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_eq theorem — 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.
    Λ :
    :
    1 < Λ
    hoverlap :
    ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
    ∀ᵐ ω ∂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
    Causalean.PO.POBackdoorSystem.calibLevel_eq · Causalean/PO/ID/Partial/Sensitivity/MSM/Gaussian.lean:75
  • measurable_gaussianCutoff theorem — The explicit Gaussian cutoff is σ(X)-measurable.
    m σ :
    γ → ℝ
    hm :
    :
    Λ :
    Measurable[S.sigmaX] (S.gaussianCutoff m σ Λ)
    Proof (Lean source)
    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)
    Causalean.PO.POBackdoorSystem.measurable_gaussianCutoff · Causalean/PO/ID/Partial/Sensitivity/MSM/Gaussian.lean:104
  • gaussianCutoff_calibrates theorem — The explicit Gaussian cutoff calibrates. Under the conditional-Gaussian model, the cutoff m(X) + σ(X)·Φ⁻¹(Λ/(Λ+1)) solves the survival equation treatedSurv c =ᵐ survTarget Λ.
    Λ :
    :
    1 < Λ
    hoverlap :
    ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
    m σ :
    γ → ℝ
    hmodel :
    S.GaussianTreatedModel m σ
    S.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
    Causalean.PO.POBackdoorSystem.gaussianCutoff_calibrates · Causalean/PO/ID/Partial/Sensitivity/MSM/Gaussian.lean:114
Lower­Bound 6 core · 5 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
Causalean.PO.POBackdoorSystem

The lower quantile-cutoff complete propensity: the candidate whose inverse weight is wMin above the cutoff and wMax at or below it, 1 / (wMin if Y > c(X) else wMax) — the minimizing worst case (opposite of cutoffProp).

Definition (Lean source)
noncomputable def lowerCutoffProp (Λ : ℝ) (c : P.Ω → ℝ) (ω : P.Ω) : ℝ := 1 / (if c ω < S.factualY ω then S.wMin Λ ω else S.wMax Λ ω)
def survTargetLower reviewed
Causalean.PO.POBackdoorSystem

The lower target survival that calibrates the lower cutoff: survTargetLower = (wMax·e − 1)/(wMax − wMin) (equal to e − survTarget).

Definition (Lean source)
noncomputable def survTargetLower (Λ : ℝ) (ω : P.Ω) : ℝ := (S.wMax Λ ω * S.propScore true ω - 1) / (S.wMax Λ ω - S.wMin Λ ω)
def calibLevelLower reviewed
Causalean.PO.POBackdoorSystem

The lower calibration quantile level 1 − survTargetLower/e (= survTarget/e).

Definition (Lean source)
noncomputable def calibLevelLower (Λ : ℝ) (ω : P.Ω) : ℝ := 1 - S.survTargetLower Λ ω / S.propScore true ω
theorem cutoff_optimal_lower reviewed
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
Λ :
:
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
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.μ := 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.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 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) 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 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.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 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.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.μ -- … truncated; follow the source link for the rest …
theorem exists_calibrating_cutoff_lower reviewed
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
Λ :
:
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 Λ
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 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.survTargetLower Λ) := by unfold POBackdoorSystem.survTargetLower exact ((hwMax_meas.mul hprop_meas).sub measurable_const).div (hwMax_meas.sub hwMin_meas) have hlevel_meas : Measurable[S.sigmaX] (S.calibLevelLower Λ) := by unfold POBackdoorSystem.calibLevelLower 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.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
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
Λ :
:
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.Ω → ℝ
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.μ
∃ c : P.Ω → ℝ,
Measurable[S.sigmaX] c ∧
S.lowerCutoffProp Λ c ∈ S.MSMSetCalib Λ ∧
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⟩
5 supporting declarations (lemmas, instances)
  • msmLowerCalib_eq_cutoff theorem — The sharp lower bound has the quantile-balancing closed form. Given a calibrating lower cutoff, msmLowerCalib Λ = candMean (lowerCutoffProp Λ c).
    Λ :
    :
    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)
    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
    Causalean.PO.POBackdoorSystem.msmLowerCalib_eq_cutoff · Causalean/PO/ID/Partial/Sensitivity/MSM/LowerBound.lean:371
  • lowerCutoff_calibValue_eq theorem — Decomposition of the lower-cutoff calibration value. E[Z/lowerCutoffProp Λ c | σ(X)] = wMax·e − (wMax − wMin)·G(c) (with G(c) = treatedSurv c).
    Λ :
    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 ω)
    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 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 (μ := P.μ) true (measurableSet_singleton true) have hI_int : Integrable (fun ω => A ω * I ω) P.μ := by rw [hA_def, hI_def] exact hint1 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] := MeasureTheory.condExp_sub hmax_int' hdiff_int S.sigmaX 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ω]
    Causalean.PO.POBackdoorSystem.lowerCutoff_calibValue_eq · Causalean/PO/ID/Partial/Sensitivity/MSM/LowerBound.lean:399
  • lowerCutoffProp_calibrated_of_survival theorem — Lower-cutoff calibration from the survival equation.
    Λ :
    :
    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)
    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
    Causalean.PO.POBackdoorSystem.lowerCutoffProp_calibrated_of_survival · Causalean/PO/ID/Partial/Sensitivity/MSM/LowerBound.lean:485
  • lowerCutoffProp_mem_MSMSet theorem — The lower cutoff propensity is always in the odds-ratio box.
    Λ :
    :
    1 ≤ Λ
    hoverlap :
    ∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
    c :
    P.Ω → ℝ
    S.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⟩
    Causalean.PO.POBackdoorSystem.lowerCutoffProp_mem_MSMSet · Causalean/PO/ID/Partial/Sensitivity/MSM/LowerBound.lean:516
  • lowerCutoffProp_mem_MSMSetCalib_of_survival theorem — The lower cutoff is calibrated-feasible given the survival equation.
    Λ :
    :
    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 Λ
    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⟩
    Causalean.PO.POBackdoorSystem.lowerCutoffProp_mem_MSMSetCalib_of_survival · Causalean/PO/ID/Partial/Sensitivity/MSM/LowerBound.lean:602
ATEClosed­Form 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
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
Λ :
:
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.Ω → ℝ
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
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.Ω → ℝ
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.μ
∃ 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)
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
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_cutoffa 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
Λ :
:
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.Ω → ℝ
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.μ
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.Ω → ℝ
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 Λ)
∃ 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))
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⟩
Control­Quantile­Balance 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
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
Λ :
:
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)
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
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
Λ :
:
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)
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)
Cutoff­Exists 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
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
Λ :
:
1 ≤ Λ
hoverlap :
∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
∀ᵐ ω ∂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
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
Λ :
:
1 ≤ Λ
hoverlap :
∀ᵐ ω ∂P.μ, 0 < S.propScore true ω ∧ S.propScore true ω < 1
∀ᵐ ω ∂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
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
Λ :
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 ω)
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
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
Λ :
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 ω)
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))
Gaussian­Half­Width 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
Causalean.PO.POBackdoorSystem

Dorn–Guo Gaussian half-width factor. For τ = Λ/(Λ+1) with Λ ≥ 1, the per-stratum MSM sharp half-width factor is (Λ²−1)/Λ · φ(Φ⁻¹(τ)). This packages the scalar appearing in the Gaussian ATE interval [ψ ± (Λ²−1)/Λ · φ(Φ⁻¹(Λ/(Λ+1))) · E[σ(X)]].

Definition (Lean source)
noncomputable def gaussianMSMHalfWidthFactor (Λ : ℝ) : ℝ := (Λ ^ 2 - 1) / Λ * stdNormalPDF (probit (Λ / (Λ + 1)))
Causalean.PO.POBackdoorSystem.gaussianMSMHalfWidthFactor · Causalean/PO/ID/Partial/Sensitivity/MSM/GaussianHalfWidth.lean:46
structure GaussianOutcomeModel reviewed
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)
m σ :
γ → ℝ
condMean_eq :
P.μ[fun ω => S.dVar.indicator true ω * S.factualY ω | S.sigmaX]
=ᵐ[P.μ] fun ω => S.propScore true ω * m (S.factualX ω)
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
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
Λ :
:
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.μ
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 have hM_int : Integrable M P.μ := by simpa [M] using hint_m have hσ_int : Integrable (fun ω => (1 - e ω) * sig ω) P.μ := by simpa [e, sig] using hint_σ rw [integral_add hM_int (hσ_int.const_mul K)] rw [integral_const_mul] 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.μ) + -- … truncated; follow the source link for the rest …