File: Mathlib/Topology/Order.lean

full_name: TopologicalSpace.GenerateOpen.inter
code: /-- The open sets of the least topology containing a collection of basic sets. -/
inductive GenerateOpen (g : Set (Set α)) : Set α → Prop
  | basic : ∀ s ∈ g, GenerateOpen g s
  | univ : GenerateOpen g univ
  | inter : ∀ s t, GenerateOpen g s → GenerateOpen g t → GenerateOpen g (s ∩ t)
  | sUnion : ∀ S : Set (Set α), (∀ s ∈ S, GenerateOpen g s) → GenerateOpen g (⋃₀ S)
goal: TopologicalSpace.GenerateOpen g s → TopologicalSpace.GenerateOpen g t → TopologicalSpace.GenerateOpen g (s ∩ t)

full_name: TopologicalSpace.GenerateOpen.univ
code: /-- The open sets of the least topology containing a collection of basic sets. -/
inductive GenerateOpen (g : Set (Set α)) : Set α → Prop
  | basic : ∀ s ∈ g, GenerateOpen g s
  | univ : GenerateOpen g univ
  | inter : ∀ s t, GenerateOpen g s → GenerateOpen g t → GenerateOpen g (s ∩ t)
  | sUnion : ∀ S : Set (Set α), (∀ s ∈ S, GenerateOpen g s) → GenerateOpen g (⋃₀ S)
goal: TopologicalSpace.GenerateOpen g Set.univ

full_name: TopologicalSpace.GenerateOpen.basic
code: /-- The open sets of the least topology containing a collection of basic sets. -/
inductive GenerateOpen (g : Set (Set α)) : Set α → Prop
  | basic : ∀ s ∈ g, GenerateOpen g s
  | univ : GenerateOpen g univ
  | inter : ∀ s t, GenerateOpen g s → GenerateOpen g t → GenerateOpen g (s ∩ t)
  | sUnion : ∀ S : Set (Set α), (∀ s ∈ S, GenerateOpen g s) → GenerateOpen g (⋃₀ S)
goal: s ∈ g → TopologicalSpace.GenerateOpen g s

full_name: TopologicalSpace.GenerateOpen
code: /-- The open sets of the least topology containing a collection of basic sets. -/
inductive GenerateOpen (g : Set (Set α)) : Set α → Prop
  | basic : ∀ s ∈ g, GenerateOpen g s
  | univ : GenerateOpen g univ
  | inter : ∀ s t, GenerateOpen g s → GenerateOpen g t → GenerateOpen g (s ∩ t)
  | sUnion : ∀ S : Set (Set α), (∀ s ∈ S, GenerateOpen g s) → GenerateOpen g (⋃₀ S)
goal: Set α → Prop

full_name: TopologicalSpace.GenerateOpen.sUnion
code: /-- The open sets of the least topology containing a collection of basic sets. -/
inductive GenerateOpen (g : Set (Set α)) : Set α → Prop
  | basic : ∀ s ∈ g, GenerateOpen g s
  | univ : GenerateOpen g univ
  | inter : ∀ s t, GenerateOpen g s → GenerateOpen g t → GenerateOpen g (s ∩ t)
  | sUnion : ∀ S : Set (Set α), (∀ s ∈ S, GenerateOpen g s) → GenerateOpen g (⋃₀ S)
goal: (∀ s ∈ S, TopologicalSpace.GenerateOpen g s) → TopologicalSpace.GenerateOpen g (⋃₀ S)

full_name: TopologicalSpace.generateFrom
code: /-- The smallest topological space containing the collection `g` of basic sets -/
def generateFrom (g : Set (Set α)) : TopologicalSpace α 
goal: TopologicalSpace α

full_name: TopologicalSpace.isOpen_generateFrom_of_mem
code: theorem isOpen_generateFrom_of_mem {g : Set (Set α)} {s : Set α} (hs : s ∈ g) :
    IsOpen[generateFrom g] s 
goal: IsOpen s

full_name: TopologicalSpace.nhds_generateFrom
code: theorem nhds_generateFrom {g : Set (Set α)} {a : α} :
    @nhds α (generateFrom g) a = ⨅ s ∈ { s | a ∈ s ∧ s ∈ g }, 𝓟 s 
goal: 𝓝 a = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s

full_name: TopologicalSpace.tendsto_nhds_generateFrom_iff
code: lemma tendsto_nhds_generateFrom_iff {β : Type*} {m : α → β} {f : Filter α} {g : Set (Set β)}
    {b : β} : Tendsto m f (@nhds β (generateFrom g) b) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f 
goal: Filter.Tendsto m f (𝓝 b) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f

full_name: TopologicalSpace.mkOfNhds
code: /-- Construct a topology on α given the filter of neighborhoods of each point of α. -/
protected def mkOfNhds (n : α → Filter α) : TopologicalSpace α 
goal: TopologicalSpace α

full_name: TopologicalSpace.nhds_mkOfNhds_of_hasBasis
code: theorem nhds_mkOfNhds_of_hasBasis {n : α → Filter α} {ι : α → Sort*} {p : ∀ a, ι a → Prop}
    {s : ∀ a, ι a → Set α} (hb : ∀ a, (n a).HasBasis (p a) (s a))
    (hpure : ∀ a i, p a i → a ∈ s a i) (hopen : ∀ a i, p a i → ∀ᶠ x in n a, s a i ∈ n x) (a : α) :
    @nhds α (.mkOfNhds n) a = n a 
goal: 𝓝 a = n a

full_name: TopologicalSpace.nhds_mkOfNhds
code: theorem nhds_mkOfNhds (n : α → Filter α) (a : α) (h₀ : pure ≤ n)
    (h₁ : ∀ a, ∀ s ∈ n a, ∀ᶠ y in n a, s ∈ n y) :
    @nhds α (TopologicalSpace.mkOfNhds n) a = n a 
goal: 𝓝 a = n a

full_name: TopologicalSpace.nhds_mkOfNhds_single
code: theorem nhds_mkOfNhds_single [DecidableEq α] {a₀ : α} {l : Filter α} (h : pure a₀ ≤ l) (b : α) :
    @nhds α (TopologicalSpace.mkOfNhds (update pure a₀ l)) b =
      (update pure a₀ l : α → Filter α) b 
goal: 𝓝 b = Function.update pure a₀ l b

full_name: TopologicalSpace.nhds_mkOfNhds_filterBasis
code: theorem nhds_mkOfNhds_filterBasis (B : α → FilterBasis α) (a : α) (h₀ : ∀ x, ∀ n ∈ B x, x ∈ n)
    (h₁ : ∀ x, ∀ n ∈ B x, ∃ n₁ ∈ B x, ∀ x' ∈ n₁, ∃ n₂ ∈ B x', n₂ ⊆ n) :
    @nhds α (TopologicalSpace.mkOfNhds fun x => (B x).filter) a = (B a).filter 
goal: 𝓝 a = (B a).filter

full_name: TopologicalSpace.instPartialOrder
code: /-- The ordering on topologies on the type `α`. `t ≤ s` if every set open in `s` is also open in `t`
(`t` is finer than `s`). -/
instance : PartialOrder (TopologicalSpace α) 
goal: PartialOrder (TopologicalSpace α)

full_name: TopologicalSpace.le_def
code: protected theorem le_def {α} {t s : TopologicalSpace α} : t ≤ s ↔ IsOpen[s] ≤ IsOpen[t] 
goal: t ≤ s ↔ IsOpen ≤ IsOpen

full_name: TopologicalSpace.le_generateFrom_iff_subset_isOpen
code: theorem le_generateFrom_iff_subset_isOpen {g : Set (Set α)} {t : TopologicalSpace α} :
    t ≤ generateFrom g ↔ g ⊆ { s | IsOpen[t] s } 
goal: t ≤ TopologicalSpace.generateFrom g ↔ g ⊆ {s | IsOpen s}

full_name: TopologicalSpace.mkOfClosure
code: /-- If `s` equals the collection of open sets in the topology it generates, then `s` defines a
topology. -/
protected def mkOfClosure (s : Set (Set α)) (hs : { u | GenerateOpen s u } = s) :
    TopologicalSpace α 
goal: TopologicalSpace α

full_name: TopologicalSpace.mkOfClosure_sets
code: theorem mkOfClosure_sets {s : Set (Set α)} {hs : { u | GenerateOpen s u } = s} :
    TopologicalSpace.mkOfClosure s hs = generateFrom s 
goal: TopologicalSpace.mkOfClosure s hs = TopologicalSpace.generateFrom s

full_name: TopologicalSpace.gc_generateFrom
code: theorem gc_generateFrom (α) :
    GaloisConnection (fun t : TopologicalSpace α => OrderDual.toDual { s | IsOpen[t] s })
      (generateFrom ∘ OrderDual.ofDual) 
goal: GaloisConnection (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual)

full_name: TopologicalSpace.gciGenerateFrom
code: /-- The Galois coinsertion between `TopologicalSpace α` and `(Set (Set α))ᵒᵈ` whose lower part sends
  a topology to its collection of open subsets, and whose upper part sends a collection of subsets
  of `α` to the topology they generate. -/
def gciGenerateFrom (α : Type*) :
    GaloisCoinsertion (fun t : TopologicalSpace α => OrderDual.toDual { s | IsOpen[t] s })
      (generateFrom ∘ OrderDual.ofDual) 
goal: GaloisCoinsertion (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual)

full_name: TopologicalSpace.instCompleteLattice
code: /-- Topologies on `α` form a complete lattice, with `⊥` the discrete topology
  and `⊤` the indiscrete topology. The infimum of a collection of topologies
  is the topology generated by all their open sets, while the supremum is the
  topology whose open sets are those sets open in every member of the collection. -/
instance : CompleteLattice (TopologicalSpace α) 
goal: CompleteLattice (TopologicalSpace α)

full_name: TopologicalSpace.generateFrom_anti
code: @[mono]
theorem generateFrom_anti {α} {g₁ g₂ : Set (Set α)} (h : g₁ ⊆ g₂) :
    generateFrom g₂ ≤ generateFrom g₁ 
goal: TopologicalSpace.generateFrom g₂ ≤ TopologicalSpace.generateFrom g₁

full_name: TopologicalSpace.generateFrom_setOf_isOpen
code: theorem generateFrom_setOf_isOpen (t : TopologicalSpace α) :
    generateFrom { s | IsOpen[t] s } = t 
goal: TopologicalSpace.generateFrom {s | IsOpen s} = t

full_name: TopologicalSpace.leftInverse_generateFrom
code: theorem leftInverse_generateFrom :
    LeftInverse generateFrom fun t : TopologicalSpace α => { s | IsOpen[t] s } 
goal: Function.LeftInverse TopologicalSpace.generateFrom fun t => {s | IsOpen s}

full_name: TopologicalSpace.generateFrom_surjective
code: theorem generateFrom_surjective : Surjective (generateFrom : Set (Set α) → TopologicalSpace α) 
goal: Function.Surjective TopologicalSpace.generateFrom

full_name: TopologicalSpace.setOf_isOpen_injective
code: theorem setOf_isOpen_injective : Injective fun t : TopologicalSpace α => { s | IsOpen[t] s } 
goal: Function.Injective fun t => {s | IsOpen s}

full_name: IsOpen.mono
code: theorem IsOpen.mono (hs : IsOpen[t₂] s) (h : t₁ ≤ t₂) : IsOpen[t₁] s 
goal: IsOpen s

full_name: IsClosed.mono
code: theorem IsClosed.mono (hs : IsClosed[t₂] s) (h : t₁ ≤ t₂) : IsClosed[t₁] s 
goal: IsClosed s

full_name: closure.mono
code: theorem closure.mono (h : t₁ ≤ t₂) : closure[t₁] s ⊆ closure[t₂] s 
goal: closure s ⊆ closure s

full_name: isOpen_implies_isOpen_iff
code: theorem isOpen_implies_isOpen_iff : (∀ s, IsOpen[t₁] s → IsOpen[t₂] s) ↔ t₂ ≤ t₁ 
goal: (∀ (s : Set α), IsOpen s → IsOpen s) ↔ t₂ ≤ t₁

full_name: TopologicalSpace.isOpen_top_iff
code: /-- The only open sets in the indiscrete topology are the empty set and the whole space. -/
theorem TopologicalSpace.isOpen_top_iff {α} (U : Set α) : IsOpen[⊤] U ↔ U = ∅ ∨ U = univ 
goal: IsOpen U ↔ U = ∅ ∨ U = Set.univ

full_name: DiscreteTopology
code: /-- A topological space is discrete if every set is open, that is,
  its topology equals the discrete topology `⊥`. -/
class DiscreteTopology (α : Type*) [t : TopologicalSpace α] : Prop where
  /-- The `TopologicalSpace` structure on a type with discrete topology is equal to `⊥`. -/
  eq_bot : t = ⊥
goal: Prop

full_name: DiscreteTopology.eq_bot
code: /-- A topological space is discrete if every set is open, that is,
  its topology equals the discrete topology `⊥`. -/
class DiscreteTopology (α : Type*) [t : TopologicalSpace α] : Prop where
  /-- The `TopologicalSpace` structure on a type with discrete topology is equal to `⊥`. -/
  eq_bot : t = ⊥
goal: t = ⊥

full_name: discreteTopology_bot
code: theorem discreteTopology_bot (α : Type*) : @DiscreteTopology α ⊥ 
goal: DiscreteTopology α

full_name: isOpen_discrete
code: @[simp]
theorem isOpen_discrete (s : Set α) : IsOpen s 
goal: IsOpen s

full_name: isClosed_discrete
code: @[simp] theorem isClosed_discrete (s : Set α) : IsClosed s 
goal: IsClosed s

full_name: closure_discrete
code: @[simp] theorem closure_discrete (s : Set α) : closure s = s 
goal: closure s = s

full_name: dense_discrete
code: @[simp] theorem dense_discrete {s : Set α} : Dense s ↔ s = univ 
goal: Dense s ↔ s = Set.univ

full_name: denseRange_discrete
code: @[simp]
theorem denseRange_discrete {ι : Type*} {f : ι → α} : DenseRange f ↔ Surjective f 
goal: DenseRange f ↔ Function.Surjective f

full_name: continuous_of_discreteTopology
code: @[nontriviality, continuity, fun_prop]
theorem continuous_of_discreteTopology [TopologicalSpace β] {f : α → β} : Continuous f 
goal: Continuous f

full_name: continuous_discrete_rng
code: /-- A function to a discrete topological space is continuous if and only if the preimage of every
singleton is open. -/
theorem continuous_discrete_rng [TopologicalSpace β] [DiscreteTopology β]
    {f : α → β} : Continuous f ↔ ∀ b : β, IsOpen (f ⁻¹' {b}) 
goal: Continuous f ↔ ∀ (b : β), IsOpen (f ⁻¹' {b})

full_name: nhds_discrete
code: @[simp]
theorem nhds_discrete (α : Type*) [TopologicalSpace α] [DiscreteTopology α] : @nhds α _ = pure 
goal: 𝓝 = pure

full_name: mem_nhds_discrete
code: theorem mem_nhds_discrete {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ x ∈ s 
goal: s ∈ 𝓝 x ↔ x ∈ s

full_name: le_of_nhds_le_nhds
code: theorem le_of_nhds_le_nhds (h : ∀ x, @nhds α t₁ x ≤ @nhds α t₂ x) : t₁ ≤ t₂ 
goal: t₁ ≤ t₂

full_name: eq_bot_of_singletons_open
code: theorem eq_bot_of_singletons_open {t : TopologicalSpace α} (h : ∀ x, IsOpen[t] {x}) : t = ⊥ 
goal: t = ⊥

full_name: forall_open_iff_discrete
code: theorem forall_open_iff_discrete {X : Type*} [TopologicalSpace X] :
    (∀ s : Set X, IsOpen s) ↔ DiscreteTopology X 
goal: (∀ (s : Set X), IsOpen s) ↔ DiscreteTopology X

full_name: discreteTopology_iff_forall_isClosed
code: theorem discreteTopology_iff_forall_isClosed [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ s : Set α, IsClosed s 
goal: DiscreteTopology α ↔ ∀ (s : Set α), IsClosed s

full_name: singletons_open_iff_discrete
code: theorem singletons_open_iff_discrete {X : Type*} [TopologicalSpace X] :
    (∀ a : X, IsOpen ({a} : Set X)) ↔ DiscreteTopology X 
goal: (∀ (a : X), IsOpen {a}) ↔ DiscreteTopology X

full_name: discreteTopology_iff_singleton_mem_nhds
code: theorem discreteTopology_iff_singleton_mem_nhds [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, {x} ∈ 𝓝 x 
goal: DiscreteTopology α ↔ ∀ (x : α), {x} ∈ 𝓝 x

full_name: discreteTopology_iff_nhds
code: /-- This lemma characterizes discrete topological spaces as those whose singletons are
neighbourhoods. -/
theorem discreteTopology_iff_nhds [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, 𝓝 x = pure x 
goal: DiscreteTopology α ↔ ∀ (x : α), 𝓝 x = pure x

full_name: discreteTopology_iff_nhds_ne
code: theorem discreteTopology_iff_nhds_ne [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, 𝓝[≠] x = ⊥ 
goal: DiscreteTopology α ↔ ∀ (x : α), 𝓝[≠] x = ⊥

full_name: DiscreteTopology.of_continuous_injective
code: /-- If the codomain of a continuous injective function has discrete topology,
then so does the domain.

See also `Embedding.discreteTopology` for an important special case. -/
theorem DiscreteTopology.of_continuous_injective
    {β : Type*} [TopologicalSpace α] [TopologicalSpace β] [DiscreteTopology β] {f : α → β}
    (hc : Continuous f) (hinj : Injective f) : DiscreteTopology α 
goal: DiscreteTopology α

full_name: isOpen_induced_iff
code: theorem isOpen_induced_iff [t : TopologicalSpace β] {s : Set α} {f : α → β} :
    IsOpen[t.induced f] s ↔ ∃ t, IsOpen t ∧ f ⁻¹' t = s 
goal: IsOpen s ↔ ∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = s

full_name: isClosed_induced_iff
code: theorem isClosed_induced_iff [t : TopologicalSpace β] {s : Set α} {f : α → β} :
    IsClosed[t.induced f] s ↔ ∃ t, IsClosed t ∧ f ⁻¹' t = s 
goal: IsClosed s ↔ ∃ t_1, IsClosed t_1 ∧ f ⁻¹' t_1 = s

full_name: isOpen_coinduced
code: theorem isOpen_coinduced {t : TopologicalSpace α} {s : Set β} {f : α → β} :
    IsOpen[t.coinduced f] s ↔ IsOpen (f ⁻¹' s) 
goal: IsOpen s ↔ IsOpen (f ⁻¹' s)

full_name: isClosed_coinduced
code: theorem isClosed_coinduced {t : TopologicalSpace α} {s : Set β} {f : α → β} :
    IsClosed[t.coinduced f] s ↔ IsClosed (f ⁻¹' s) 
goal: IsClosed s ↔ IsClosed (f ⁻¹' s)

full_name: preimage_nhds_coinduced
code: theorem preimage_nhds_coinduced [TopologicalSpace α] {π : α → β} {s : Set β} {a : α}
    (hs : s ∈ @nhds β (TopologicalSpace.coinduced π ‹_›) (π a)) : π ⁻¹' s ∈ 𝓝 a 
goal: π ⁻¹' s ∈ 𝓝 a

full_name: Continuous.coinduced_le
code: theorem Continuous.coinduced_le (h : Continuous[t, t'] f) : t.coinduced f ≤ t' 
goal: TopologicalSpace.coinduced f t ≤ t'

full_name: coinduced_le_iff_le_induced
code: theorem coinduced_le_iff_le_induced {f : α → β} {tα : TopologicalSpace α}
    {tβ : TopologicalSpace β} : tα.coinduced f ≤ tβ ↔ tα ≤ tβ.induced f 
goal: TopologicalSpace.coinduced f tα ≤ tβ ↔ tα ≤ TopologicalSpace.induced f tβ

full_name: Continuous.le_induced
code: theorem Continuous.le_induced (h : Continuous[t, t'] f) : t ≤ t'.induced f 
goal: t ≤ TopologicalSpace.induced f t'

full_name: gc_coinduced_induced
code: theorem gc_coinduced_induced (f : α → β) :
    GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f) 
goal: GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f)

full_name: induced_mono
code: theorem induced_mono (h : t₁ ≤ t₂) : t₁.induced g ≤ t₂.induced g 
goal: TopologicalSpace.induced g t₁ ≤ TopologicalSpace.induced g t₂

full_name: coinduced_mono
code: theorem coinduced_mono (h : t₁ ≤ t₂) : t₁.coinduced f ≤ t₂.coinduced f 
goal: TopologicalSpace.coinduced f t₁ ≤ TopologicalSpace.coinduced f t₂

full_name: induced_top
code: @[simp]
theorem induced_top : (⊤ : TopologicalSpace α).induced g = ⊤ 
goal: TopologicalSpace.induced g ⊤ = ⊤

full_name: induced_inf
code: @[simp]
theorem induced_inf : (t₁ ⊓ t₂).induced g = t₁.induced g ⊓ t₂.induced g 
goal: TopologicalSpace.induced g (t₁ ⊓ t₂) = TopologicalSpace.induced g t₁ ⊓ TopologicalSpace.induced g t₂

full_name: induced_iInf
code: @[simp]
theorem induced_iInf {ι : Sort w} {t : ι → TopologicalSpace α} :
    (⨅ i, t i).induced g = ⨅ i, (t i).induced g 
goal: TopologicalSpace.induced g (⨅ i, t i) = ⨅ i, TopologicalSpace.induced g (t i)

full_name: coinduced_bot
code: @[simp]
theorem coinduced_bot : (⊥ : TopologicalSpace α).coinduced f = ⊥ 
goal: TopologicalSpace.coinduced f ⊥ = ⊥

full_name: coinduced_sup
code: @[simp]
theorem coinduced_sup : (t₁ ⊔ t₂).coinduced f = t₁.coinduced f ⊔ t₂.coinduced f 
goal: TopologicalSpace.coinduced f (t₁ ⊔ t₂) = TopologicalSpace.coinduced f t₁ ⊔ TopologicalSpace.coinduced f t₂

full_name: coinduced_iSup
code: @[simp]
theorem coinduced_iSup {ι : Sort w} {t : ι → TopologicalSpace α} :
    (⨆ i, t i).coinduced f = ⨆ i, (t i).coinduced f 
goal: TopologicalSpace.coinduced f (⨆ i, t i) = ⨆ i, TopologicalSpace.coinduced f (t i)

full_name: induced_id
code: theorem induced_id [t : TopologicalSpace α] : t.induced id = t 
goal: TopologicalSpace.induced id t = t

full_name: induced_compose
code: theorem induced_compose {tγ : TopologicalSpace γ} {f : α → β} {g : β → γ} :
    (tγ.induced g).induced f = tγ.induced (g ∘ f) 
goal: TopologicalSpace.induced f (TopologicalSpace.induced g tγ) = TopologicalSpace.induced (g ∘ f) tγ

full_name: induced_const
code: theorem induced_const [t : TopologicalSpace α] {x : α} : (t.induced fun _ : β => x) = ⊤ 
goal: TopologicalSpace.induced (fun x_1 => x) t = ⊤

full_name: coinduced_id
code: theorem coinduced_id [t : TopologicalSpace α] : t.coinduced id = t 
goal: TopologicalSpace.coinduced id t = t

full_name: coinduced_compose
code: theorem coinduced_compose [tα : TopologicalSpace α] {f : α → β} {g : β → γ} :
    (tα.coinduced f).coinduced g = tα.coinduced (g ∘ f) 
goal: TopologicalSpace.coinduced g (TopologicalSpace.coinduced f tα) = TopologicalSpace.coinduced (g ∘ f) tα

full_name: Equiv.induced_symm
code: theorem Equiv.induced_symm {α β : Type*} (e : α ≃ β) :
    TopologicalSpace.induced e.symm = TopologicalSpace.coinduced e 
goal: TopologicalSpace.induced ⇑e.symm = TopologicalSpace.coinduced ⇑e

full_name: Equiv.coinduced_symm
code: theorem Equiv.coinduced_symm {α β : Type*} (e : α ≃ β) :
    TopologicalSpace.coinduced e.symm = TopologicalSpace.induced e 
goal: TopologicalSpace.coinduced ⇑e.symm = TopologicalSpace.induced ⇑e

full_name: inhabitedTopologicalSpace
code: instance inhabitedTopologicalSpace {α : Type u} : Inhabited (TopologicalSpace α) 
goal: Inhabited (TopologicalSpace α)

full_name: Subsingleton.uniqueTopologicalSpace
code: instance (priority := 100) Subsingleton.uniqueTopologicalSpace [Subsingleton α] :
    Unique (TopologicalSpace α) 
goal: Unique (TopologicalSpace α)

full_name: Subsingleton.discreteTopology
code: instance (priority := 100) Subsingleton.discreteTopology [t : TopologicalSpace α] [Subsingleton α] :
    DiscreteTopology α 
goal: DiscreteTopology α

full_name: instTopologicalSpaceEmpty
code: instance : TopologicalSpace Empty 
goal: TopologicalSpace Empty

full_name: instDiscreteTopologyEmpty
code: instance : DiscreteTopology Empty 
goal: DiscreteTopology Empty

full_name: instTopologicalSpacePEmpty
code: instance : TopologicalSpace PEmpty 
goal: TopologicalSpace PEmpty.{u_1 + 1}

full_name: instDiscreteTopologyPEmpty
code: instance : DiscreteTopology PEmpty 
goal: DiscreteTopology PEmpty.{u_1 + 1}

full_name: instTopologicalSpacePUnit
code: instance : TopologicalSpace PUnit 
goal: TopologicalSpace PUnit.{u_1 + 1}

full_name: instDiscreteTopologyPUnit
code: instance : DiscreteTopology PUnit 
goal: DiscreteTopology PUnit.{u_1 + 1}

full_name: instTopologicalSpaceBool
code: instance : TopologicalSpace Bool 
goal: TopologicalSpace Bool

full_name: instDiscreteTopologyBool
code: instance : DiscreteTopology Bool 
goal: DiscreteTopology Bool

full_name: instTopologicalSpaceNat
code: instance : TopologicalSpace ℕ 
goal: TopologicalSpace ℕ

full_name: instDiscreteTopologyNat
code: instance : DiscreteTopology ℕ 
goal: DiscreteTopology ℕ

full_name: instTopologicalSpaceInt
code: instance : TopologicalSpace ℤ 
goal: TopologicalSpace ℤ

full_name: instDiscreteTopologyInt
code: instance : DiscreteTopology ℤ 
goal: DiscreteTopology ℤ

full_name: instTopologicalSpaceFin
code: instance {n} : TopologicalSpace (Fin n) 
goal: TopologicalSpace (Fin n)

full_name: instDiscreteTopologyFin
code: instance {n} : DiscreteTopology (Fin n) 
goal: DiscreteTopology (Fin n)

full_name: sierpinskiSpace
code: instance sierpinskiSpace : TopologicalSpace Prop 
goal: TopologicalSpace Prop

full_name: continuous_empty_function
code: theorem continuous_empty_function [TopologicalSpace α] [TopologicalSpace β] [IsEmpty β]
    (f : α → β) : Continuous f 
goal: Continuous f

full_name: le_generateFrom
code: theorem le_generateFrom {t : TopologicalSpace α} {g : Set (Set α)} (h : ∀ s ∈ g, IsOpen s) :
    t ≤ generateFrom g 
goal: t ≤ TopologicalSpace.generateFrom g

full_name: induced_generateFrom_eq
code: theorem induced_generateFrom_eq {α β} {b : Set (Set β)} {f : α → β} :
    (generateFrom b).induced f = generateFrom (preimage f '' b) 
goal: TopologicalSpace.induced f (TopologicalSpace.generateFrom b) = TopologicalSpace.generateFrom (Set.preimage f '' b)

full_name: le_induced_generateFrom
code: theorem le_induced_generateFrom {α β} [t : TopologicalSpace α] {b : Set (Set β)} {f : α → β}
    (h : ∀ a : Set β, a ∈ b → IsOpen (f ⁻¹' a)) : t ≤ induced f (generateFrom b) 
goal: t ≤ TopologicalSpace.induced f (TopologicalSpace.generateFrom b)

full_name: generateFrom_insert_of_generateOpen
code: lemma generateFrom_insert_of_generateOpen {α : Type*} {s : Set (Set α)} {t : Set α}
    (ht : GenerateOpen s t) : generateFrom (insert t s) = generateFrom s 
goal: TopologicalSpace.generateFrom (insert t s) = TopologicalSpace.generateFrom s

full_name: generateFrom_insert_univ
code: @[simp]
lemma generateFrom_insert_univ {α : Type*} {s : Set (Set α)} :
    generateFrom (insert univ s) = generateFrom s 
goal: TopologicalSpace.generateFrom (insert Set.univ s) = TopologicalSpace.generateFrom s

full_name: nhdsAdjoint
code: /-- This construction is left adjoint to the operation sending a topology on `α`
  to its neighborhood filter at a fixed point `a : α`. -/
def nhdsAdjoint (a : α) (f : Filter α) : TopologicalSpace α 
goal: TopologicalSpace α

full_name: gc_nhds
code: theorem gc_nhds (a : α) : GaloisConnection (nhdsAdjoint a) fun t => @nhds α t a 
goal: GaloisConnection (nhdsAdjoint a) fun t => 𝓝 a

full_name: nhds_mono
code: theorem nhds_mono {t₁ t₂ : TopologicalSpace α} {a : α} (h : t₁ ≤ t₂) :
    @nhds α t₁ a ≤ @nhds α t₂ a 
goal: 𝓝 a ≤ 𝓝 a

full_name: le_iff_nhds
code: theorem le_iff_nhds {α : Type*} (t t' : TopologicalSpace α) :
    t ≤ t' ↔ ∀ x, @nhds α t x ≤ @nhds α t' x 
goal: t ≤ t' ↔ ∀ (x : α), 𝓝 x ≤ 𝓝 x

full_name: isOpen_singleton_nhdsAdjoint
code: theorem isOpen_singleton_nhdsAdjoint {α : Type*} {a b : α} (f : Filter α) (hb : b ≠ a) :
    IsOpen[nhdsAdjoint a f] {b} 
goal: IsOpen {b}

full_name: nhds_nhdsAdjoint_same
code: theorem nhds_nhdsAdjoint_same (a : α) (f : Filter α) :
    @nhds α (nhdsAdjoint a f) a = pure a ⊔ f 
goal: 𝓝 a = pure a ⊔ f

full_name: nhds_nhdsAdjoint_of_ne
code: theorem nhds_nhdsAdjoint_of_ne {a b : α} (f : Filter α) (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b 
goal: 𝓝 b = pure b

full_name: nhdsAdjoint_nhds_of_ne
code: @[deprecated nhds_nhdsAdjoint_of_ne (since := "2024-02-10")]
theorem nhdsAdjoint_nhds_of_ne (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b 
goal: 𝓝 b = pure b

full_name: nhds_nhdsAdjoint
code: theorem nhds_nhdsAdjoint [DecidableEq α] (a : α) (f : Filter α) :
    @nhds α (nhdsAdjoint a f) = update pure a (pure a ⊔ f) 
goal: 𝓝 = Function.update pure a (pure a ⊔ f)

full_name: le_nhdsAdjoint_iff'
code: theorem le_nhdsAdjoint_iff' {a : α} {f : Filter α} {t : TopologicalSpace α} :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b ≠ a, @nhds α t b = pure b 
goal: t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b

full_name: le_nhdsAdjoint_iff
code: theorem le_nhdsAdjoint_iff {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b ≠ a, IsOpen[t] {b} 
goal: t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → IsOpen {b}

full_name: nhds_iInf
code: theorem nhds_iInf {ι : Sort*} {t : ι → TopologicalSpace α} {a : α} :
    @nhds α (iInf t) a = ⨅ i, @nhds α (t i) a 
goal: 𝓝 a = ⨅ i, 𝓝 a

full_name: nhds_sInf
code: theorem nhds_sInf {s : Set (TopologicalSpace α)} {a : α} :
    @nhds α (sInf s) a = ⨅ t ∈ s, @nhds α t a 
goal: 𝓝 a = ⨅ t ∈ s, 𝓝 a

full_name: nhds_inf
code: theorem nhds_inf {t₁ t₂ : TopologicalSpace α} {a : α} :
    @nhds α (t₁ ⊓ t₂) a = @nhds α t₁ a ⊓ @nhds α t₂ a 
goal: 𝓝 a = 𝓝 a ⊓ 𝓝 a

full_name: nhds_top
code: theorem nhds_top {a : α} : @nhds α ⊤ a = ⊤ 
goal: 𝓝 a = ⊤

full_name: isOpen_sup
code: theorem isOpen_sup {t₁ t₂ : TopologicalSpace α} {s : Set α} :
    IsOpen[t₁ ⊔ t₂] s ↔ IsOpen[t₁] s ∧ IsOpen[t₂] s 
goal: IsOpen s ↔ IsOpen s ∧ IsOpen s

full_name: continuous_iff_coinduced_le
code: theorem continuous_iff_coinduced_le {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β} :
    Continuous[t₁, t₂] f ↔ coinduced f t₁ ≤ t₂ 
goal: Continuous f ↔ TopologicalSpace.coinduced f t₁ ≤ t₂

full_name: continuous_iff_le_induced
code: theorem continuous_iff_le_induced {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β} :
    Continuous[t₁, t₂] f ↔ t₁ ≤ induced f t₂ 
goal: Continuous f ↔ t₁ ≤ TopologicalSpace.induced f t₂

full_name: continuous_generateFrom_iff
code: lemma continuous_generateFrom_iff {t : TopologicalSpace α} {b : Set (Set β)} :
    Continuous[t, generateFrom b] f ↔ ∀ s ∈ b, IsOpen (f ⁻¹' s) 
goal: Continuous f ↔ ∀ s ∈ b, IsOpen (f ⁻¹' s)

full_name: continuous_induced_dom
code: @[continuity, fun_prop]
theorem continuous_induced_dom {t : TopologicalSpace β} : Continuous[induced f t, t] f 
goal: Continuous f

full_name: continuous_induced_rng
code: theorem continuous_induced_rng {g : γ → α} {t₂ : TopologicalSpace β} {t₁ : TopologicalSpace γ} :
    Continuous[t₁, induced f t₂] g ↔ Continuous[t₁, t₂] (f ∘ g) 
goal: Continuous g ↔ Continuous (f ∘ g)

full_name: continuous_coinduced_rng
code: theorem continuous_coinduced_rng {t : TopologicalSpace α} :
    Continuous[t, coinduced f t] f 
goal: Continuous f

full_name: continuous_coinduced_dom
code: theorem continuous_coinduced_dom {g : β → γ} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace γ} :
    Continuous[coinduced f t₁, t₂] g ↔ Continuous[t₁, t₂] (g ∘ f) 
goal: Continuous g ↔ Continuous (g ∘ f)

full_name: continuous_le_dom
code: theorem continuous_le_dom {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} (h₁ : t₂ ≤ t₁)
    (h₂ : Continuous[t₁, t₃] f) : Continuous[t₂, t₃] f 
goal: Continuous f

full_name: continuous_le_rng
code: theorem continuous_le_rng {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β} (h₁ : t₂ ≤ t₃)
    (h₂ : Continuous[t₁, t₂] f) : Continuous[t₁, t₃] f 
goal: Continuous f

full_name: continuous_sup_dom
code: theorem continuous_sup_dom {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} :
    Continuous[t₁ ⊔ t₂, t₃] f ↔ Continuous[t₁, t₃] f ∧ Continuous[t₂, t₃] f 
goal: Continuous f ↔ Continuous f ∧ Continuous f

full_name: continuous_sup_rng_left
code: theorem continuous_sup_rng_left {t₁ : TopologicalSpace α} {t₃ t₂ : TopologicalSpace β} :
    Continuous[t₁, t₂] f → Continuous[t₁, t₂ ⊔ t₃] f 
goal: Continuous f → Continuous f

full_name: continuous_sup_rng_right
code: theorem continuous_sup_rng_right {t₁ : TopologicalSpace α} {t₃ t₂ : TopologicalSpace β} :
    Continuous[t₁, t₃] f → Continuous[t₁, t₂ ⊔ t₃] f 
goal: Continuous f → Continuous f

full_name: continuous_sSup_dom
code: theorem continuous_sSup_dom {T : Set (TopologicalSpace α)} {t₂ : TopologicalSpace β} :
    Continuous[sSup T, t₂] f ↔ ∀ t ∈ T, Continuous[t, t₂] f 
goal: Continuous f ↔ ∀ t ∈ T, Continuous f

full_name: continuous_sSup_rng
code: theorem continuous_sSup_rng {t₁ : TopologicalSpace α} {t₂ : Set (TopologicalSpace β)}
    {t : TopologicalSpace β} (h₁ : t ∈ t₂) (hf : Continuous[t₁, t] f) :
    Continuous[t₁, sSup t₂] f 
goal: Continuous f

full_name: continuous_iSup_dom
code: theorem continuous_iSup_dom {t₁ : ι → TopologicalSpace α} {t₂ : TopologicalSpace β} :
    Continuous[iSup t₁, t₂] f ↔ ∀ i, Continuous[t₁ i, t₂] f 
goal: Continuous f ↔ ∀ (i : ι), Continuous f

full_name: continuous_iSup_rng
code: theorem continuous_iSup_rng {t₁ : TopologicalSpace α} {t₂ : ι → TopologicalSpace β} {i : ι}
    (h : Continuous[t₁, t₂ i] f) : Continuous[t₁, iSup t₂] f 
goal: Continuous f

full_name: continuous_inf_rng
code: theorem continuous_inf_rng {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β} :
    Continuous[t₁, t₂ ⊓ t₃] f ↔ Continuous[t₁, t₂] f ∧ Continuous[t₁, t₃] f 
goal: Continuous f ↔ Continuous f ∧ Continuous f

full_name: continuous_inf_dom_left
code: theorem continuous_inf_dom_left {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} :
    Continuous[t₁, t₃] f → Continuous[t₁ ⊓ t₂, t₃] f 
goal: Continuous f → Continuous f

full_name: continuous_inf_dom_right
code: theorem continuous_inf_dom_right {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} :
    Continuous[t₂, t₃] f → Continuous[t₁ ⊓ t₂, t₃] f 
goal: Continuous f → Continuous f

full_name: continuous_sInf_dom
code: theorem continuous_sInf_dom {t₁ : Set (TopologicalSpace α)} {t₂ : TopologicalSpace β}
    {t : TopologicalSpace α} (h₁ : t ∈ t₁) :
    Continuous[t, t₂] f → Continuous[sInf t₁, t₂] f 
goal: Continuous f → Continuous f

full_name: continuous_sInf_rng
code: theorem continuous_sInf_rng {t₁ : TopologicalSpace α} {T : Set (TopologicalSpace β)} :
    Continuous[t₁, sInf T] f ↔ ∀ t ∈ T, Continuous[t₁, t] f 
goal: Continuous f ↔ ∀ t ∈ T, Continuous f

full_name: continuous_iInf_dom
code: theorem continuous_iInf_dom {t₁ : ι → TopologicalSpace α} {t₂ : TopologicalSpace β} {i : ι} :
    Continuous[t₁ i, t₂] f → Continuous[iInf t₁, t₂] f 
goal: Continuous f → Continuous f

full_name: continuous_iInf_rng
code: theorem continuous_iInf_rng {t₁ : TopologicalSpace α} {t₂ : ι → TopologicalSpace β} :
    Continuous[t₁, iInf t₂] f ↔ ∀ i, Continuous[t₁, t₂ i] f 
goal: Continuous f ↔ ∀ (i : ι), Continuous f

full_name: continuous_bot
code: @[continuity, fun_prop]
theorem continuous_bot {t : TopologicalSpace β} : Continuous[⊥, t] f 
goal: Continuous f

full_name: continuous_top
code: @[continuity, fun_prop]
theorem continuous_top {t : TopologicalSpace α} : Continuous[t, ⊤] f 
goal: Continuous f

full_name: continuous_id_iff_le
code: theorem continuous_id_iff_le {t t' : TopologicalSpace α} : Continuous[t, t'] id ↔ t ≤ t' 
goal: Continuous id ↔ t ≤ t'

full_name: continuous_id_of_le
code: theorem continuous_id_of_le {t t' : TopologicalSpace α} (h : t ≤ t') : Continuous[t, t'] id 
goal: Continuous id

full_name: mem_nhds_induced
code: theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s 
goal: s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s

full_name: nhds_induced
code: theorem nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) :
    @nhds β (TopologicalSpace.induced f T) a = comap f (𝓝 (f a)) 
goal: 𝓝 a = Filter.comap f (𝓝 (f a))

full_name: induced_iff_nhds_eq
code: theorem induced_iff_nhds_eq [tα : TopologicalSpace α] [tβ : TopologicalSpace β] (f : β → α) :
    tβ = tα.induced f ↔ ∀ b, 𝓝 b = comap f (𝓝 <| f b) 
goal: tβ = TopologicalSpace.induced f tα ↔ ∀ (b : β), 𝓝 b = Filter.comap f (𝓝 (f b))

full_name: map_nhds_induced_of_surjective
code: theorem map_nhds_induced_of_surjective [T : TopologicalSpace α] {f : β → α} (hf : Surjective f)
    (a : β) : map f (@nhds β (TopologicalSpace.induced f T) a) = 𝓝 (f a) 
goal: Filter.map f (𝓝 a) = 𝓝 (f a)

full_name: isOpen_induced_eq
code: theorem isOpen_induced_eq {s : Set α} :
    IsOpen[induced f t] s ↔ s ∈ preimage f '' { s | IsOpen s } 
goal: IsOpen s ↔ s ∈ Set.preimage f '' {s | IsOpen s}

full_name: isOpen_induced
code: theorem isOpen_induced {s : Set β} (h : IsOpen s) : IsOpen[induced f t] (f ⁻¹' s) 
goal: IsOpen (f ⁻¹' s)

full_name: map_nhds_induced_eq
code: theorem map_nhds_induced_eq (a : α) : map f (@nhds α (induced f t) a) = 𝓝[range f] f a 
goal: Filter.map f (𝓝 a) = 𝓝[Set.range f] f a

full_name: map_nhds_induced_of_mem
code: theorem map_nhds_induced_of_mem {a : α} (h : range f ∈ 𝓝 (f a)) :
    map f (@nhds α (induced f t) a) = 𝓝 (f a) 
goal: Filter.map f (𝓝 a) = 𝓝 (f a)

full_name: closure_induced
code: theorem closure_induced {f : α → β} {a : α} {s : Set α} :
    a ∈ @closure α (t.induced f) s ↔ f a ∈ closure (f '' s) 
goal: a ∈ closure s ↔ f a ∈ closure (f '' s)

full_name: isClosed_induced_iff'
code: theorem isClosed_induced_iff' {f : α → β} {s : Set α} :
    IsClosed[t.induced f] s ↔ ∀ a, f a ∈ closure (f '' s) → a ∈ s 
goal: IsClosed s ↔ ∀ (a : α), f a ∈ closure (f '' s) → a ∈ s

full_name: isOpen_singleton_true
code: @[simp]
theorem isOpen_singleton_true : IsOpen ({True} : Set Prop) 
goal: IsOpen {True}

full_name: nhds_true
code: @[simp]
theorem nhds_true : 𝓝 True = pure True 
goal: 𝓝 True = pure True

full_name: nhds_false
code: @[simp]
theorem nhds_false : 𝓝 False = ⊤ 
goal: 𝓝 False = ⊤

full_name: tendsto_nhds_true
code: theorem tendsto_nhds_true {l : Filter α} {p : α → Prop} :
    Tendsto p l (𝓝 True) ↔ ∀ᶠ x in l, p x 
goal: Filter.Tendsto p l (𝓝 True) ↔ ∀ᶠ (x : α) in l, p x

full_name: tendsto_nhds_Prop
code: theorem tendsto_nhds_Prop {l : Filter α} {p : α → Prop} {q : Prop} :
    Tendsto p l (𝓝 q) ↔ (q → ∀ᶠ x in l, p x) 
goal: Filter.Tendsto p l (𝓝 q) ↔ q → ∀ᶠ (x : α) in l, p x

full_name: continuous_Prop
code: theorem continuous_Prop {p : α → Prop} : Continuous p ↔ IsOpen { x | p x } 
goal: Continuous p ↔ IsOpen {x | p x}

full_name: isOpen_iff_continuous_mem
code: theorem isOpen_iff_continuous_mem {s : Set α} : IsOpen s ↔ Continuous (· ∈ s) 
goal: IsOpen s ↔ Continuous fun x => x ∈ s

full_name: generateFrom_union
code: theorem generateFrom_union (a₁ a₂ : Set (Set α)) :
    generateFrom (a₁ ∪ a₂) = generateFrom a₁ ⊓ generateFrom a₂ 
goal: TopologicalSpace.generateFrom (a₁ ∪ a₂) = TopologicalSpace.generateFrom a₁ ⊓ TopologicalSpace.generateFrom a₂

full_name: setOf_isOpen_sup
code: theorem setOf_isOpen_sup (t₁ t₂ : TopologicalSpace α) :
    { s | IsOpen[t₁ ⊔ t₂] s } = { s | IsOpen[t₁] s } ∩ { s | IsOpen[t₂] s } 
goal: {s | IsOpen s} = {s | IsOpen s} ∩ {s | IsOpen s}

full_name: generateFrom_iUnion
code: theorem generateFrom_iUnion {f : ι → Set (Set α)} :
    generateFrom (⋃ i, f i) = ⨅ i, generateFrom (f i) 
goal: TopologicalSpace.generateFrom (⋃ i, f i) = ⨅ i, TopologicalSpace.generateFrom (f i)

full_name: setOf_isOpen_iSup
code: theorem setOf_isOpen_iSup {t : ι → TopologicalSpace α} :
    { s | IsOpen[⨆ i, t i] s } = ⋂ i, { s | IsOpen[t i] s } 
goal: {s | IsOpen s} = ⋂ i, {s | IsOpen s}

full_name: generateFrom_sUnion
code: theorem generateFrom_sUnion {S : Set (Set (Set α))} :
    generateFrom (⋃₀ S) = ⨅ s ∈ S, generateFrom s 
goal: TopologicalSpace.generateFrom (⋃₀ S) = ⨅ s ∈ S, TopologicalSpace.generateFrom s

full_name: setOf_isOpen_sSup
code: theorem setOf_isOpen_sSup {T : Set (TopologicalSpace α)} :
    { s | IsOpen[sSup T] s } = ⋂ t ∈ T, { s | IsOpen[t] s } 
goal: {s | IsOpen s} = ⋂ t ∈ T, {s | IsOpen s}

full_name: generateFrom_union_isOpen
code: theorem generateFrom_union_isOpen (a b : TopologicalSpace α) :
    generateFrom ({ s | IsOpen[a] s } ∪ { s | IsOpen[b] s }) = a ⊓ b 
goal: TopologicalSpace.generateFrom ({s | IsOpen s} ∪ {s | IsOpen s}) = a ⊓ b

full_name: generateFrom_iUnion_isOpen
code: theorem generateFrom_iUnion_isOpen (f : ι → TopologicalSpace α) :
    generateFrom (⋃ i, { s | IsOpen[f i] s }) = ⨅ i, f i 
goal: TopologicalSpace.generateFrom (⋃ i, {s | IsOpen s}) = ⨅ i, f i

full_name: generateFrom_inter
code: theorem generateFrom_inter (a b : TopologicalSpace α) :
    generateFrom ({ s | IsOpen[a] s } ∩ { s | IsOpen[b] s }) = a ⊔ b 
goal: TopologicalSpace.generateFrom ({s | IsOpen s} ∩ {s | IsOpen s}) = a ⊔ b

full_name: generateFrom_iInter
code: theorem generateFrom_iInter (f : ι → TopologicalSpace α) :
    generateFrom (⋂ i, { s | IsOpen[f i] s }) = ⨆ i, f i 
goal: TopologicalSpace.generateFrom (⋂ i, {s | IsOpen s}) = ⨆ i, f i

full_name: generateFrom_iInter_of_generateFrom_eq_self
code: theorem generateFrom_iInter_of_generateFrom_eq_self (f : ι → Set (Set α))
    (hf : ∀ i, { s | IsOpen[generateFrom (f i)] s } = f i) :
    generateFrom (⋂ i, f i) = ⨆ i, generateFrom (f i) 
goal: TopologicalSpace.generateFrom (⋂ i, f i) = ⨆ i, TopologicalSpace.generateFrom (f i)

full_name: isOpen_iSup_iff
code: theorem isOpen_iSup_iff {s : Set α} : IsOpen[⨆ i, t i] s ↔ ∀ i, IsOpen[t i] s 
goal: IsOpen s ↔ ∀ (i : ι), IsOpen s

full_name: isClosed_iSup_iff
code: theorem isClosed_iSup_iff {s : Set α} : IsClosed[⨆ i, t i] s ↔ ∀ i, IsClosed[t i] s 
goal: IsClosed s ↔ ∀ (i : ι), IsClosed s