PO.ID.Partial.Support­Function

Support-function representations of convex identified sets and their estimation theory.

Basic 2 core · 2 supporting This file defines the support function of a feasible set in a real inner-product space. ★ supportFn★ le_supportFn

Support functions for partial identification

This file defines the support function of a feasible set in a real inner-product space. It supplies the basic lower and upper comparison principles used to turn convex feasible sets into sharp bounds for linear causal targets. Boundedness and nonemptiness side conditions are carried explicitly, matching the scalar partial-identification convention.

def supportFn reviewed
Causalean.PartialID

The support function of a set C in direction d: supportFn C d = sup { ⟪d, x⟫ : x ∈ C }. Outside the nonempty and bounded-above regime, the raw sSup value is a convention and should not be used mathematically; meaningful statements carry Nonempty/BddAbove hypotheses (see le_supportFn, supportFn_le).

Definition (Lean source)
noncomputable def supportFn (C : Set E) (d : E) : ℝ := sSup ((fun x => ⟪d, x⟫) '' C)
theorem le_supportFn reviewed
Causalean.PartialID

Lower sandwich. For a feasible set C in a real inner-product space and a direction d, if a point x belongs to C and the linear functional ⟪d, ·⟫ is bounded above on C, then x's functional value is at most the support value: ⟪d, x⟫ ≤ supportFn C d.

Formal statement
C :
Set E
d :
E
x :
E
hx :
x ∈ C
hbdd :
BddAbove ((fun x => ⟪d, x⟫) '' C)
⟪d, x⟫ ≤ supportFn C d
Proof (Lean source)
theorem le_supportFn {C : Set E} {d : E} {x : E} (hx : x ∈ C) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) : ⟪d, x⟫ ≤ supportFn C d := le_csSup hbdd ⟨x, hx, rfl⟩
2 supporting declarations (lemmas, instances)
  • supportFn_eq_iSup_image lemma — The support function is definitionally the supremum of the linear target over the set.
    C :
    Set E
    d :
    E
    supportFn C d = sSup ((fun x => ⟪d, x⟫) '' C)
    Proof (Lean source)
    lemma supportFn_eq_iSup_image (C : Set E) (d : E) : supportFn C d = sSup ((fun x => ⟪d, x⟫) '' C) := rfl
    Causalean.PartialID.supportFn_eq_iSup_image · Causalean/PO/ID/Partial/SupportFunction/Basic.lean:63
  • supportFn_le theorem — Upper sandwich. A uniform upper bound b on the functional over a nonempty C bounds the support value: supportFn C d ≤ b.
    C :
    Set E
    d :
    E
    b :
    hne :
    C.Nonempty
    hb :
    ∀ x ∈ C, ⟪d, x⟫ ≤ b
    supportFn C d ≤ b
    Proof (Lean source)
    theorem supportFn_le {C : Set E} {d : E} {b : ℝ} (hne : C.Nonempty) (hb : ∀ x ∈ C, ⟪d, x⟫ ≤ b) : supportFn C d ≤ b := by refine csSup_le ?_ ?_ · exact (hne.image _) · rintro _ ⟨x, hx, rfl⟩; exact hb x hx
Interval 5 core · 4 supporting This file characterizes the sharp interval of values attained by a linear target over a convex feasible set. ★ linearImage_eq_Icc★ linearImage_eq_Icc_of_isCompact★ width_eq_zero_iff★ identifiedInterval_eq_image

Support-Function Identified Intervals

This file characterizes the sharp interval of values attained by a linear target over a convex feasible set. It connects the support-function description of the lower and upper endpoints to the scalar identified-interval machinery used elsewhere in the partial-identification library.

theorem linearImage_eq_Icc reviewed
Causalean.PartialID

Sharp identified interval (attainment form). For a convex feasible set C in a real inner-product space and a linear target direction d, assuming the target functional is bounded above on C in the direction d and in the opposite direction -d, and that the upper support value is attained by some feasible point and the lower support value -supportFn C (-d) is likewise attained, then the identified set of the target functional over C is exactly the closed interval [-supportFn C (-d), supportFn C d].

Formal statement
C :
Set E
d :
E
hC :
Convex ℝ C
hbdd :
BddAbove ((fun x => ⟪d, x⟫) '' C)
hbdd' :
BddAbove ((fun x => ⟪-d, x⟫) '' C)
hUmem :
supportFn C d ∈ (fun x => ⟪d, x⟫) '' C
hLmem :
-supportFn C (-d) ∈ (fun x => ⟪d, x⟫) '' C
(fun x => ⟪d, x⟫) '' C = Icc (-supportFn C (-d)) (supportFn C d)
Proof (Lean source)
theorem linearImage_eq_Icc {C : Set E} {d : E} (hC : Convex ℝ C) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbdd' : BddAbove ((fun x => ⟪-d, x⟫) '' C)) (hUmem : supportFn C d ∈ (fun x => ⟪d, x⟫) '' C) (hLmem : -supportFn C (-d) ∈ (fun x => ⟪d, x⟫) '' C) : (fun x => ⟪d, x⟫) '' C = Icc (-supportFn C (-d)) (supportFn C d) := Set.Subset.antisymm (linearImage_subset_Icc hbdd hbdd') ((linearImage_ordConnected hC).out hLmem hUmem)
Causalean.PartialID.linearImage_eq_Icc · Causalean/PO/ID/Partial/SupportFunction/Interval.lean:86 · uses supportFn
theorem linearImage_eq_Icc_of_isCompact reviewed
Causalean.PartialID

Sharp identified interval (compact convex form). For a linear target direction d and a feasible set that is compact, convex, and nonempty, the identified set of the target functional ⟪d, ·⟫ over C is exactly the closed interval [-supportFn C (-d), supportFn C d]: a continuous functional attains its supremum and infimum on a compact set and is automatically bounded there.

Formal statement
C :
Set E
d :
E
hcomp :
hC :
Convex ℝ C
hne :
C.Nonempty
(fun x => ⟪d, x⟫) '' C = Icc (-supportFn C (-d)) (supportFn C d)
Proof (Lean source)
theorem linearImage_eq_Icc_of_isCompact {C : Set E} {d : E} (hcomp : IsCompact C) (hC : Convex ℝ C) (hne : C.Nonempty) : (fun x => ⟪d, x⟫) '' C = Icc (-supportFn C (-d)) (supportFn C d) := by have hcont : Continuous (fun x => ⟪d, x⟫) := continuous_inner.comp (continuous_const.prodMk continuous_id) have hcont' : Continuous (fun x => ⟪-d, x⟫) := continuous_inner.comp (continuous_const.prodMk continuous_id) have hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C) := hcomp.bddAbove_image hcont.continuousOn have hbdd' : BddAbove ((fun x => ⟪-d, x⟫) '' C) := hcomp.bddAbove_image hcont'.continuousOn obtain ⟨xU, hxU, hU⟩ := hcomp.exists_sSup_image_eq hne hcont.continuousOn obtain ⟨xL, hxL, hL⟩ := hcomp.exists_sSup_image_eq hne hcont'.continuousOn refine linearImage_eq_Icc hC hbdd hbdd' ?_ ?_ · exact ⟨xU, hxU, hU.symm⟩ · refine ⟨xL, hxL, ?_⟩ have hsup : supportFn C (-d) = ⟪-d, xL⟫ := hL change ⟪d, xL⟫ = -supportFn C (-d) rw [hsup, inner_neg_left]; ring
Causalean.PartialID.linearImage_eq_Icc_of_isCompact · Causalean/PO/ID/Partial/SupportFunction/Interval.lean:102 · uses supportFn
def width reviewed
Causalean.PartialID

The width of the identified set: supportFn C d + supportFn C (-d), i.e. the upper endpoint minus the lower endpoint.

Definition (Lean source)
noncomputable def width (C : Set E) (d : E) : ℝ := supportFn C d + supportFn C (-d)
theorem width_eq_zero_iff reviewed
Causalean.PartialID

Point identification. For a feasible set C and direction d in a real inner-product space, assuming C is nonempty and the target functional ⟪d, ·⟫ is bounded above on C in the direction d and in the opposite direction -d, then the identified set collapses to a point (zero width) if and only if the target functional is constant on C, equal to its support value.

Formal statement
C :
Set E
d :
E
hne :
C.Nonempty
hbdd :
BddAbove ((fun x => ⟪d, x⟫) '' C)
hbdd' :
BddAbove ((fun x => ⟪-d, x⟫) '' C)
width C d = 0 ↔ ∀ x ∈ C, ⟪d, x⟫ = supportFn C d
Proof (Lean source)
theorem width_eq_zero_iff {C : Set E} {d : E} (hne : C.Nonempty) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbdd' : BddAbove ((fun x => ⟪-d, x⟫) '' C)) : width C d = 0 ↔ ∀ x ∈ C, ⟪d, x⟫ = supportFn C d := by constructor · intro hw x hx have hle : ⟪d, x⟫ ≤ supportFn C d := le_supportFn hx hbdd have hge : -supportFn C (-d) ≤ ⟪d, x⟫ := neg_supportFn_neg_le hx hbdd' have : -supportFn C (-d) = supportFn C d := by simp only [width] at hw; linarith linarith · intro hconst -- supportFn C (-d) = -supportFn C d, since ⟪-d,x⟫ = -(supportFn C d) on C have hneg : supportFn C (-d) = -supportFn C d := by apply le_antisymm · refine supportFn_le hne ?_ intro x hx rw [inner_neg_left, hconst x hx] · obtain ⟨x, hx⟩ := hne have := le_supportFn (d := -d) hx hbdd' rw [inner_neg_left, hconst x hx] at this linarith simp only [width, hneg]; ring
theorem identifiedInterval_eq_image reviewed
Causalean.PartialID

Bridge to the scalar engine. For an objective functional obj and a feasible set C, the scalar identified interval of obj relative to membership in C equals exactly the image of obj on C. Specialised to obj = ⟪d, ·⟫, this identifies the scalar engine's output with the linear image studied here.

Formal statement
α :
Type*
obj :
α → ℝ
C :
Set α
IdentifiedInterval obj (· ∈ C) = obj '' C
Proof (Lean source)
theorem identifiedInterval_eq_image {α : Type*} (obj : α → ℝ) (C : Set α) : IdentifiedInterval obj (· ∈ C) = obj '' C := by ext y simp only [IdentifiedInterval, Set.mem_range, Set.mem_image, Subtype.exists] constructor · rintro ⟨x, hx, rfl⟩; exact ⟨x, hx, rfl⟩ · rintro ⟨x, hx, rfl⟩; exact ⟨x, hx, rfl⟩
Causalean.PartialID.identifiedInterval_eq_image · Causalean/PO/ID/Partial/SupportFunction/Interval.lean:168 · uses IdentifiedInterval
4 supporting declarations (lemmas, instances)
  • neg_supportFn_neg_le theorem — Lower endpoint bound. If ⟪-d, ·⟫ is bounded above on C, then the lower endpoint -supportFn C (-d) is a lower bound for the functional ⟪d, ·⟫.
    C :
    Set E
    d :
    E
    x :
    E
    hx :
    x ∈ C
    hbdd' :
    BddAbove ((fun x => ⟪-d, x⟫) '' C)
    -supportFn C (-d) ≤ ⟪d, x⟫
    Proof (Lean source)
    theorem neg_supportFn_neg_le {C : Set E} {d : E} {x : E} (hx : x ∈ C) (hbdd' : BddAbove ((fun x => ⟪-d, x⟫) '' C)) : -supportFn C (-d) ≤ ⟪d, x⟫ := by have h := le_supportFn (d := -d) hx hbdd' rw [inner_neg_left] at h linarith
    Causalean.PartialID.neg_supportFn_neg_le · Causalean/PO/ID/Partial/SupportFunction/Interval.lean:59
  • linearImage_subset_Icc theorem — Outer bound. The identified set of the linear target lies inside the support interval [-supportFn C (-d), supportFn C d].
    C :
    Set E
    d :
    E
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    hbdd' :
    BddAbove ((fun x => ⟪-d, x⟫) '' C)
    (fun x => ⟪d, x⟫) '' C ⊆ Icc (-supportFn C (-d)) (supportFn C d)
    Proof (Lean source)
    theorem linearImage_subset_Icc {C : Set E} {d : E} (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbdd' : BddAbove ((fun x => ⟪-d, x⟫) '' C)) : (fun x => ⟪d, x⟫) '' C ⊆ Icc (-supportFn C (-d)) (supportFn C d) := by rintro _ ⟨x, hx, rfl⟩ exact ⟨neg_supportFn_neg_le hx hbdd', le_supportFn hx hbdd⟩
    Causalean.PartialID.linearImage_subset_Icc · Causalean/PO/ID/Partial/SupportFunction/Interval.lean:68
  • linearImage_ordConnected theorem — Order-connectedness. The linear image of a convex set is convex in ℝ, hence order-connected: the identified set has "no gaps".
    C :
    Set E
    d :
    E
    hC :
    Convex ℝ C
    ((fun x => ⟪d, x⟫) '' C).OrdConnected
    Proof (Lean source)
    theorem linearImage_ordConnected {C : Set E} {d : E} (hC : Convex ℝ C) : ((fun x => ⟪d, x⟫) '' C).OrdConnected := by have hlin : IsLinearMap ℝ (fun x => ⟪d, x⟫) := { map_add := fun x y => inner_add_right d x y map_smul := fun c x => real_inner_smul_right d x c } exact (hC.is_linear_image hlin).ordConnected
    Causalean.PartialID.linearImage_ordConnected · Causalean/PO/ID/Partial/SupportFunction/Interval.lean:77
  • width_nonneg theorem — The identified width is nonnegative.
    C :
    Set E
    d :
    E
    hne :
    C.Nonempty
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    hbdd' :
    BddAbove ((fun x => ⟪-d, x⟫) '' C)
    0 ≤ width C d
    Proof (Lean source)
    theorem width_nonneg {C : Set E} {d : E} (hne : C.Nonempty) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbdd' : BddAbove ((fun x => ⟪-d, x⟫) '' C)) : 0 ≤ width C d := by obtain ⟨x, hx⟩ := hne have h1 := le_supportFn hx hbdd have h2 := le_supportFn (d := -d) hx hbdd' rw [inner_neg_left] at h2 simp only [width]; linarith
Affine­Ball 5 core · 2 supporting This file solves the support-function problem for a linear functional over the intersection of an affine solution set and a Hilbert-space ball. ★ supportFn_affineBall_eq★ width_affineBall_eq★ affineBall_point_identified_iff

Support bounds for an affine ball

This file solves the support-function problem for a linear functional over the intersection of an affine solution set and a Hilbert-space ball. It defines the free-direction kernel opKer and feasible set affineBall, proves the closed-form endpoint supportFn_affineBall_eq, derives the width formula width_affineBall_eq, and characterizes point identification by affineBall_point_identified_iff.

abbrev opKer reviewed
Causalean.PartialID

The free-direction subspace of a continuous operator: perturbations in ker A do not change the linear constraint A h = b.

Definition (Lean source)
abbrev opKer (A : H →L[ℝ] F) : Submodule ℝ H := ker (A : H →ₗ[ℝ] F)
def affineBall reviewed
Causalean.PartialID

The affine-ball fiber contains the solutions to a linear equation that also satisfy a norm bound.

Definition (Lean source)
def affineBall (A : H →L[ℝ] F) (b : F) (B : ℝ) : Set H := {h | A h = b ∧ ‖h‖ ≤ B}
theorem supportFn_affineBall_eq reviewed
Causalean.PartialID

Closed-form support value over the affine-ball fiber. Let A be a continuous linear map between real inner-product spaces, b a target value, B a radius, and c a direction. Suppose h₀ solves the linear constraint A h₀ = b, h₀ is orthogonal to the kernel of A (the minimum-norm solution), and h₀'s norm is at most B (h₀ fits the ball). Then the support value of ⟪c, ·⟫ over the fiber {h : A h = b, ‖h‖ ≤ B} equals ⟪c, h₀⟫ + √(B² − ‖h₀‖²)·‖P c‖, where P is the orthogonal projection onto the kernel of A.

Formal statement
A :
H →L[ℝ] F
b :
F
B :
c h₀ :
H
hsol :
A h₀ = b
hperp :
h₀ ∈ (opKer A)ᗮ
hfit :
‖h₀‖ ≤ B
= ⟪c, h₀⟫
+ sqrt (B ^ 2 - ‖h₀‖ ^ 2) * ‖(orthogonalProjection (opKer A) c : H)‖
Proof (Lean source)
theorem supportFn_affineBall_eq (A : H →L[ℝ] F) {b : F} {B : ℝ} {c h₀ : H} (hsol : A h₀ = b) (hperp : h₀ ∈ (opKer A)ᗮ) (hfit : ‖h₀‖ ≤ B) : supportFn (affineBall A b B) c = ⟪c, h₀⟫ + sqrt (B ^ 2 - ‖h₀‖ ^ 2) * ‖(Submodule.orthogonalProjection (opKer A) c : H)‖ := by set K : Submodule ℝ H := opKer A with hK set Pc : H := (Submodule.orthogonalProjection K c : H) with hPc set r : ℝ := sqrt (B ^ 2 - ‖h₀‖ ^ 2) with hr -- basic nonnegativity facts have hB2 : (0 : ℝ) ≤ B ^ 2 - ‖h₀‖ ^ 2 := by have : ‖h₀‖ ^ 2 ≤ B ^ 2 := by have hn : (0 : ℝ) ≤ ‖h₀‖ := norm_nonneg _ nlinarith [hn, hfit] linarith have hr_nonneg : (0 : ℝ) ≤ r := Real.sqrt_nonneg _ have hr_sq : r ^ 2 = B ^ 2 - ‖h₀‖ ^ 2 := Real.sq_sqrt hB2 -- (FIBER): A h = b ↔ h - h₀ ∈ K have hfiber : ∀ h : H, A h = b ↔ h - h₀ ∈ K := by intro h rw [hK, opKer, LinearMap.mem_ker, ContinuousLinearMap.coe_coe, map_sub, hsol, sub_eq_zero] -- (PYTHAG): for v ∈ K, ⟪h₀, v⟫ = 0 have hpythag_inner : ∀ v : H, v ∈ K → ⟪h₀, v⟫ = 0 := by intro v hv exact Submodule.inner_left_of_mem_orthogonal hv hperp have hpythag : ∀ v : H, v ∈ K → ‖h₀ + v‖ ^ 2 = ‖h₀‖ ^ 2 + ‖v‖ ^ 2 := by intro v hv rw [norm_add_sq_real, hpythag_inner v hv]; ring -- (PROJ): for v ∈ K, ⟪c, v⟫ = ⟪Pc, v⟫ have hproj : ∀ v : H, v ∈ K → ⟪c, v⟫ = ⟪Pc, v⟫ := by intro v hv have h0 : ⟪c - Pc, v⟫ = 0 := by have hz := Submodule.starProjection_inner_eq_zero (K := K) c v hv rw [Submodule.starProjection_apply] at hz rw [hPc]; exact hz rw [inner_sub_left] at h0 linarith [h0] -- h₀ is feasible have hh0_mem : h₀ ∈ affineBall A b B := ⟨hsol, hfit⟩ -- KEY upper-bound computation: for any feasible h, ⟪c,h⟫ ≤ ⟪c,h₀⟫ + r * ‖Pc‖ have hub : ∀ h ∈ affineBall A b B, ⟪c, h⟫ ≤ ⟪c, h₀⟫ + r * ‖Pc‖ := by intro h hh obtain ⟨hAh, hnorm⟩ := hh set v : H := h - h₀ with hv_def have hvK : v ∈ K := (hfiber h).mp hAh have hh_eq : h = h₀ + v := by rw [hv_def]; abel -- ‖v‖ ≤ r have hnorm_sq : ‖h‖ ^ 2 = ‖h₀‖ ^ 2 + ‖v‖ ^ 2 := by rw [hh_eq]; exact hpythag v hvK have hv_le : ‖v‖ ^ 2 ≤ B ^ 2 - ‖h₀‖ ^ 2 := by have hhB : ‖h‖ ^ 2 ≤ B ^ 2 := by have hn : (0 : ℝ) ≤ ‖h‖ := norm_nonneg _ nlinarith [hn, hnorm] linarith [hnorm_sq] have hv_le_r : ‖v‖ ≤ r := by rw [hr] calc ‖v‖ = sqrt (‖v‖ ^ 2) := by rw [Real.sqrt_sq (norm_nonneg _)] _ ≤ sqrt (B ^ 2 - ‖h₀‖ ^ 2) := Real.sqrt_le_sqrt hv_le -- ⟪c,h⟫ = ⟪c,h₀⟫ + ⟪Pc,v⟫ have hsplit : ⟪c, h⟫ = ⟪c, h₀⟫ + ⟪Pc, v⟫ := by rw [hh_eq, inner_add_right, hproj v hvK] rw [hsplit] have hcs : ⟪Pc, v⟫ ≤ ‖Pc‖ * ‖v‖ := real_inner_le_norm Pc v have hbound : ‖Pc‖ * ‖v‖ ≤ ‖Pc‖ * r := by apply mul_le_mul_of_nonneg_left hv_le_r (norm_nonneg _) have : ⟪Pc, v⟫ ≤ r * ‖Pc‖ := by rw [mul_comm r] at *; linarith [hcs, hbound] linarith -- BddAbove for le_supportFn have hbdd : BddAbove ((fun x => ⟪c, x⟫) '' (affineBall A b B)) := by refine ⟨⟪c, h₀⟫ + r * ‖Pc‖, ?_⟩ rintro _ ⟨h, hh, rfl⟩ exact hub h hh apply le_antisymm · -- upper bound refine supportFn_le ⟨h₀, hh0_mem⟩ ?_ intro h hh exact hub h hh · -- lower bound / attainment by_cases hPc0 : Pc = 0 · -- Pc = 0: RHS = ⟪c, h₀⟫, attained at h₀ have hnorm0 : ‖Pc‖ = 0 := by rw [hPc0]; simp rw [hnorm0] simp only [mul_zero, add_zero] have := le_supportFn (C := affineBall A b B) (d := c) hh0_mem hbdd exact this · -- Pc ≠ 0: maximizer h* = h₀ + (r/‖Pc‖) • Pc have hPcK : Pc ∈ K := by rw [hPc]; exact Submodule.coe_mem _ have hPc_ne : ‖Pc‖ ≠ 0 := by rwa [ne_eq, norm_eq_zero] set v : H := (r / ‖Pc‖) • Pc with hv_def have hvK : v ∈ K := by rw [hv_def]; exact K.smul_mem _ hPcK have hv_norm : ‖v‖ = r := by rw [hv_def, norm_smul, Real.norm_eq_abs, abs_div, abs_of_nonneg hr_nonneg, abs_of_nonneg (norm_nonneg _)] field_simp set hstar : H := h₀ + v with hstar_def have hAstar : A hstar = b := by rw [hfiber hstar, hstar_def, add_sub_cancel_left] exact hvK have hstar_norm : ‖hstar‖ ≤ B := by have hsq : ‖hstar‖ ^ 2 = B ^ 2 := by rw [hstar_def, hpythag v hvK, hv_norm, hr_sq]; ring have hBnn : (0 : ℝ) ≤ B := le_trans (norm_nonneg _) hfit nlinarith [norm_nonneg hstar, hsq, hBnn] have hstar_mem : hstar ∈ affineBall A b B := ⟨hAstar, hstar_norm⟩ have hinner_v : ⟪Pc, v⟫ = r * ‖Pc‖ := by rw [hv_def, real_inner_smul_right, real_inner_self_eq_norm_sq, pow_two, div_mul_eq_mul_div, mul_div_assoc] rw [mul_div_assoc, div_self hPc_ne, mul_one] have hval : ⟪c, hstar⟫ = ⟪c, h₀⟫ + r * ‖Pc‖ := by rw [hstar_def, inner_add_right, hproj v hvK, hinner_v] have := le_supportFn (C := affineBall A b B) (d := c) hstar_mem hbdd rw [hval] at this exact this
theorem width_affineBall_eq reviewed
Causalean.PartialID

Closed-form width of the affine-ball identified set. Under the same hypotheses as supportFn_affineBall_eqh₀ solves A h₀ = b, h₀ is orthogonal to the kernel of A, and h₀'s norm is at most Bthe width of the identified set of ⟪c, ·⟫ over the fiber {h : A h = b, ‖h‖ ≤ B} equals 2·√(B² − ‖h₀‖²)·‖P c‖, twice the residual radius times the norm of c's projection onto the kernel of A.

Formal statement
A :
H →L[ℝ] F
b :
F
B :
c h₀ :
H
hsol :
A h₀ = b
hperp :
h₀ ∈ (opKer A)ᗮ
hfit :
‖h₀‖ ≤ B
width (affineBall A b B) c
= 2 * sqrt (B ^ 2 - ‖h₀‖ ^ 2) * ‖(orthogonalProjection (opKer A) c : H)‖
Proof (Lean source)
theorem width_affineBall_eq (A : H →L[ℝ] F) {b : F} {B : ℝ} {c h₀ : H} (hsol : A h₀ = b) (hperp : h₀ ∈ (opKer A)ᗮ) (hfit : ‖h₀‖ ≤ B) : width (affineBall A b B) c = 2 * sqrt (B ^ 2 - ‖h₀‖ ^ 2) * ‖(orthogonalProjection (opKer A) c : H)‖ := by unfold width rw [supportFn_affineBall_eq A hsol hperp hfit, supportFn_affineBall_eq A hsol hperp hfit] -- projection of -c is -(projection of c), so its norm equals ‖P c‖ have hneg : (orthogonalProjection (opKer A) (-c) : H) = -(orthogonalProjection (opKer A) c : H) := by rw [map_neg]; rfl rw [hneg, norm_neg, inner_neg_left] ring
theorem affineBall_point_identified_iff reviewed
Causalean.PartialID

Point identification. Let A be a continuous linear map between real inner-product spaces with b in its range, B a radius, and c a target direction. Suppose h₀ solves the linear constraint A h₀ = b, h₀ is orthogonal to the kernel of A (the minimum-norm solution), and h₀'s norm is strictly less than B (strict slack in the norm bound). Then the identified set of ⟪c, ·⟫ over the fiber {h : A h = b, ‖h‖ ≤ B} collapses to a point if and only if the orthogonal projection of c onto the kernel of A vanishes, i.e. c is orthogonal to that kernel.

Formal statement
A :
H →L[ℝ] F
b :
F
B :
c h₀ :
H
hsol :
A h₀ = b
hperp :
h₀ ∈ (opKer A)ᗮ
hfit :
‖h₀‖ < B
width (affineBall A b B) c = 0 ↔ orthogonalProjection (opKer A) c = 0
Proof (Lean source)
theorem affineBall_point_identified_iff (A : H →L[ℝ] F) {b : F} {B : ℝ} {c h₀ : H} (hsol : A h₀ = b) (hperp : h₀ ∈ (opKer A)ᗮ) (hfit : ‖h₀‖ < B) : width (affineBall A b B) c = 0 ↔ orthogonalProjection (opKer A) c = 0 := by rw [width_affineBall_eq A hsol hperp (le_of_lt hfit)] -- r = √(B² − ‖h₀‖²) > 0 under strict slack have hpos : (0 : ℝ) < B ^ 2 - ‖h₀‖ ^ 2 := by have h1 : (0 : ℝ) ≤ ‖h₀‖ := norm_nonneg _ nlinarith [h1, hfit] have hr_pos : (0 : ℝ) < sqrt (B ^ 2 - ‖h₀‖ ^ 2) := Real.sqrt_pos.mpr hpos constructor · intro hw have hPc0 : ‖(orthogonalProjection (opKer A) c : H)‖ = 0 := by rcases mul_eq_zero.mp hw with h | h · exact absurd h (by positivity) · exact h rw [norm_eq_zero] at hPc0 exact (Submodule.coe_eq_zero).mp hPc0 · intro hP rw [hP] simp
2 supporting declarations (lemmas, instances)
Calculus 1 core · 9 supporting This file proves algebraic rules for support functions of convex identified sets: singleton evaluation, homogeneity, subadditivity, monotonicity, unions, intersections, translations, scaling, and Minkowski sums. ★ supportFn_add_dir_le

Support-function calculus

This file proves algebraic rules for support functions of convex identified sets: singleton evaluation, homogeneity, subadditivity, monotonicity, unions, intersections, translations, scaling, and Minkowski sums. These rules let downstream partial-identification proofs compute robust interval endpoints compositionally.

theorem supportFn_add_dir_le reviewed
Causalean.PartialID

Subadditivity in the direction (sublinearity of the support function). For a feasible set C in a real inner-product space and directions d₁, d₂, assuming C is nonempty and the linear functionals ⟪d₁, ·⟫ and ⟪d₂, ·⟫ are each bounded above on C, then the support value in the combined direction is at most the sum of the support values in each direction: supportFn C (d₁ + d₂) ≤ supportFn C d₁ + supportFn C d₂.

Formal statement
C :
Set E
d₁ d₂ :
E
hne :
C.Nonempty
hb₁ :
BddAbove ((fun x => ⟪d₁, x⟫) '' C)
hb₂ :
BddAbove ((fun x => ⟪d₂, x⟫) '' C)
supportFn C (d₁ + d₂) ≤ supportFn C d₁ + supportFn C d₂
Proof (Lean source)
theorem supportFn_add_dir_le {C : Set E} {d₁ d₂ : E} (hne : C.Nonempty) (hb₁ : BddAbove ((fun x => ⟪d₁, x⟫) '' C)) (hb₂ : BddAbove ((fun x => ⟪d₂, x⟫) '' C)) : supportFn C (d₁ + d₂) ≤ supportFn C d₁ + supportFn C d₂ := by refine supportFn_le hne ?_ intro x hx rw [inner_add_left] have h₁ : ⟪d₁, x⟫ ≤ supportFn C d₁ := le_supportFn hx hb₁ have h₂ : ⟪d₂, x⟫ ≤ supportFn C d₂ := le_supportFn hx hb₂ linarith
Causalean.PartialID.supportFn_add_dir_le · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:102 · uses supportFn
9 supporting declarations (lemmas, instances)
  • supportFn_singleton theorem — Support function of a singleton is the functional value at the point.
    d x₀ :
    E
    supportFn ({x₀} : Set E) d = ⟪d, x₀⟫
    Proof (Lean source)
    theorem supportFn_singleton (d x₀ : E) : supportFn ({x₀} : Set E) d = ⟪d, x₀⟫ := by unfold supportFn rw [Set.image_singleton, csSup_singleton]
    Causalean.PartialID.supportFn_singleton · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:52
  • supportFn_nonneg_of_zero_mem theorem — If 0 ∈ C then the support value is nonnegative (the functional value 0 at the origin is a lower bound for the sup).
    C :
    Set E
    d :
    E
    h0 :
    (0 : E) ∈ C
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    0 ≤ supportFn C d
    Proof (Lean source)
    theorem supportFn_nonneg_of_zero_mem {C : Set E} {d : E} (h0 : (0 : E) ∈ C) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) : 0 ≤ supportFn C d := by have h := le_supportFn (C := C) (d := d) h0 hbdd simpa using h
    Causalean.PartialID.supportFn_nonneg_of_zero_mem · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:57
  • supportFn_smul_dir theorem — Positive homogeneity in the direction. For t ≥ 0, supportFn C (t • d) = t * supportFn C d.
    C :
    Set E
    d :
    E
    t :
    ht :
    0 ≤ t
    hne :
    C.Nonempty
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    supportFn C (t • d) = t * supportFn C d
    Proof (Lean source)
    theorem supportFn_smul_dir {C : Set E} {d : E} {t : ℝ} (ht : 0 ≤ t) (hne : C.Nonempty) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) : supportFn C (t • d) = t * supportFn C d := by rcases eq_or_lt_of_le ht with rfl | htpos · simp only [zero_smul, zero_mul] apply le_antisymm · refine supportFn_le hne ?_ intro x _ simp · obtain ⟨x, hx⟩ := hne have := le_supportFn (C := C) (d := (0 : E)) hx ?_ · simpa using this · refine ⟨0, ?_⟩ rintro _ ⟨y, _, rfl⟩ simp · apply le_antisymm · refine supportFn_le hne ?_ intro x hx rw [real_inner_smul_left] have : ⟪d, x⟫ ≤ supportFn C d := le_supportFn hx hbdd exact mul_le_mul_of_nonneg_left this ht · rw [mul_comm, ← le_div_iff₀ htpos] refine supportFn_le hne ?_ intro x hx rw [le_div_iff₀ htpos] have hle : ⟪t • d, x⟫ ≤ supportFn C (t • d) := by refine le_supportFn hx ?_ obtain ⟨b, hb⟩ := hbdd refine ⟨t * b, ?_⟩ rintro _ ⟨y, hy, rfl⟩ simp only [real_inner_smul_left] exact mul_le_mul_of_nonneg_left (hb (Set.mem_image_of_mem _ hy)) ht rw [real_inner_smul_left] at hle linarith [hle]
    Causalean.PartialID.supportFn_smul_dir · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:65
  • supportFn_mono theorem — Monotone in the set. If C ⊆ D (with C nonempty and the functional bounded above on D), then supportFn C d ≤ supportFn D d.
    C D :
    Set E
    d :
    E
    hCD :
    C ⊆ D
    hne :
    C.Nonempty
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' D)
    supportFn C d ≤ supportFn D d
    Proof (Lean source)
    theorem supportFn_mono {C D : Set E} {d : E} (hCD : C ⊆ D) (hne : C.Nonempty) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' D)) : supportFn C d ≤ supportFn D d := by refine supportFn_le hne (fun x hx => ?_) exact le_supportFn (hCD hx) hbdd
  • supportFn_union theorem — Union rule. The support function of a union is the maximum of the parts.
    C D :
    Set E
    d :
    E
    hC :
    C.Nonempty
    hD :
    D.Nonempty
    hbC :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    hbD :
    BddAbove ((fun x => ⟪d, x⟫) '' D)
    supportFn (C ∪ D) d = max (supportFn C d) (supportFn D d)
    Proof (Lean source)
    theorem supportFn_union {C D : Set E} {d : E} (hC : C.Nonempty) (hD : D.Nonempty) (hbC : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbD : BddAbove ((fun x => ⟪d, x⟫) '' D)) : supportFn (C ∪ D) d = max (supportFn C d) (supportFn D d) := by have hbU : BddAbove ((fun x => ⟪d, x⟫) '' (C ∪ D)) := by rw [Set.image_union]; exact hbC.union hbD refine le_antisymm ?_ ?_ · refine supportFn_le (hC.inl) (fun x hx => ?_) rcases hx with hx | hx · exact le_trans (le_supportFn hx hbC) (le_max_left _ _) · exact le_trans (le_supportFn hx hbD) (le_max_right _ _) · rw [max_le_iff] exact ⟨supportFn_mono Set.subset_union_left hC hbU, supportFn_mono Set.subset_union_right hD hbU⟩
  • supportFn_inter_le theorem — Intersection rule (one-sided). The support function of an intersection is at most the minimum of the parts.
    C D :
    Set E
    d :
    E
    hne :
    (C ∩ D).Nonempty
    hbC :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    hbD :
    BddAbove ((fun x => ⟪d, x⟫) '' D)
    supportFn (C ∩ D) d ≤ min (supportFn C d) (supportFn D d)
    Proof (Lean source)
    theorem supportFn_inter_le {C D : Set E} {d : E} (hne : (C ∩ D).Nonempty) (hbC : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbD : BddAbove ((fun x => ⟪d, x⟫) '' D)) : supportFn (C ∩ D) d ≤ min (supportFn C d) (supportFn D d) := by refine le_min ?_ ?_ · exact supportFn_mono Set.inter_subset_left hne hbC · exact supportFn_mono Set.inter_subset_right hne hbD
    Causalean.PartialID.supportFn_inter_le · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:145
  • supportFn_translate theorem — Translation rule. Translating the set by x₀ shifts the support value by ⟪d, x₀⟫.
    C :
    Set E
    d :
    E
    x₀ :
    E
    hne :
    C.Nonempty
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    supportFn ((fun x => x₀ + x) '' C) d = ⟪d, x₀⟫ + supportFn C d
    Proof (Lean source)
    theorem supportFn_translate {C : Set E} {d : E} (x₀ : E) (hne : C.Nonempty) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) : supportFn ((fun x => x₀ + x) '' C) d = ⟪d, x₀⟫ + supportFn C d := by have hneT : ((fun x => x₀ + x) '' C).Nonempty := hne.image _ have hbT : BddAbove ((fun x => ⟪d, x⟫) '' ((fun x => x₀ + x) '' C)) := by obtain ⟨b, hb⟩ := hbdd refine ⟨⟪d, x₀⟫ + b, ?_⟩ rintro _ ⟨_, ⟨x, hx, rfl⟩, rfl⟩ simp only [inner_add_right] have hx' : ⟪d, x⟫ ≤ b := hb ⟨x, hx, rfl⟩ linarith refine le_antisymm ?_ ?_ · refine supportFn_le hneT (fun y hy => ?_) obtain ⟨x, hx, rfl⟩ := hy simp only [inner_add_right] have := le_supportFn hx hbdd linarith · have : supportFn C d ≤ supportFn ((fun x => x₀ + x) '' C) d - ⟪d, x₀⟫ := by refine supportFn_le hne (fun x hx => ?_) have hmem : x₀ + x ∈ (fun x => x₀ + x) '' C := ⟨x, hx, rfl⟩ have := le_supportFn hmem hbT rw [inner_add_right] at this linarith linarith
    Causalean.PartialID.supportFn_translate · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:155
  • supportFn_smul_set theorem — Positive scaling rule. Scaling the set by a ≥ 0 scales the support value by a.
    C :
    Set E
    d :
    E
    a :
    ha :
    0 ≤ a
    hne :
    C.Nonempty
    hbdd :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    supportFn (a • C) d = a * supportFn C d
    Proof (Lean source)
    theorem supportFn_smul_set {C : Set E} {d : E} {a : ℝ} (ha : 0 ≤ a) (hne : C.Nonempty) (hbdd : BddAbove ((fun x => ⟪d, x⟫) '' C)) : supportFn (a • C) d = a * supportFn C d := by have hsmul : (a • C : Set E) = (fun x => a • x) '' C := rfl rcases eq_or_lt_of_le ha with hz | hpos · -- a = 0: a • C = {0} over nonempty C subst hz obtain ⟨c, hc⟩ := hne have hset : ((0 : ℝ) • C : Set E) = {0} := by rw [hsmul] ext y simp only [Set.mem_image, zero_smul, Set.mem_singleton_iff] constructor · rintro ⟨x, _, rfl⟩; rfl · rintro rfl; exact ⟨c, hc, rfl⟩ rw [hset, zero_mul, supportFn_eq_iSup_image, Set.image_singleton, inner_zero_right, csSup_singleton] · -- 0 < a have hneS : (a • C : Set E).Nonempty := by rw [hsmul]; exact hne.image _ have hbS : BddAbove ((fun x => ⟪d, x⟫) '' (a • C : Set E)) := by obtain ⟨b, hb⟩ := hbdd refine ⟨a * b, ?_⟩ rw [hsmul] rintro _ ⟨_, ⟨x, hx, rfl⟩, rfl⟩ simp only [real_inner_smul_right] have hx' : ⟪d, x⟫ ≤ b := hb ⟨x, hx, rfl⟩ exact mul_le_mul_of_nonneg_left hx' ha refine le_antisymm ?_ ?_ · refine supportFn_le hneS (fun y hy => ?_) rw [hsmul] at hy obtain ⟨x, hx, rfl⟩ := hy simp only [real_inner_smul_right] exact mul_le_mul_of_nonneg_left (le_supportFn hx hbdd) ha · have : supportFn C d ≤ a⁻¹ * supportFn (a • C : Set E) d := by refine supportFn_le hne (fun x hx => ?_) have hmem : a • x ∈ (a • C : Set E) := by rw [hsmul]; exact ⟨x, hx, rfl⟩ have h1 := le_supportFn hmem hbS rw [real_inner_smul_right] at h1 have := mul_le_mul_of_nonneg_left h1 (le_of_lt (inv_pos.mpr hpos)) rwa [← mul_assoc, inv_mul_cancel₀ (ne_of_gt hpos), one_mul] at this have h2 := mul_le_mul_of_nonneg_left this ha rwa [← mul_assoc, mul_inv_cancel₀ (ne_of_gt hpos), one_mul] at h2
    Causalean.PartialID.supportFn_smul_set · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:182
  • supportFn_minkowski theorem — Minkowski additivity. The support function is additive over Minkowski sums: supportFn (C + D) d = supportFn C d + supportFn D d.
    C D :
    Set E
    d :
    E
    hC :
    C.Nonempty
    hD :
    D.Nonempty
    hbC :
    BddAbove ((fun x => ⟪d, x⟫) '' C)
    hbD :
    BddAbove ((fun x => ⟪d, x⟫) '' D)
    supportFn (C + D) d = supportFn C d + supportFn D d
    Proof (Lean source)
    theorem supportFn_minkowski {C D : Set E} {d : E} (hC : C.Nonempty) (hD : D.Nonempty) (hbC : BddAbove ((fun x => ⟪d, x⟫) '' C)) (hbD : BddAbove ((fun x => ⟪d, x⟫) '' D)) : supportFn (C + D) d = supportFn C d + supportFn D d := by have hneS : (C + D).Nonempty := hC.add hD have hbS : BddAbove ((fun x => ⟪d, x⟫) '' (C + D)) := by refine ⟨supportFn C d + supportFn D d, ?_⟩ rintro _ ⟨_, hy, rfl⟩ obtain ⟨c, hc, e, he, rfl⟩ := hy simp only [inner_add_right] exact add_le_add (le_supportFn hc hbC) (le_supportFn he hbD) refine le_antisymm ?_ ?_ · refine supportFn_le hneS (fun y hy => ?_) obtain ⟨c, hc, e, he, rfl⟩ := hy simp only [inner_add_right] exact add_le_add (le_supportFn hc hbC) (le_supportFn he hbD) · -- ≥ : for each c, ⟪d,c⟫ + supportFn D d ≤ supportFn (C+D) d have key : ∀ c ∈ C, ⟪d, c⟫ + supportFn D d ≤ supportFn (C + D) d := by intro c hc have : supportFn D d ≤ supportFn (C + D) d - ⟪d, c⟫ := by refine supportFn_le hD (fun e he => ?_) have hmem : c + e ∈ C + D := ⟨c, hc, e, he, rfl⟩ have h1 := le_supportFn hmem hbS rw [inner_add_right] at h1 linarith linarith have : supportFn C d ≤ supportFn (C + D) d - supportFn D d := by refine supportFn_le hC (fun c hc => ?_) have := key c hc linarith linarith
    Causalean.PartialID.supportFn_minkowski · Causalean/PO/ID/Partial/SupportFunction/Calculus.lean:229
Sensitivity 10 core · 8 supporting This file applies the support-function engine to sensitivity analysis with reweighted means. ★ robustUpper_singleton★ robustLower_singleton★ robustInterval_eq_image★ l2Ball_eq_translate★ supportFn_l2Ball_eq★ width_l2Ball_eq★ l2Ball_point_identified_iff

Support-function sensitivity models

This file applies the support-function engine to sensitivity analysis with reweighted means. It defines robust upper and lower bounds over ambiguity sets, records their monotonicity and singleton collapse properties, and computes the closed form for the chi-square/L2-ball relaxation.

def robustUpper reviewed
Causalean.PartialID

The upper robust bound of the reweighted mean ⟪c, ·⟫ over an ambiguity set W: the worst case from above, supportFn W c.

Definition (Lean source)
noncomputable def robustUpper (W : Set E) (c : E) : ℝ := supportFn W c
def robustLower reviewed
Causalean.PartialID

The lower robust bound of the reweighted mean ⟪c, ·⟫ over an ambiguity set W: the worst case from below, -supportFn W (-c).

Definition (Lean source)
noncomputable def robustLower (W : Set E) (c : E) : ℝ := -supportFn W (-c)
theorem robustUpper_singleton reviewed
Causalean.PartialID

No ambiguity implies point identification (upper). When the ambiguity set collapses to the singleton {w₀}, the upper robust bound for the linear functional c equals the identified value ⟪c, w₀⟫.

Formal statement
c w₀ :
E
robustUpper ({w₀} : Set E) c = ⟪c, w₀⟫
Proof (Lean source)
@[simp] theorem robustUpper_singleton (c w₀ : E) : robustUpper ({w₀} : Set E) c = ⟪c, w₀⟫ := by simp only [robustUpper, supportFn_singleton]
Causalean.PartialID.robustUpper_singleton · Causalean/PO/ID/Partial/SupportFunction/Sensitivity.lean:142 · uses robustUpper
theorem robustLower_singleton reviewed
Causalean.PartialID

No ambiguity implies point identification (lower). When the ambiguity set collapses to the singleton {w₀}, the lower robust bound for the linear functional c equals the identified value ⟪c, w₀⟫.

Formal statement
c w₀ :
E
robustLower ({w₀} : Set E) c = ⟪c, w₀⟫
Proof (Lean source)
@[simp] theorem robustLower_singleton (c w₀ : E) : robustLower ({w₀} : Set E) c = ⟪c, w₀⟫ := by simp only [robustLower, supportFn_singleton, inner_neg_left, neg_neg]
Causalean.PartialID.robustLower_singleton · Causalean/PO/ID/Partial/SupportFunction/Sensitivity.lean:149 · uses robustLower
theorem robustInterval_eq_image reviewed
Causalean.PartialID

The robust interval is the identified set. When the ambiguity set W is compact, convex, and nonempty, the set of reweighted means ⟪c, w⟫ attained as w ranges over W is exactly the closed interval [robustLower W c, robustUpper W c] — the robust bounds are sharp.

Formal statement
W :
Set E
c :
E
hcomp :
hW :
Convex ℝ W
hne :
W.Nonempty
(fun x => ⟪c, x⟫) '' W = Icc (robustLower W c) (robustUpper W c)
Proof (Lean source)
theorem robustInterval_eq_image {W : Set E} {c : E} (hcomp : IsCompact W) (hW : Convex ℝ W) (hne : W.Nonempty) : (fun x => ⟪c, x⟫) '' W = Icc (robustLower W c) (robustUpper W c) := linearImage_eq_Icc_of_isCompact hcomp hW hne
def l2Ball reviewed
Causalean.PartialID

The χ²/L² ambiguity set: weights normalized against the unit base direction e and within an L²-ball of radius ρ around it.

Definition (Lean source)
def l2Ball (e : H) (ρ : ℝ) : Set H := {w | ⟪e, w⟫ = 1 ∧ ‖w - e‖ ≤ ρ}
theorem l2Ball_eq_translate reviewed
Causalean.PartialID

Reduction to the affine-ball engine. When the base direction has unit inner product with itself, ⟪e, e⟫ = 1, the χ²/L² ambiguity set l2Ball e ρ equals the translate by e of the affine ball of radius ρ for the linear functional ⟪e, ·⟫ centered at the origin — the substitution v = w - e turns the normalization constraint ⟪e, w⟫ = 1 into the linear constraint ⟪e, v⟫ = 0.

Formal statement
e :
H
he :
⟪e, e⟫ = 1
ρ :
l2Ball e ρ = (fun v => e + v) '' affineBall (innerSL ℝ e) 0 ρ
Proof (Lean source)
theorem l2Ball_eq_translate {e : H} (he : ⟪e, e⟫ = 1) (ρ : ℝ) : l2Ball e ρ = (fun v => e + v) '' affineBall (innerSL ℝ e) 0 ρ := by ext w simp only [mem_l2Ball, Set.mem_image, mem_affineBall] constructor · rintro ⟨hmean, hnorm⟩ refine ⟨w - e, ⟨?_, ?_⟩, by abel⟩ · rw [innerSL_apply_apply, inner_sub_right, he, hmean, sub_self] · simpa using hnorm · rintro ⟨v, ⟨hv0, hvnorm⟩, rfl⟩ rw [innerSL_apply_apply] at hv0 refine ⟨?_, ?_⟩ · rw [inner_add_right, he, hv0, add_zero] · simpa using hvnorm
theorem supportFn_l2Ball_eq reviewed
Causalean.PartialID

Closed-form worst case (mean plus ρ·SD). For a unit-norm base direction e and a nonnegative radius ρ, the largest reweighted value ⟪c, w⟫ attains over the χ²/L² ambiguity set l2Ball e ρ equals ⟪e, c⟫ + ρ · √(‖c‖² − ⟪e, c⟫²) — the base-direction mean plus ρ standard deviations of c.

Formal statement
e :
H
he :
‖e‖ = 1
c :
H
ρ :
:
0 ≤ ρ
supportFn (l2Ball e ρ) c = ⟪e, c⟫ + ρ * sqrt (‖c‖ ^ 2 - ⟪e, c⟫ ^ 2)
Proof (Lean source)
theorem supportFn_l2Ball_eq {e : H} (he : ‖e‖ = 1) (c : H) {ρ : ℝ} (hρ : 0 ≤ ρ) : supportFn (l2Ball e ρ) c = ⟪e, c⟫ + ρ * sqrt (‖c‖ ^ 2 - ⟪e, c⟫ ^ 2) := by have hee : ⟪e, e⟫ = 1 := by rw [real_inner_self_eq_norm_mul_norm, he, mul_one] set A : H →L[ℝ] ℝ := innerSL ℝ e with hA have hsol : A 0 = 0 := map_zero A have hperp : (0 : H) ∈ (opKer A)ᗮ := Submodule.zero_mem _ have hfit : ‖(0 : H)‖ ≤ ρ := by simpa using hρ have hne : (affineBall A 0 ρ).Nonempty := ⟨0, hsol, hfit⟩ have hbdd : BddAbove ((fun x => ⟪c, x⟫) '' affineBall A 0 ρ) := by refine ⟨‖c‖ * ρ, ?_⟩ rintro _ ⟨h, hh, rfl⟩ calc ⟪c, h⟫ ≤ ‖c‖ * ‖h‖ := real_inner_le_norm c h _ ≤ ‖c‖ * ρ := mul_le_mul_of_nonneg_left hh.2 (norm_nonneg _) rw [l2Ball_eq_translate hee, supportFn_translate e hne hbdd, supportFn_affineBall_eq A hsol hperp hfit, norm_orthogonalProjection_opKer_innerSL he] rw [inner_zero_right, norm_zero, zero_add] rw [show (ρ : ℝ) ^ 2 - (0 : ℝ) ^ 2 = ρ ^ 2 by ring, Real.sqrt_sq hρ, real_inner_comm c e]
theorem width_l2Ball_eq reviewed
Causalean.PartialID

Closed-form width. For a unit-norm base direction e and a nonnegative radius ρ, the width of the χ²/L² robust interval for the target c equals 2ρ · √(‖c‖² − ⟪e, c⟫²), twice the radius times the standard deviation of c.

Formal statement
e :
H
he :
‖e‖ = 1
c :
H
ρ :
:
0 ≤ ρ
width (l2Ball e ρ) c = 2 * ρ * sqrt (‖c‖ ^ 2 - ⟪e, c⟫ ^ 2)
Proof (Lean source)
theorem width_l2Ball_eq {e : H} (he : ‖e‖ = 1) (c : H) {ρ : ℝ} (hρ : 0 ≤ ρ) : width (l2Ball e ρ) c = 2 * ρ * sqrt (‖c‖ ^ 2 - ⟪e, c⟫ ^ 2) := by unfold width rw [supportFn_l2Ball_eq he c hρ, supportFn_l2Ball_eq he (-c) hρ] rw [inner_neg_right, norm_neg] rw [show (-⟪e, c⟫) ^ 2 = ⟪e, c⟫ ^ 2 by ring] ring
theorem l2Ball_point_identified_iff reviewed
Causalean.PartialID

Point identification. For a unit-norm base direction e and a strictly positive radius ρ, the χ²/L² robust interval for the target c collapses to a single point exactly when ‖c‖² equals ⟪e, c⟫², i.e. when c is collinear with e — equivalently, equality holds in the Cauchy–Schwarz inequality, meaning the represented outcome is almost-surely constant.

Formal statement
e :
H
he :
‖e‖ = 1
c :
H
ρ :
:
0 < ρ
width (l2Ball e ρ) c = 0 ↔ ‖c‖ ^ 2 = ⟪e, c⟫ ^ 2
Proof (Lean source)
theorem l2Ball_point_identified_iff {e : H} (he : ‖e‖ = 1) (c : H) {ρ : ℝ} (hρ : 0 < ρ) : width (l2Ball e ρ) c = 0 ↔ ‖c‖ ^ 2 = ⟪e, c⟫ ^ 2 := by rw [width_l2Ball_eq he c (le_of_lt hρ)] -- Cauchy–Schwarz: ‖c‖² − ⟪e,c⟫² ≥ 0 under ‖e‖ = 1 have hge : (0 : ℝ) ≤ ‖c‖ ^ 2 - ⟪e, c⟫ ^ 2 := by have h := abs_real_inner_le_norm e c rw [he, one_mul] at h have : ⟪e, c⟫ ^ 2 ≤ ‖c‖ ^ 2 := by rw [← sq_abs ⟪e, c⟫]; nlinarith [abs_nonneg ⟪e, c⟫, norm_nonneg c, h] linarith rw [mul_eq_zero, mul_eq_zero] constructor · rintro ((h | h) | h) · norm_num at h · exact absurd h (ne_of_gt hρ) · have hle : ‖c‖ ^ 2 - ⟪e, c⟫ ^ 2 ≤ 0 := Real.sqrt_eq_zero'.mp h linarith · intro h right rw [show ‖c‖ ^ 2 - ⟪e, c⟫ ^ 2 = 0 by linarith, Real.sqrt_zero]
Causalean.PartialID.l2Ball_point_identified_iff · Causalean/PO/ID/Partial/SupportFunction/Sensitivity.lean:271 · uses l2Ball , width
8 supporting declarations (lemmas, instances)