File: Mathlib/Topology/Bornology/Basic.lean

full_name: Bornology.le_cofinite'
code: /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
Such spaces are equivalently specified by their bounded sets, see `Bornology.ofBounded`
and `Bornology.ext_iff_isBounded`-/
class Bornology (α : Type*) where
  /-- The filter of cobounded sets in a bornology. This is a field of the structure, but one
  should always prefer `Bornology.cobounded` because it makes the `α` argument explicit. -/
  cobounded' : Filter α
  /-- The cobounded filter in a bornology is smaller than the cofinite filter. This is a field of
  the structure, but one should always prefer `Bornology.le_cofinite` because it makes the `α`
  argument explicit. -/
  le_cofinite' : cobounded' ≤ cofinite
goal: Bornology.cobounded' ≤ Filter.cofinite

full_name: Bornology
code: /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
Such spaces are equivalently specified by their bounded sets, see `Bornology.ofBounded`
and `Bornology.ext_iff_isBounded`-/
class Bornology (α : Type*) where
  /-- The filter of cobounded sets in a bornology. This is a field of the structure, but one
  should always prefer `Bornology.cobounded` because it makes the `α` argument explicit. -/
  cobounded' : Filter α
  /-- The cobounded filter in a bornology is smaller than the cofinite filter. This is a field of
  the structure, but one should always prefer `Bornology.le_cofinite` because it makes the `α`
  argument explicit. -/
  le_cofinite' : cobounded' ≤ cofinite
goal: Type u_4

full_name: Bornology.cobounded'
code: /-- A **bornology** on a type `α` is a filter of cobounded sets which contains the cofinite filter.
Such spaces are equivalently specified by their bounded sets, see `Bornology.ofBounded`
and `Bornology.ext_iff_isBounded`-/
class Bornology (α : Type*) where
  /-- The filter of cobounded sets in a bornology. This is a field of the structure, but one
  should always prefer `Bornology.cobounded` because it makes the `α` argument explicit. -/
  cobounded' : Filter α
  /-- The cobounded filter in a bornology is smaller than the cofinite filter. This is a field of
  the structure, but one should always prefer `Bornology.le_cofinite` because it makes the `α`
  argument explicit. -/
  le_cofinite' : cobounded' ≤ cofinite
goal: Filter α

full_name: Bornology.cobounded
code: /-- The filter of cobounded sets in a bornology. -/
def Bornology.cobounded (α : Type*) [Bornology α] : Filter α 
goal: Filter α

full_name: Bornology.le_cofinite
code: lemma Bornology.le_cofinite (α : Type*) [Bornology α] : cobounded α ≤ cofinite 
goal: Bornology.cobounded α ≤ Filter.cofinite

full_name: Bornology.ext
code: @[ext]
lemma Bornology.ext (t t' : Bornology α)
    (h_cobounded : @Bornology.cobounded α t = @Bornology.cobounded α t') :
    t = t' 
goal: t = t'

full_name: Bornology.ext_iff
code: lemma Bornology.ext_iff (t t' : Bornology α) :
    t = t' ↔ @Bornology.cobounded α t = @Bornology.cobounded α t' 
goal: t = t' ↔ Bornology.cobounded α = Bornology.cobounded α

full_name: Bornology.ofBounded
code: /-- A constructor for bornologies by specifying the bounded sets,
and showing that they satisfy the appropriate conditions. -/
@[simps]
def Bornology.ofBounded {α : Type*} (B : Set (Set α))
    (empty_mem : ∅ ∈ B)
    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
    (singleton_mem : ∀ x, {x} ∈ B) : Bornology α 
goal: Bornology α

full_name: Bornology.ofBounded_cobounded
code: /-- A constructor for bornologies by specifying the bounded sets,
and showing that they satisfy the appropriate conditions. -/
@[simps]
def Bornology.ofBounded {α : Type*} (B : Set (Set α))
    (empty_mem : ∅ ∈ B)
    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
    (singleton_mem : ∀ x, {x} ∈ B) : Bornology α 
goal: Bornology.cobounded α = Filter.comk (fun x => x ∈ B) empty_mem subset_mem union_mem

full_name: Bornology.ofBounded'_cobounded
code: /-- A constructor for bornologies by specifying the bounded sets,
and showing that they satisfy the appropriate conditions. -/
@[simps! cobounded]
def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
    (empty_mem : ∅ ∈ B)
    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
    (sUnion_univ : ⋃₀ B = univ) :
    Bornology α 
goal: Bornology.cobounded α = Filter.comk (fun x => x ∈ B) empty_mem subset_mem union_mem

full_name: Bornology.ofBounded'
code: /-- A constructor for bornologies by specifying the bounded sets,
and showing that they satisfy the appropriate conditions. -/
@[simps! cobounded]
def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
    (empty_mem : ∅ ∈ B)
    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
    (sUnion_univ : ⋃₀ B = univ) :
    Bornology α 
goal: Bornology α

full_name: Bornology.IsCobounded
code: /-- `IsCobounded` is the predicate that `s` is in the filter of cobounded sets in the ambient
bornology on `α` -/
def IsCobounded [Bornology α] (s : Set α) : Prop 
goal: Prop

full_name: Bornology.IsBounded
code: /-- `IsBounded` is the predicate that `s` is bounded relative to the ambient bornology on `α`. -/
def IsBounded [Bornology α] (s : Set α) : Prop 
goal: Prop

full_name: Bornology.isCobounded_def
code: theorem isCobounded_def {s : Set α} : IsCobounded s ↔ s ∈ cobounded α 
goal: ∀ {x : Bornology α} {s : Set α}, Bornology.IsCobounded s ↔ s ∈ Bornology.cobounded α

full_name: Bornology.isBounded_def
code: theorem isBounded_def {s : Set α} : IsBounded s ↔ sᶜ ∈ cobounded α 
goal: ∀ {x : Bornology α} {s : Set α}, Bornology.IsBounded s ↔ sᶜ ∈ Bornology.cobounded α

full_name: Bornology.isBounded_compl_iff
code: @[simp]
theorem isBounded_compl_iff : IsBounded sᶜ ↔ IsCobounded s 
goal: ∀ {x : Bornology α} {s : Set α}, Bornology.IsBounded sᶜ ↔ Bornology.IsCobounded s

full_name: Bornology.isCobounded_compl_iff
code: @[simp]
theorem isCobounded_compl_iff : IsCobounded sᶜ ↔ IsBounded s 
goal: ∀ {x : Bornology α} {s : Set α}, Bornology.IsCobounded sᶜ ↔ Bornology.IsBounded s

full_name: Bornology.isBounded_empty
code: @[simp]
theorem isBounded_empty : IsBounded (∅ : Set α) 
goal: ∀ {x : Bornology α}, Bornology.IsBounded ∅

full_name: Bornology.nonempty_of_not_isBounded
code: theorem nonempty_of_not_isBounded (h : ¬IsBounded s) : s.Nonempty 
goal: ∀ {x : Bornology α} {s : Set α}, ¬Bornology.IsBounded s → s.Nonempty

full_name: Bornology.isBounded_singleton
code: @[simp]
theorem isBounded_singleton : IsBounded ({x} : Set α) 
goal: ∀ {x : Bornology α} {x_1 : α}, Bornology.IsBounded {x_1}

full_name: Bornology.isBounded_iff_forall_mem
code: theorem isBounded_iff_forall_mem : IsBounded s ↔ ∀ x ∈ s, IsBounded s 
goal: ∀ {x : Bornology α} {s : Set α}, Bornology.IsBounded s ↔ ∀ x_1 ∈ s, Bornology.IsBounded s

full_name: Bornology.isCobounded_univ
code: @[simp]
theorem isCobounded_univ : IsCobounded (univ : Set α) 
goal: ∀ {x : Bornology α}, Bornology.IsCobounded Set.univ

full_name: Bornology.isCobounded_inter
code: @[simp]
theorem isCobounded_inter : IsCobounded (s ∩ t) ↔ IsCobounded s ∧ IsCobounded t 
goal: ∀ {x : Bornology α} {s t : Set α}, Bornology.IsCobounded (s ∩ t) ↔ Bornology.IsCobounded s ∧ Bornology.IsCobounded t

full_name: Bornology.IsCobounded.inter
code: theorem IsCobounded.inter (hs : IsCobounded s) (ht : IsCobounded t) : IsCobounded (s ∩ t) 
goal: ∀ {x : Bornology α} {s t : Set α}, Bornology.IsCobounded s → Bornology.IsCobounded t → Bornology.IsCobounded (s ∩ t)

full_name: Bornology.isBounded_union
code: @[simp]
theorem isBounded_union : IsBounded (s ∪ t) ↔ IsBounded s ∧ IsBounded t 
goal: ∀ {x : Bornology α} {s t : Set α}, Bornology.IsBounded (s ∪ t) ↔ Bornology.IsBounded s ∧ Bornology.IsBounded t

full_name: Bornology.IsBounded.union
code: theorem IsBounded.union (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ∪ t) 
goal: ∀ {x : Bornology α} {s t : Set α}, Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s ∪ t)

full_name: Bornology.IsCobounded.superset
code: theorem IsCobounded.superset (hs : IsCobounded s) (ht : s ⊆ t) : IsCobounded t 
goal: ∀ {x : Bornology α} {s t : Set α}, Bornology.IsCobounded s → s ⊆ t → Bornology.IsCobounded t

full_name: Bornology.IsBounded.subset
code: theorem IsBounded.subset (ht : IsBounded t) (hs : s ⊆ t) : IsBounded s 
goal: ∀ {x : Bornology α} {s t : Set α}, Bornology.IsBounded t → s ⊆ t → Bornology.IsBounded s

full_name: Bornology.sUnion_bounded_univ
code: @[simp]
theorem sUnion_bounded_univ : ⋃₀ { s : Set α | IsBounded s } = univ 
goal: ∀ {x : Bornology α}, ⋃₀ {s | Bornology.IsBounded s} = Set.univ

full_name: Bornology.IsBounded.insert
code: theorem IsBounded.insert (h : IsBounded s) (x : α) : IsBounded (insert x s) 
goal: ∀ {x : Bornology α} {s : Set α}, Bornology.IsBounded s → ∀ (x_1 : α), Bornology.IsBounded (insert x_1 s)

full_name: Bornology.isBounded_insert
code: @[simp]
theorem isBounded_insert : IsBounded (insert x s) ↔ IsBounded s 
goal: ∀ {x : Bornology α} {s : Set α} {x_1 : α}, Bornology.IsBounded (insert x_1 s) ↔ Bornology.IsBounded s

full_name: Bornology.comap_cobounded_le_iff
code: theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
    (cobounded β).comap f ≤ cobounded α ↔ ∀ ⦃s⦄, IsBounded s → IsBounded (f '' s) 
goal: ∀ {x : Bornology α} [inst : Bornology β] {f : α → β},
  Filter.comap f (Bornology.cobounded β) ≤ Bornology.cobounded α ↔
    ∀ ⦃s : Set α⦄, Bornology.IsBounded s → Bornology.IsBounded (f '' s)

full_name: Bornology.ext_iff'
code: theorem ext_iff' {t t' : Bornology α} :
    t = t' ↔ ∀ s, s ∈ @cobounded α t ↔ s ∈ @cobounded α t' 
goal: t = t' ↔ ∀ (s : Set α), s ∈ Bornology.cobounded α ↔ s ∈ Bornology.cobounded α

full_name: Bornology.ext_iff_isBounded
code: theorem ext_iff_isBounded {t t' : Bornology α} :
    t = t' ↔ ∀ s, @IsBounded α t s ↔ @IsBounded α t' s 
goal: t = t' ↔ ∀ (s : Set α), Bornology.IsBounded s ↔ Bornology.IsBounded s

full_name: Bornology.isCobounded_ofBounded_iff
code: theorem isCobounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
    @IsCobounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ sᶜ ∈ B 
goal: Bornology.IsCobounded s ↔ sᶜ ∈ B

full_name: Bornology.isBounded_ofBounded_iff
code: theorem isBounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
    @IsBounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ s ∈ B 
goal: Bornology.IsBounded s ↔ s ∈ B

full_name: Bornology.isCobounded_biInter
code: theorem isCobounded_biInter {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
    IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) 
goal: Bornology.IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, Bornology.IsCobounded (f i)

full_name: Bornology.isCobounded_biInter_finset
code: @[simp]
theorem isCobounded_biInter_finset (s : Finset ι) {f : ι → Set α} :
    IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, IsCobounded (f i) 
goal: Bornology.IsCobounded (⋂ i ∈ s, f i) ↔ ∀ i ∈ s, Bornology.IsCobounded (f i)

full_name: Bornology.isCobounded_iInter
code: @[simp]
theorem isCobounded_iInter [Finite ι] {f : ι → Set α} :
    IsCobounded (⋂ i, f i) ↔ ∀ i, IsCobounded (f i) 
goal: Bornology.IsCobounded (⋂ i, f i) ↔ ∀ (i : ι), Bornology.IsCobounded (f i)

full_name: Bornology.isCobounded_sInter
code: theorem isCobounded_sInter {S : Set (Set α)} (hs : S.Finite) :
    IsCobounded (⋂₀ S) ↔ ∀ s ∈ S, IsCobounded s 
goal: Bornology.IsCobounded (⋂₀ S) ↔ ∀ s ∈ S, Bornology.IsCobounded s

full_name: Bornology.isBounded_biUnion
code: theorem isBounded_biUnion {s : Set ι} {f : ι → Set α} (hs : s.Finite) :
    IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) 
goal: Bornology.IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, Bornology.IsBounded (f i)

full_name: Bornology.isBounded_biUnion_finset
code: theorem isBounded_biUnion_finset (s : Finset ι) {f : ι → Set α} :
    IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, IsBounded (f i) 
goal: Bornology.IsBounded (⋃ i ∈ s, f i) ↔ ∀ i ∈ s, Bornology.IsBounded (f i)

full_name: Bornology.isBounded_sUnion
code: theorem isBounded_sUnion {S : Set (Set α)} (hs : S.Finite) :
    IsBounded (⋃₀ S) ↔ ∀ s ∈ S, IsBounded s 
goal: Bornology.IsBounded (⋃₀ S) ↔ ∀ s ∈ S, Bornology.IsBounded s

full_name: Bornology.isBounded_iUnion
code: @[simp]
theorem isBounded_iUnion [Finite ι] {s : ι → Set α} :
    IsBounded (⋃ i, s i) ↔ ∀ i, IsBounded (s i) 
goal: Bornology.IsBounded (⋃ i, s i) ↔ ∀ (i : ι), Bornology.IsBounded (s i)

full_name: Bornology.eventually_ne_cobounded
code: lemma eventually_ne_cobounded (a : α) : ∀ᶠ x in cobounded α, x ≠ a 
goal: ∀ᶠ (x : α) in Bornology.cobounded α, x ≠ a

full_name: Filter.HasBasis.disjoint_cobounded_iff
code: theorem Filter.HasBasis.disjoint_cobounded_iff [Bornology α] {ι : Sort*} {p : ι → Prop}
    {s : ι → Set α} {l : Filter α} (h : l.HasBasis p s) :
    Disjoint l (cobounded α) ↔ ∃ i, p i ∧ IsBounded (s i) 
goal: Disjoint l (Bornology.cobounded α) ↔ ∃ i, p i ∧ Bornology.IsBounded (s i)

full_name: Set.Finite.isBounded
code: theorem Set.Finite.isBounded [Bornology α] {s : Set α} (hs : s.Finite) : IsBounded s 
goal: Bornology.IsBounded s

full_name: Filter.Tendsto.eventually_ne_cobounded
code: nonrec lemma Filter.Tendsto.eventually_ne_cobounded [Bornology α] {f : β → α} {l : Filter β}
    (h : Tendsto f l (cobounded α)) (a : α) : ∀ᶠ x in l, f x ≠ a 
goal: ∀ᶠ (x : β) in l, f x ≠ a

full_name: instBornologyPUnit
code: instance : Bornology PUnit 
goal: Bornology PUnit.{u_4 + 1}

full_name: Bornology.cofinite
code: /-- The cofinite filter as a bornology -/
abbrev Bornology.cofinite : Bornology α 
goal: Bornology α

full_name: BoundedSpace
code: /-- A space with a `Bornology` is a **bounded space** if `Set.univ : Set α` is bounded. -/
class BoundedSpace (α : Type*) [Bornology α] : Prop where
  /-- The `Set.univ` is bounded. -/
  bounded_univ : Bornology.IsBounded (univ : Set α)
goal: Prop

full_name: BoundedSpace.bounded_univ
code: /-- A space with a `Bornology` is a **bounded space** if `Set.univ : Set α` is bounded. -/
class BoundedSpace (α : Type*) [Bornology α] : Prop where
  /-- The `Set.univ` is bounded. -/
  bounded_univ : Bornology.IsBounded (univ : Set α)
goal: Bornology.IsBounded Set.univ

full_name: BoundedSpace.of_finite
code: /-- A finite space is bounded. -/
instance (priority := 100) BoundedSpace.of_finite {α : Type*} [Bornology α] [Finite α] :
    BoundedSpace α 
goal: BoundedSpace α

full_name: Bornology.isBounded_univ
code: theorem isBounded_univ : IsBounded (univ : Set α) ↔ BoundedSpace α 
goal: Bornology.IsBounded Set.univ ↔ BoundedSpace α

full_name: Bornology.cobounded_eq_bot_iff
code: theorem cobounded_eq_bot_iff : cobounded α = ⊥ ↔ BoundedSpace α 
goal: Bornology.cobounded α = ⊥ ↔ BoundedSpace α

full_name: Bornology.IsBounded.all
code: theorem IsBounded.all (s : Set α) : IsBounded s 
goal: Bornology.IsBounded s

full_name: Bornology.IsCobounded.all
code: theorem IsCobounded.all (s : Set α) : IsCobounded s 
goal: Bornology.IsCobounded s

full_name: Bornology.cobounded_eq_bot
code: @[simp]
theorem cobounded_eq_bot : cobounded α = ⊥ 
goal: Bornology.cobounded α = ⊥

full_name: OrderDual.instBornology
code: instance instBornology : Bornology αᵒᵈ 
goal: Bornology αᵒᵈ

full_name: OrderDual.isCobounded_preimage_ofDual
code: @[simp] lemma isCobounded_preimage_ofDual {s : Set α} :
    IsCobounded (ofDual ⁻¹' s) ↔ IsCobounded s 
goal: Bornology.IsCobounded (⇑OrderDual.ofDual ⁻¹' s) ↔ Bornology.IsCobounded s

full_name: OrderDual.isCobounded_preimage_toDual
code: @[simp] lemma isCobounded_preimage_toDual {s : Set αᵒᵈ} :
    IsCobounded (toDual ⁻¹' s) ↔ IsCobounded s 
goal: Bornology.IsCobounded (⇑OrderDual.toDual ⁻¹' s) ↔ Bornology.IsCobounded s

full_name: OrderDual.isBounded_preimage_ofDual
code: @[simp] lemma isBounded_preimage_ofDual {s : Set α} :
    IsBounded (ofDual ⁻¹' s) ↔ IsBounded s 
goal: Bornology.IsBounded (⇑OrderDual.ofDual ⁻¹' s) ↔ Bornology.IsBounded s

full_name: OrderDual.isBounded_preimage_toDual
code: @[simp] lemma isBounded_preimage_toDual {s : Set αᵒᵈ} :
    IsBounded (toDual ⁻¹' s) ↔ IsBounded s 
goal: Bornology.IsBounded (⇑OrderDual.toDual ⁻¹' s) ↔ Bornology.IsBounded s