File: Mathlib/Analysis/Convex/Exposed.lean

full_name: IsExposed
code: /-- A set `B` is exposed with respect to `A` iff it maximizes some functional over `A` (and contains
all points maximizing it). Written `IsExposed 𝕜 A B`. -/
def IsExposed (A B : Set E) : Prop 
goal: Prop

full_name: ContinuousLinearMap.toExposed
code: /-- A useful way to build exposed sets from intersecting `A` with halfspaces (modelled by an
inequality with a functional). -/
def ContinuousLinearMap.toExposed (l : E →L[𝕜] 𝕜) (A : Set E) : Set E 
goal: Set E

full_name: ContinuousLinearMap.toExposed.isExposed
code: theorem ContinuousLinearMap.toExposed.isExposed : IsExposed 𝕜 A (l.toExposed A) 
goal: IsExposed 𝕜 A (l.toExposed A)

full_name: isExposed_empty
code: theorem isExposed_empty : IsExposed 𝕜 A ∅ 
goal: IsExposed 𝕜 A ∅

full_name: IsExposed.subset
code: protected theorem subset (hAB : IsExposed 𝕜 A B) : B ⊆ A 
goal: B ⊆ A

full_name: IsExposed.refl
code: @[refl]
protected theorem refl (A : Set E) : IsExposed 𝕜 A A 
goal: IsExposed 𝕜 A A

full_name: IsExposed.antisymm
code: protected theorem antisymm (hB : IsExposed 𝕜 A B) (hA : IsExposed 𝕜 B A) : A = B 
goal: A = B

full_name: IsExposed.mono
code: protected theorem mono (hC : IsExposed 𝕜 A C) (hBA : B ⊆ A) (hCB : C ⊆ B) : IsExposed 𝕜 B C 
goal: IsExposed 𝕜 B C

full_name: IsExposed.eq_inter_halfspace'
code: /-- If `B` is a nonempty exposed subset of `A`, then `B` is the intersection of `A` with some closed
halfspace. The converse is *not* true. It would require that the corresponding open halfspace
doesn't intersect `A`. -/
theorem eq_inter_halfspace' {A B : Set E} (hAB : IsExposed 𝕜 A B) (hB : B.Nonempty) :
    ∃ l : E →L[𝕜] 𝕜, ∃ a, B = { x ∈ A | a ≤ l x } 
goal: ∃ l a, B = {x | x ∈ A ∧ a ≤ l x}

full_name: IsExposed.eq_inter_halfspace
code: /-- For nontrivial `𝕜`, if `B` is an exposed subset of `A`, then `B` is the intersection of `A` with
some closed halfspace. The converse is *not* true. It would require that the corresponding open
halfspace doesn't intersect `A`. -/
theorem eq_inter_halfspace [Nontrivial 𝕜] {A B : Set E} (hAB : IsExposed 𝕜 A B) :
    ∃ l : E →L[𝕜] 𝕜, ∃ a, B = { x ∈ A | a ≤ l x } 
goal: ∃ l a, B = {x | x ∈ A ∧ a ≤ l x}

full_name: IsExposed.inter
code: protected theorem inter [ContinuousAdd 𝕜] {A B C : Set E} (hB : IsExposed 𝕜 A B)
    (hC : IsExposed 𝕜 A C) : IsExposed 𝕜 A (B ∩ C) 
goal: IsExposed 𝕜 A (B ∩ C)

full_name: IsExposed.sInter
code: theorem sInter [ContinuousAdd 𝕜] {F : Finset (Set E)} (hF : F.Nonempty)
    (hAF : ∀ B ∈ F, IsExposed 𝕜 A B) : IsExposed 𝕜 A (⋂₀ F) 
goal: IsExposed 𝕜 A (⋂₀ ↑F)

full_name: IsExposed.inter_left
code: theorem inter_left (hC : IsExposed 𝕜 A C) (hCB : C ⊆ B) : IsExposed 𝕜 (A ∩ B) C 
goal: IsExposed 𝕜 (A ∩ B) C

full_name: IsExposed.inter_right
code: theorem inter_right (hC : IsExposed 𝕜 B C) (hCA : C ⊆ A) : IsExposed 𝕜 (A ∩ B) C 
goal: IsExposed 𝕜 (A ∩ B) C

full_name: IsExposed.isClosed
code: protected theorem isClosed [OrderClosedTopology 𝕜] {A B : Set E} (hAB : IsExposed 𝕜 A B)
    (hA : IsClosed A) : IsClosed B 
goal: IsClosed B

full_name: IsExposed.isCompact
code: protected theorem isCompact [OrderClosedTopology 𝕜] [T2Space E] {A B : Set E}
    (hAB : IsExposed 𝕜 A B) (hA : IsCompact A) : IsCompact B 
goal: IsCompact B

full_name: Set.exposedPoints
code: /-- A point is exposed with respect to `A` iff there exists a hyperplane whose intersection with
`A` is exactly that point. -/
def Set.exposedPoints (A : Set E) : Set E 
goal: Set E

full_name: exposed_point_def
code: theorem exposed_point_def :
    x ∈ A.exposedPoints 𝕜 ↔ x ∈ A ∧ ∃ l : E →L[𝕜] 𝕜, ∀ y ∈ A, l y ≤ l x ∧ (l x ≤ l y → y = x) 
goal: x ∈ Set.exposedPoints 𝕜 A ↔ x ∈ A ∧ ∃ l, ∀ y ∈ A, l y ≤ l x ∧ (l x ≤ l y → y = x)

full_name: exposedPoints_subset
code: theorem exposedPoints_subset : A.exposedPoints 𝕜 ⊆ A 
goal: Set.exposedPoints 𝕜 A ⊆ A

full_name: exposedPoints_empty
code: @[simp]
theorem exposedPoints_empty : (∅ : Set E).exposedPoints 𝕜 = ∅ 
goal: Set.exposedPoints 𝕜 ∅ = ∅

full_name: mem_exposedPoints_iff_exposed_singleton
code: /-- Exposed points exactly correspond to exposed singletons. -/
theorem mem_exposedPoints_iff_exposed_singleton : x ∈ A.exposedPoints 𝕜 ↔ IsExposed 𝕜 A {x} 
goal: x ∈ Set.exposedPoints 𝕜 A ↔ IsExposed 𝕜 A {x}

full_name: IsExposed.convex
code: protected theorem convex (hAB : IsExposed 𝕜 A B) (hA : Convex 𝕜 A) : Convex 𝕜 B 
goal: Convex 𝕜 B

full_name: IsExposed.isExtreme
code: protected theorem isExtreme (hAB : IsExposed 𝕜 A B) : IsExtreme 𝕜 A B 
goal: IsExtreme 𝕜 A B

full_name: exposedPoints_subset_extremePoints
code: theorem exposedPoints_subset_extremePoints : A.exposedPoints 𝕜 ⊆ A.extremePoints 𝕜 
goal: Set.exposedPoints 𝕜 A ⊆ Set.extremePoints 𝕜 A