File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

full_name: balancedCore
code: /-- The largest balanced subset of `s`. -/
def balancedCore (s : Set E) 
goal: Set E

full_name: balancedCoreAux
code: /-- Helper definition to prove `balanced_core_eq_iInter`-/
def balancedCoreAux (s : Set E) 
goal: Set E

full_name: balancedHull
code: /-- The smallest balanced superset of `s`. -/
def balancedHull (s : Set E) 
goal: Set E

full_name: balancedCore_subset
code: theorem balancedCore_subset (s : Set E) : balancedCore 𝕜 s ⊆ s 
goal: balancedCore 𝕜 s ⊆ s

full_name: balancedCore_empty
code: theorem balancedCore_empty : balancedCore 𝕜 (∅ : Set E) = ∅ 
goal: balancedCore 𝕜 ∅ = ∅

full_name: mem_balancedCore_iff
code: theorem mem_balancedCore_iff : x ∈ balancedCore 𝕜 s ↔ ∃ t, Balanced 𝕜 t ∧ t ⊆ s ∧ x ∈ t 
goal: x ∈ balancedCore 𝕜 s ↔ ∃ t, Balanced 𝕜 t ∧ t ⊆ s ∧ x ∈ t

full_name: smul_balancedCore_subset
code: theorem smul_balancedCore_subset (s : Set E) {a : 𝕜} (ha : ‖a‖ ≤ 1) :
    a • balancedCore 𝕜 s ⊆ balancedCore 𝕜 s 
goal: a • balancedCore 𝕜 s ⊆ balancedCore 𝕜 s

full_name: balancedCore_balanced
code: theorem balancedCore_balanced (s : Set E) : Balanced 𝕜 (balancedCore 𝕜 s) 
goal: Balanced 𝕜 (balancedCore 𝕜 s)

full_name: Balanced.subset_balancedCore_of_subset
code: /-- The balanced core of `t` is maximal in the sense that it contains any balanced subset
`s` of `t`. -/
theorem Balanced.subset_balancedCore_of_subset (hs : Balanced 𝕜 s) (h : s ⊆ t) :
    s ⊆ balancedCore 𝕜 t 
goal: s ⊆ balancedCore 𝕜 t

full_name: mem_balancedCoreAux_iff
code: theorem mem_balancedCoreAux_iff : x ∈ balancedCoreAux 𝕜 s ↔ ∀ r : 𝕜, 1 ≤ ‖r‖ → x ∈ r • s 
goal: x ∈ balancedCoreAux 𝕜 s ↔ ∀ (r : 𝕜), 1 ≤ ‖r‖ → x ∈ r • s

full_name: mem_balancedHull_iff
code: theorem mem_balancedHull_iff : x ∈ balancedHull 𝕜 s ↔ ∃ r : 𝕜, ‖r‖ ≤ 1 ∧ x ∈ r • s 
goal: x ∈ balancedHull 𝕜 s ↔ ∃ r, ‖r‖ ≤ 1 ∧ x ∈ r • s

full_name: Balanced.balancedHull_subset_of_subset
code: /-- The balanced hull of `s` is minimal in the sense that it is contained in any balanced superset
`t` of `s`. -/
theorem Balanced.balancedHull_subset_of_subset (ht : Balanced 𝕜 t) (h : s ⊆ t) :
    balancedHull 𝕜 s ⊆ t 
goal: balancedHull 𝕜 s ⊆ t

full_name: balancedCore_zero_mem
code: theorem balancedCore_zero_mem (hs : (0 : E) ∈ s) : (0 : E) ∈ balancedCore 𝕜 s 
goal: 0 ∈ balancedCore 𝕜 s

full_name: balancedCore_nonempty_iff
code: theorem balancedCore_nonempty_iff : (balancedCore 𝕜 s).Nonempty ↔ (0 : E) ∈ s 
goal: (balancedCore 𝕜 s).Nonempty ↔ 0 ∈ s

full_name: subset_balancedHull
code: theorem subset_balancedHull [NormOneClass 𝕜] {s : Set E} : s ⊆ balancedHull 𝕜 s 
goal: s ⊆ balancedHull 𝕜 s

full_name: balancedHull.balanced
code: theorem balancedHull.balanced (s : Set E) : Balanced 𝕜 (balancedHull 𝕜 s) 
goal: Balanced 𝕜 (balancedHull 𝕜 s)

full_name: balancedCoreAux_empty
code: @[simp]
theorem balancedCoreAux_empty : balancedCoreAux 𝕜 (∅ : Set E) = ∅ 
goal: balancedCoreAux 𝕜 ∅ = ∅

full_name: balancedCoreAux_subset
code: theorem balancedCoreAux_subset (s : Set E) : balancedCoreAux 𝕜 s ⊆ s 
goal: balancedCoreAux 𝕜 s ⊆ s

full_name: balancedCoreAux_balanced
code: theorem balancedCoreAux_balanced (h0 : (0 : E) ∈ balancedCoreAux 𝕜 s) :
    Balanced 𝕜 (balancedCoreAux 𝕜 s) 
goal: Balanced 𝕜 (balancedCoreAux 𝕜 s)

full_name: balancedCoreAux_maximal
code: theorem balancedCoreAux_maximal (h : t ⊆ s) (ht : Balanced 𝕜 t) : t ⊆ balancedCoreAux 𝕜 s 
goal: t ⊆ balancedCoreAux 𝕜 s

full_name: balancedCore_subset_balancedCoreAux
code: theorem balancedCore_subset_balancedCoreAux : balancedCore 𝕜 s ⊆ balancedCoreAux 𝕜 s 
goal: balancedCore 𝕜 s ⊆ balancedCoreAux 𝕜 s

full_name: balancedCore_eq_iInter
code: theorem balancedCore_eq_iInter (hs : (0 : E) ∈ s) :
    balancedCore 𝕜 s = ⋂ (r : 𝕜) (_ : 1 ≤ ‖r‖), r • s 
goal: balancedCore 𝕜 s = ⋂ r, ⋂ (_ : 1 ≤ ‖r‖), r • s

full_name: subset_balancedCore
code: theorem subset_balancedCore (ht : (0 : E) ∈ t) (hst : ∀ a : 𝕜, ‖a‖ ≤ 1 → a • s ⊆ t) :
    s ⊆ balancedCore 𝕜 t 
goal: s ⊆ balancedCore 𝕜 t

full_name: IsClosed.balancedCore
code: protected theorem IsClosed.balancedCore (hU : IsClosed U) : IsClosed (balancedCore 𝕜 U) 
goal: IsClosed (balancedCore 𝕜 U)

full_name: balancedCore_mem_nhds_zero
code: theorem balancedCore_mem_nhds_zero (hU : U ∈ 𝓝 (0 : E)) : balancedCore 𝕜 U ∈ 𝓝 (0 : E) 
goal: balancedCore 𝕜 U ∈ 𝓝 0

full_name: nhds_basis_balanced
code: theorem nhds_basis_balanced :
    (𝓝 (0 : E)).HasBasis (fun s : Set E => s ∈ 𝓝 (0 : E) ∧ Balanced 𝕜 s) id 
goal: (𝓝 0).HasBasis (fun s => s ∈ 𝓝 0 ∧ Balanced 𝕜 s) id

full_name: nhds_basis_closed_balanced
code: theorem nhds_basis_closed_balanced [RegularSpace E] :
    (𝓝 (0 : E)).HasBasis (fun s : Set E => s ∈ 𝓝 (0 : E) ∧ IsClosed s ∧ Balanced 𝕜 s) id 
goal: (𝓝 0).HasBasis (fun s => s ∈ 𝓝 0 ∧ IsClosed s ∧ Balanced 𝕜 s) id