PO.ID.Partial.SupportFunction
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.
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).
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
Proof (Lean source)
2 supporting declarations (lemmas, instances)
-
supportFn_eq_iSup_imagelemma — The support function is definitionally the supremum of the linear target over the set.Proof (Lean source)
lemma supportFn_eq_iSup_image (C : Set E) (d : E) : supportFn C d = sSup ((fun x => ⟪d, x⟫) '' C) := rfl -
supportFn_letheorem — Upper sandwich. A uniform upper bound b on the functional over a nonempty C bounds the support value: supportFn C d ≤ b.hypothesesconclusionsupportFn C d ≤ bProof (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.
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
Proof (Lean source)
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
Proof (Lean source)
The width of the identified set: supportFn C d + supportFn C (-d), i.e. the upper endpoint minus the lower endpoint.
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
Proof (Lean source)
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
Proof (Lean source)
4 supporting declarations (lemmas, instances)
-
neg_supportFn_neg_letheorem — 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, ·⟫.hypothesesconclusion-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 -
linearImage_subset_Icctheorem — Outer bound. The identified set of the linear target lies inside the support interval [-supportFn C (-d), supportFn C d].hypothesesProof (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⟩ -
linearImage_ordConnectedtheorem — Order-connectedness. The linear image of a convex set is convex in ℝ, hence order-connected: the identified set has "no gaps".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 -
width_nonnegtheorem — The identified width is nonnegative.hypothesesC :Set Ed :Ehne :C.Nonemptyhbdd :BddAbove ((fun x => ⟪d, x⟫) '' C)hbdd' :BddAbove ((fun x => ⟪-d, x⟫) '' C)conclusion0 ≤ width C dProof (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
AffineBall 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.
The free-direction subspace of a continuous operator: perturbations in ker A do not change the linear constraint A h = b.
The affine-ball fiber contains the solutions to a linear equation that also satisfy a norm bound.
Definition (Lean source)
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
Proof (Lean source)
Closed-form width of the affine-ball identified set. Under the same hypotheses as supportFn_affineBall_eq — h₀ solves A h₀ = b, h₀ is orthogonal to the kernel of A, and h₀'s norm is at most B — the 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
Proof (Lean source)
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
Proof (Lean source)
2 supporting declarations (lemmas, instances)
-
kerHasOrthogonalProjectioninstance — The free-direction subspace of a continuous linear map admits an orthogonal projection because the kernel is closed in a complete Hilbert space.instance kerHasOrthogonalProjection (A : H →L[ℝ] F) : (opKer A).HasOrthogonalProjection := by haveI := (ContinuousLinearMap.isClosed_ker A).completeSpace_coe infer_instance -
mem_affineBalltheorem — Membership in the affine-ball fiber is exactly satisfying the equation and the norm bound.Proof (Lean source)
@[simp] theorem mem_affineBall {A : H →L[ℝ] F} {b : F} {B : ℝ} {h : H} : h ∈ affineBall A b B ↔ A h = b ∧ ‖h‖ ≤ B := Iff.rfl
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.
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
Proof (Lean source)
9 supporting declarations (lemmas, instances)
-
supportFn_singletontheorem — Support function of a singleton is the functional value at the point.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] -
supportFn_nonneg_of_zero_memtheorem — If 0 ∈ C then the support value is nonnegative (the functional value 0 at the origin is a lower bound for the sup).hypothesesconclusion0 ≤ supportFn C dProof (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 -
supportFn_smul_dirtheorem — Positive homogeneity in the direction. For t ≥ 0, supportFn C (t • d) = t * supportFn C d.hypothesesProof (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] -
supportFn_monotheorem — Monotone in the set. If C ⊆ D (with C nonempty and the functional bounded above on D), then supportFn C d ≤ supportFn D d.hypothesesProof (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_uniontheorem — Union rule. The support function of a union is the maximum of the parts.hypothesesProof (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_letheorem — Intersection rule (one-sided). The support function of an intersection is at most the minimum of the parts.hypothesesProof (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 -
supportFn_translatetheorem — Translation rule. Translating the set by x₀ shifts the support value by ⟪d, x₀⟫.hypothesesProof (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 -
supportFn_smul_settheorem — Positive scaling rule. Scaling the set by a ≥ 0 scales the support value by a.hypothesesProof (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 -
supportFn_minkowskitheorem — Minkowski additivity. The support function is additive over Minkowski sums: supportFn (C + D) d = supportFn C d + supportFn D d.hypothesesProof (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
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.
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)
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)
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
Proof (Lean source)
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
Proof (Lean source)
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
Proof (Lean source)
The χ²/L² ambiguity set: weights normalized against the unit base direction e and within an L²-ball of radius ρ around it.
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
Proof (Lean source)
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
Proof (Lean source)
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
Proof (Lean source)
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
Proof (Lean source)
8 supporting declarations (lemmas, instances)
-
robustLower_le_robustUppertheorem — The robust interval [robustLower, robustUpper] is well-ordered under the usual boundedness conditions: its width is width W c ≥ 0.hypothesesW :Set Ec :Ehne :W.Nonemptyhbdd :BddAbove ((fun x => ⟪c, x⟫) '' W)hbdd' :BddAbove ((fun x => ⟪-c, x⟫) '' W)conclusionrobustLower W c ≤ robustUpper W cProof (Lean source)
theorem robustLower_le_robustUpper {W : Set E} {c : E} (hne : W.Nonempty) (hbdd : BddAbove ((fun x => ⟪c, x⟫) '' W)) (hbdd' : BddAbove ((fun x => ⟪-c, x⟫) '' W)) : robustLower W c ≤ robustUpper W c := by have hw := width_nonneg hne hbdd hbdd' simp only [robustLower, robustUpper, width] at * linarith -
le_robustUppertheorem — Any admissible weight has a reweighted mean no larger than the upper robust bound.hypothesesconclusion⟪c, w⟫ ≤ robustUpper W cProof (Lean source)
theorem le_robustUpper {W : Set E} {c : E} {w : E} (hw : w ∈ W) (hbdd : BddAbove ((fun x => ⟪c, x⟫) '' W)) : ⟪c, w⟫ ≤ robustUpper W c := le_supportFn hw hbdd -
robustLower_letheorem — Any admissible weight has a reweighted mean no smaller than the lower robust bound.hypothesesconclusionrobustLower W c ≤ ⟪c, w⟫Proof (Lean source)
theorem robustLower_le {W : Set E} {c : E} {w : E} (hw : w ∈ W) (hbdd' : BddAbove ((fun x => ⟪-c, x⟫) '' W)) : robustLower W c ≤ ⟪c, w⟫ := neg_supportFn_neg_le hw hbdd' -
robustUpper_monotheorem — Monotonicity in the budget (upper). A larger ambiguity set raises the upper robust bound.hypothesesconclusionrobustUpper W c ≤ robustUpper W' cProof (Lean source)
theorem robustUpper_mono {W W' : Set E} {c : E} (hWW' : W ⊆ W') (hne : W.Nonempty) (hbdd : BddAbove ((fun x => ⟪c, x⟫) '' W')) : robustUpper W c ≤ robustUpper W' c := supportFn_mono hWW' hne hbdd -
robustLower_antitonetheorem — Monotonicity in the budget (lower). A larger ambiguity set lowers the lower robust bound, so the robust interval widens.hypothesesconclusionrobustLower W' c ≤ robustLower W cProof (Lean source)
theorem robustLower_antitone {W W' : Set E} {c : E} (hWW' : W ⊆ W') (hne : W.Nonempty) (hbdd' : BddAbove ((fun x => ⟪-c, x⟫) '' W')) : robustLower W' c ≤ robustLower W c := by have h := supportFn_mono (d := -c) hWW' hne hbdd' simp only [robustLower] linarith -
mem_l2Balltheorem — Membership in the chi-square or L2 ambiguity set is exactly normalization and the radius bound.Proof (Lean source)
@[simp] theorem mem_l2Ball {e : H} {ρ : ℝ} {w : H} : w ∈ l2Ball e ρ ↔ ⟪e, w⟫ = 1 ∧ ‖w - e‖ ≤ ρ := Iff.rfl -
opKer_innerSL_eqtheorem — The free-direction kernel for normalization against the base direction is its orthogonal complement: ker (innerSL ℝ e) = (ℝ ∙ e)ᗮ.Proof (Lean source)
theorem opKer_innerSL_eq (e : H) : opKer (innerSL ℝ e) = (ℝ ∙ e)ᗮ := by ext x rw [opKer, LinearMap.mem_ker, Submodule.mem_orthogonal_singleton_iff_inner_right, ContinuousLinearMap.coe_coe, innerSL_apply_apply] -
norm_orthogonalProjection_opKer_innerSLtheorem — The norm of the free-direction projection equals the standard deviation √(‖c‖² − ⟪e,c⟫²) under ‖e‖ = 1.Proof (Lean source)
theorem norm_orthogonalProjection_opKer_innerSL {e : H} (he : ‖e‖ = 1) (c : H) : ‖(orthogonalProjection (opKer (innerSL ℝ e)) c : H)‖ = sqrt (‖c‖ ^ 2 - ⟪e, c⟫ ^ 2) := by have hcong : ∀ {K K' : Submodule ℝ H} [K.HasOrthogonalProjection] [K'.HasOrthogonalProjection], K = K' → (K.orthogonalProjection c : H) = (K'.orthogonalProjection c : H) := by intro K K' _ _ h; subst h; rfl rw [hcong (opKer_innerSL_eq e)] have hdec := Submodule.norm_sq_eq_add_norm_sq_projection c (ℝ ∙ e) -- the parallel component has norm |⟪e,c⟫| have hpar : ((ℝ ∙ e).orthogonalProjection c : H) = ⟪e, c⟫ • e := by rw [← Submodule.starProjection_apply, Submodule.starProjection_singleton ℝ, he] simp have hpar_sq : ‖((ℝ ∙ e).orthogonalProjection c : H)‖ ^ 2 = ⟪e, c⟫ ^ 2 := by rw [hpar, norm_smul, he, mul_one, Real.norm_eq_abs, ← sq_abs ⟪e, c⟫] -- the perpendicular component squared have hperp_sq : ‖((ℝ ∙ e)ᗮ.orthogonalProjection c : H)‖ ^ 2 = ‖c‖ ^ 2 - ⟪e, c⟫ ^ 2 := by have h1 : ‖(c : H)‖ ^ 2 = ‖((ℝ ∙ e).orthogonalProjection c : H)‖ ^ 2 + ‖((ℝ ∙ e)ᗮ.orthogonalProjection c : H)‖ ^ 2 := hdec rw [hpar_sq] at h1 linarith rw [← Real.sqrt_sq (norm_nonneg _), hperp_sq]