ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- nhds_list
theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as 
Arguments: {α : Type u_1} [TopologicalSpace α] (as : List α)
Goal: 𝓝 as = traverse 𝓝 as
-- nhds_nil
@[simp]
theorem nhds_nil : 𝓝 ([] : List α) = pure [] 
Arguments: {α : Type u_1} [TopologicalSpace α]
Goal: 𝓝 [] = pure []
-- nhds_cons
theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*> 𝓝 l 
Arguments: {α : Type u_1} [TopologicalSpace α] (a : α) (l : List α)
Goal: 𝓝 (a :: l) = Seq.seq (List.cons <$> 𝓝 a) fun x => 𝓝 l
-- List.tendsto_cons
theorem List.tendsto_cons {a : α} {l : List α} :
    Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a::l)) 
Arguments: {α : Type u_1} [TopologicalSpace α] {a : α} {l : List α}
Goal: Filter.Tendsto (fun p => p.1 :: p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: l))
-- Filter.Tendsto.cons
theorem Filter.Tendsto.cons {α : Type*} {f : α → β} {g : α → List β} {a : Filter α} {b : β}
    {l : List β} (hf : Tendsto f a (𝓝 b)) (hg : Tendsto g a (𝓝 l)) :
    Tendsto (fun a => List.cons (f a) (g a)) a (𝓝 (b::l)) 
Arguments: {β : Type u_2} [TopologicalSpace β] {α : Type u_3} {f : α → β} {g : α → List β} {a : Filter α} {b : β} {l : List β} (hf : Filter.Tendsto f a (𝓝 b)) (hg : Filter.Tendsto g a (𝓝 l))
Goal: Filter.Tendsto (fun a => f a :: g a) a (𝓝 (b :: l))
-- List.tendsto_cons_iff
theorem tendsto_cons_iff {β : Type*} {f : List α → β} {b : Filter β} {a : α} {l : List α} :
    Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) b 
Arguments: {α : Type u_1} [TopologicalSpace α] {β : Type u_3} {f : List α → β} {b : Filter β} {a : α} {l : List α}
Goal: Filter.Tendsto f (𝓝 (a :: l)) b ↔ Filter.Tendsto (fun p => f (p.1 :: p.2)) (𝓝 a ×ˢ 𝓝 l) b
-- List.continuous_cons
theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α) 
Arguments: {α : Type u_1} [TopologicalSpace α]
Goal: Continuous fun x => x.1 :: x.2
-- List.tendsto_nhds
theorem tendsto_nhds {β : Type*} {f : List α → β} {r : List α → Filter β}
    (h_nil : Tendsto f (pure []) (r []))
    (h_cons :
      ∀ l a,
        Tendsto f (𝓝 l) (r l) →
          Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) (r (a::l))) :
    ∀ l, Tendsto f (𝓝 l) (r l)
  
Arguments: {α : Type u_1} [TopologicalSpace α] {β : Type u_3} {f : List α → β} {r : List α → Filter β} (h_nil : Filter.Tendsto f (pure []) (r [])) (h_cons :
  ∀ (l : List α) (a : α),
    Filter.Tendsto f (𝓝 l) (r l) → Filter.Tendsto (fun p => f (p.1 :: p.2)) (𝓝 a ×ˢ 𝓝 l) (r (a :: l))) (l : List α)
Goal: Filter.Tendsto f (𝓝 l) (r l)
-- List.continuousAt_length
theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l 
Arguments: {α : Type u_1} [TopologicalSpace α] (l : List α)
Goal: ContinuousAt List.length l
-- List.tendsto_insertNth'
theorem tendsto_insertNth' {a : α} :
    ∀ {n : ℕ} {l : List α},
      Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n a l))
  
Arguments: {α : Type u_1} [TopologicalSpace α] {a : α} {n : ℕ} {l : List α}
Goal: Filter.Tendsto (fun p => List.insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (List.insertNth n a l))
-- List.tendsto_insertNth
theorem tendsto_insertNth {β} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α}
    {b : Filter β} (hf : Tendsto f b (𝓝 a)) (hg : Tendsto g b (𝓝 l)) :
    Tendsto (fun b : β => insertNth n (f b) (g b)) b (𝓝 (insertNth n a l)) 
Arguments: {α : Type u_1} [TopologicalSpace α] {β : Type u_3} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α} {b : Filter β} (hf : Filter.Tendsto f b (𝓝 a)) (hg : Filter.Tendsto g b (𝓝 l))
Goal: Filter.Tendsto (fun b => List.insertNth n (f b) (g b)) b (𝓝 (List.insertNth n a l))
-- List.continuous_insertNth
theorem continuous_insertNth {n : ℕ} : Continuous fun p : α × List α => insertNth n p.1 p.2 
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ}
Goal: Continuous fun p => List.insertNth n p.1 p.2
-- List.tendsto_eraseIdx
theorem tendsto_eraseIdx :
    ∀ {n : ℕ} {l : List α}, Tendsto (eraseIdx · n) (𝓝 l) (𝓝 (eraseIdx l n))
  
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ} {l : List α}
Goal: Filter.Tendsto (fun x => x.eraseIdx n) (𝓝 l) (𝓝 (l.eraseIdx n))
-- List.continuous_eraseIdx
theorem continuous_eraseIdx {n : ℕ} : Continuous fun l : List α => eraseIdx l n 
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ}
Goal: Continuous fun l => l.eraseIdx n
-- List.tendsto_prod
@[to_additive]
theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
    Tendsto List.prod (𝓝 l) (𝓝 l.prod) 
Arguments: {α : Type u_1} [TopologicalSpace α] [Monoid α] [ContinuousMul α] {l : List α}
Goal: Filter.Tendsto List.prod (𝓝 l) (𝓝 l.prod)
-- List.tendsto_sum
@[to_additive]
theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
    Tendsto List.prod (𝓝 l) (𝓝 l.prod) 
Arguments: {α : Type u_1} [TopologicalSpace α] [AddMonoid α] [ContinuousAdd α] {l : List α}
Goal: Filter.Tendsto List.sum (𝓝 l) (𝓝 l.sum)
-- List.continuous_prod
@[to_additive]
theorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α) 
Arguments: {α : Type u_1} [TopologicalSpace α] [Monoid α] [ContinuousMul α]
Goal: Continuous List.prod
-- List.continuous_sum
@[to_additive]
theorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α) 
Arguments: {α : Type u_1} [TopologicalSpace α] [AddMonoid α] [ContinuousAdd α]
Goal: Continuous List.sum
-- Vector.tendsto_cons
theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :
    Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l)) 
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ} {a : α} {l : Mathlib.Vector α n}
Goal: Filter.Tendsto (fun p => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l))
-- Vector.tendsto_insertNth
theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :
    ∀ {l : Vector α n},
      Tendsto (fun p : α × Vector α n => Vector.insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 l)
        (𝓝 (Vector.insertNth a i l))
  
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)} {a : α} {l : Mathlib.Vector α n}
Goal: Filter.Tendsto (fun p => Mathlib.Vector.insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (Mathlib.Vector.insertNth a i l))
-- Vector.continuous_insertNth'
theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
    Continuous fun p : α × Vector α n => Vector.insertNth p.1 i p.2 
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)}
Goal: Continuous fun p => Mathlib.Vector.insertNth p.1 i p.2
-- Vector.continuous_insertNth
theorem continuous_insertNth {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Vector α n}
    (hf : Continuous f) (hg : Continuous g) : Continuous fun b => Vector.insertNth (f b) i (g b) 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Mathlib.Vector α n} (hf : Continuous f) (hg : Continuous g)
Goal: Continuous fun b => Mathlib.Vector.insertNth (f b) i (g b)
-- Vector.continuousAt_eraseIdx
theorem continuousAt_eraseIdx {n : ℕ} {i : Fin (n + 1)} :
    ∀ {l : Vector α (n + 1)}, ContinuousAt (Vector.eraseIdx i) l
  
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)} {l : Mathlib.Vector α (n + 1)}
Goal: ContinuousAt (Mathlib.Vector.eraseIdx i) l
-- Vector.continuous_eraseIdx
theorem continuous_eraseIdx {n : ℕ} {i : Fin (n + 1)} :
    Continuous (Vector.eraseIdx i : Vector α (n + 1) → Vector α n) 
Arguments: {α : Type u_1} [TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)}
Goal: Continuous (Mathlib.Vector.eraseIdx i)
-- TopologicalSpace.isOpen_generateFrom_of_mem
theorem isOpen_generateFrom_of_mem {g : Set (Set α)} {s : Set α} (hs : s ∈ g) :
    IsOpen[generateFrom g] s 
Arguments: {α : Type u} {g : Set (Set α)} {s : Set α} (hs : s ∈ g)
Goal: IsOpen s
-- TopologicalSpace.nhds_generateFrom
theorem nhds_generateFrom {g : Set (Set α)} {a : α} :
    @nhds α (generateFrom g) a = ⨅ s ∈ { s | a ∈ s ∧ s ∈ g }, 𝓟 s 
Arguments: {α : Type u} {g : Set (Set α)} {a : α}
Goal: 𝓝 a = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s
-- TopologicalSpace.tendsto_nhds_generateFrom_iff
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 
Arguments: {α : Type u} {β : Type u_1} {m : α → β} {f : Filter α} {g : Set (Set β)} {b : β}
Goal: Filter.Tendsto m f (𝓝 b) ↔ ∀ s ∈ g, b ∈ s → m ⁻¹' s ∈ f
-- TopologicalSpace.nhds_mkOfNhds_of_hasBasis
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 
Arguments: {α : Type u} {n : α → Filter α} {ι : α → Sort u_1} {p : (a : α) → ι a → Prop} {s : (a : α) → ι a → Set α} (hb : ∀ (a : α), (n a).HasBasis (p a) (s a)) (hpure : ∀ (a : α) (i : ι a), p a i → a ∈ s a i) (hopen : ∀ (a : α) (i : ι a), p a i → ∀ᶠ (x : α) in n a, s a i ∈ n x) (a : α)
Goal: 𝓝 a = n a
-- TopologicalSpace.nhds_mkOfNhds
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 
Arguments: {α : Type u} (n : α → Filter α) (a : α) (h₀ : pure ≤ n) (h₁ : ∀ (a : α), ∀ s ∈ n a, ∀ᶠ (y : α) in n a, s ∈ n y)
Goal: 𝓝 a = n a
-- TopologicalSpace.nhds_mkOfNhds_single
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 
Arguments: {α : Type u} [DecidableEq α] {a₀ : α} {l : Filter α} (h : pure a₀ ≤ l) (b : α)
Goal: 𝓝 b = Function.update pure a₀ l b
-- TopologicalSpace.nhds_mkOfNhds_filterBasis
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 
Arguments: {α : Type u} (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)
Goal: 𝓝 a = (B a).filter
-- TopologicalSpace.le_def
protected theorem le_def {α} {t s : TopologicalSpace α} : t ≤ s ↔ IsOpen[s] ≤ IsOpen[t] 
Arguments: {α : Type u_1} {t s : TopologicalSpace α}
Goal: t ≤ s ↔ IsOpen ≤ IsOpen
-- TopologicalSpace.le_generateFrom_iff_subset_isOpen
theorem le_generateFrom_iff_subset_isOpen {g : Set (Set α)} {t : TopologicalSpace α} :
    t ≤ generateFrom g ↔ g ⊆ { s | IsOpen[t] s } 
Arguments: {α : Type u} {g : Set (Set α)} {t : TopologicalSpace α}
Goal: t ≤ TopologicalSpace.generateFrom g ↔ g ⊆ {s | IsOpen s}
-- TopologicalSpace.mkOfClosure_sets
theorem mkOfClosure_sets {s : Set (Set α)} {hs : { u | GenerateOpen s u } = s} :
    TopologicalSpace.mkOfClosure s hs = generateFrom s 
Arguments: {α : Type u} {s : Set (Set α)} {hs : {u | TopologicalSpace.GenerateOpen s u} = s}
Goal: TopologicalSpace.mkOfClosure s hs = TopologicalSpace.generateFrom s
-- TopologicalSpace.gc_generateFrom
theorem gc_generateFrom (α) :
    GaloisConnection (fun t : TopologicalSpace α => OrderDual.toDual { s | IsOpen[t] s })
      (generateFrom ∘ OrderDual.ofDual) 
Arguments: (α : Type u_1)
Goal: GaloisConnection (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual)
-- TopologicalSpace.generateFrom_anti
@[mono]
theorem generateFrom_anti {α} {g₁ g₂ : Set (Set α)} (h : g₁ ⊆ g₂) :
    generateFrom g₂ ≤ generateFrom g₁ 
Arguments: {α : Type u_1} {g₁ g₂ : Set (Set α)} (h : g₁ ⊆ g₂)
Goal: TopologicalSpace.generateFrom g₂ ≤ TopologicalSpace.generateFrom g₁
-- TopologicalSpace.generateFrom_setOf_isOpen
theorem generateFrom_setOf_isOpen (t : TopologicalSpace α) :
    generateFrom { s | IsOpen[t] s } = t 
Arguments: {α : Type u} (t : TopologicalSpace α)
Goal: TopologicalSpace.generateFrom {s | IsOpen s} = t
-- TopologicalSpace.leftInverse_generateFrom
theorem leftInverse_generateFrom :
    LeftInverse generateFrom fun t : TopologicalSpace α => { s | IsOpen[t] s } 
Arguments: {α : Type u}
Goal: Function.LeftInverse TopologicalSpace.generateFrom fun t => {s | IsOpen s}
-- TopologicalSpace.generateFrom_surjective
theorem generateFrom_surjective : Surjective (generateFrom : Set (Set α) → TopologicalSpace α) 
Arguments: {α : Type u}
Goal: Function.Surjective TopologicalSpace.generateFrom
-- TopologicalSpace.setOf_isOpen_injective
theorem setOf_isOpen_injective : Injective fun t : TopologicalSpace α => { s | IsOpen[t] s } 
Arguments: {α : Type u}
Goal: Function.Injective fun t => {s | IsOpen s}
-- IsOpen.mono
theorem IsOpen.mono (hs : IsOpen[t₂] s) (h : t₁ ≤ t₂) : IsOpen[t₁] s 
Arguments: {α : Type u_1} {t₁ t₂ : TopologicalSpace α} {s : Set α} (hs : IsOpen s) (h : t₁ ≤ t₂)
Goal: IsOpen s
-- IsClosed.mono
theorem IsClosed.mono (hs : IsClosed[t₂] s) (h : t₁ ≤ t₂) : IsClosed[t₁] s 
Arguments: {α : Type u_1} {t₁ t₂ : TopologicalSpace α} {s : Set α} (hs : IsClosed s) (h : t₁ ≤ t₂)
Goal: IsClosed s
-- closure.mono
theorem closure.mono (h : t₁ ≤ t₂) : closure[t₁] s ⊆ closure[t₂] s 
Arguments: {α : Type u_1} {t₁ t₂ : TopologicalSpace α} {s : Set α} (h : t₁ ≤ t₂)
Goal: closure s ⊆ closure s
-- isOpen_implies_isOpen_iff
theorem isOpen_implies_isOpen_iff : (∀ s, IsOpen[t₁] s → IsOpen[t₂] s) ↔ t₂ ≤ t₁ 
Arguments: {α : Type u_1} {t₁ t₂ : TopologicalSpace α}
Goal: (∀ (s : Set α), IsOpen s → IsOpen s) ↔ t₂ ≤ t₁
-- TopologicalSpace.isOpen_top_iff
theorem TopologicalSpace.isOpen_top_iff {α} (U : Set α) : IsOpen[⊤] U ↔ U = ∅ ∨ U = univ 
Arguments: {α : Type u_2} (U : Set α)
Goal: IsOpen U ↔ U = ∅ ∨ U = Set.univ
-- DiscreteTopology.eq_bot
class DiscreteTopology (α : Type*) [t : TopologicalSpace α] : Prop where
    eq_bot : t = ⊥
Arguments: {α : Type u_2} [t : TopologicalSpace α] [self : DiscreteTopology α]
Goal: t = ⊥
-- discreteTopology_bot
theorem discreteTopology_bot (α : Type*) : @DiscreteTopology α ⊥ 
Arguments: (α : Type u_2)
Goal: DiscreteTopology α
-- isOpen_discrete
@[simp]
theorem isOpen_discrete (s : Set α) : IsOpen s 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] (s : Set α)
Goal: IsOpen s
-- isClosed_discrete
@[simp] theorem isClosed_discrete (s : Set α) : IsClosed s 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] (s : Set α)
Goal: IsClosed s
-- closure_discrete
@[simp] theorem closure_discrete (s : Set α) : closure s = s 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] (s : Set α)
Goal: closure s = s
-- dense_discrete
@[simp] theorem dense_discrete {s : Set α} : Dense s ↔ s = univ 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] {s : Set α}
Goal: Dense s ↔ s = Set.univ
-- denseRange_discrete
@[simp]
theorem denseRange_discrete {ι : Type*} {f : ι → α} : DenseRange f ↔ Surjective f 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] {ι : Type u_3} {f : ι → α}
Goal: DenseRange f ↔ Function.Surjective f
-- continuous_of_discreteTopology
@[nontriviality, continuity, fun_prop]
theorem continuous_of_discreteTopology [TopologicalSpace β] {f : α → β} : Continuous f 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] {β : Type u_2} [TopologicalSpace β] {f : α → β}
Goal: Continuous f
-- continuous_discrete_rng
theorem continuous_discrete_rng [TopologicalSpace β] [DiscreteTopology β]
    {f : α → β} : Continuous f ↔ ∀ b : β, IsOpen (f ⁻¹' {b}) 
Arguments: {α : Type u_1} [TopologicalSpace α] {β : Type u_2} [TopologicalSpace β] [DiscreteTopology β] {f : α → β}
Goal: Continuous f ↔ ∀ (b : β), IsOpen (f ⁻¹' {b})
-- nhds_discrete
@[simp]
theorem nhds_discrete (α : Type*) [TopologicalSpace α] [DiscreteTopology α] : @nhds α _ = pure 
Arguments: (α : Type u_3) [TopologicalSpace α] [DiscreteTopology α]
Goal: 𝓝 = pure
-- mem_nhds_discrete
theorem mem_nhds_discrete {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ x ∈ s 
Arguments: {α : Type u_1} [TopologicalSpace α] [DiscreteTopology α] {x : α} {s : Set α}
Goal: s ∈ 𝓝 x ↔ x ∈ s
-- le_of_nhds_le_nhds
theorem le_of_nhds_le_nhds (h : ∀ x, @nhds α t₁ x ≤ @nhds α t₂ x) : t₁ ≤ t₂ 
Arguments: {α : Type u_1} {t₁ t₂ : TopologicalSpace α} (h : ∀ (x : α), 𝓝 x ≤ 𝓝 x)
Goal: t₁ ≤ t₂
-- eq_bot_of_singletons_open
theorem eq_bot_of_singletons_open {t : TopologicalSpace α} (h : ∀ x, IsOpen[t] {x}) : t = ⊥ 
Arguments: {α : Type u_1} {t : TopologicalSpace α} (h : ∀ (x : α), IsOpen {x})
Goal: t = ⊥
-- forall_open_iff_discrete
theorem forall_open_iff_discrete {X : Type*} [TopologicalSpace X] :
    (∀ s : Set X, IsOpen s) ↔ DiscreteTopology X 
Arguments: {X : Type u_2} [TopologicalSpace X]
Goal: (∀ (s : Set X), IsOpen s) ↔ DiscreteTopology X
-- discreteTopology_iff_forall_isClosed
theorem discreteTopology_iff_forall_isClosed [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ s : Set α, IsClosed s 
Arguments: {α : Type u_1} [TopologicalSpace α]
Goal: DiscreteTopology α ↔ ∀ (s : Set α), IsClosed s
-- singletons_open_iff_discrete
theorem singletons_open_iff_discrete {X : Type*} [TopologicalSpace X] :
    (∀ a : X, IsOpen ({a} : Set X)) ↔ DiscreteTopology X 
Arguments: {X : Type u_2} [TopologicalSpace X]
Goal: (∀ (a : X), IsOpen {a}) ↔ DiscreteTopology X
-- discreteTopology_iff_singleton_mem_nhds
theorem discreteTopology_iff_singleton_mem_nhds [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, {x} ∈ 𝓝 x 
Arguments: {α : Type u_1} [TopologicalSpace α]
Goal: DiscreteTopology α ↔ ∀ (x : α), {x} ∈ 𝓝 x
-- discreteTopology_iff_nhds
theorem discreteTopology_iff_nhds [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, 𝓝 x = pure x 
Arguments: {α : Type u_1} [TopologicalSpace α]
Goal: DiscreteTopology α ↔ ∀ (x : α), 𝓝 x = pure x
-- discreteTopology_iff_nhds_ne
theorem discreteTopology_iff_nhds_ne [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ x : α, 𝓝[≠] x = ⊥ 
Arguments: {α : Type u_1} [TopologicalSpace α]
Goal: DiscreteTopology α ↔ ∀ (x : α), 𝓝[≠] x = ⊥
-- DiscreteTopology.of_continuous_injective
theorem DiscreteTopology.of_continuous_injective
    {β : Type*} [TopologicalSpace α] [TopologicalSpace β] [DiscreteTopology β] {f : α → β}
    (hc : Continuous f) (hinj : Injective f) : DiscreteTopology α 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] [TopologicalSpace β] [DiscreteTopology β] {f : α → β} (hc : Continuous f) (hinj : Function.Injective f)
Goal: DiscreteTopology α
-- isOpen_induced_iff
theorem isOpen_induced_iff [t : TopologicalSpace β] {s : Set α} {f : α → β} :
    IsOpen[t.induced f] s ↔ ∃ t, IsOpen t ∧ f ⁻¹' t = s 
Arguments: {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {s : Set α} {f : α → β}
Goal: IsOpen s ↔ ∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = s
-- isClosed_induced_iff
theorem isClosed_induced_iff [t : TopologicalSpace β] {s : Set α} {f : α → β} :
    IsClosed[t.induced f] s ↔ ∃ t, IsClosed t ∧ f ⁻¹' t = s 
Arguments: {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {s : Set α} {f : α → β}
Goal: IsClosed s ↔ ∃ t_1, IsClosed t_1 ∧ f ⁻¹' t_1 = s
-- isOpen_coinduced
theorem isOpen_coinduced {t : TopologicalSpace α} {s : Set β} {f : α → β} :
    IsOpen[t.coinduced f] s ↔ IsOpen (f ⁻¹' s) 
Arguments: {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}
Goal: IsOpen s ↔ IsOpen (f ⁻¹' s)
-- isClosed_coinduced
theorem isClosed_coinduced {t : TopologicalSpace α} {s : Set β} {f : α → β} :
    IsClosed[t.coinduced f] s ↔ IsClosed (f ⁻¹' s) 
Arguments: {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}
Goal: IsClosed s ↔ IsClosed (f ⁻¹' s)
-- preimage_nhds_coinduced
theorem preimage_nhds_coinduced [TopologicalSpace α] {π : α → β} {s : Set β} {a : α}
    (hs : s ∈ @nhds β (TopologicalSpace.coinduced π ‹_›) (π a)) : π ⁻¹' s ∈ 𝓝 a 
Arguments: {α : Type u_1} {β : Type u_2} [TopologicalSpace α] {π : α → β} {s : Set β} {a : α} (hs : s ∈ 𝓝 (π a))
Goal: π ⁻¹' s ∈ 𝓝 a
-- Continuous.coinduced_le
theorem Continuous.coinduced_le (h : Continuous[t, t'] f) : t.coinduced f ≤ t' 
Arguments: {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {t' : TopologicalSpace β} {f : α → β} (h : Continuous f)
Goal: TopologicalSpace.coinduced f t ≤ t'
-- coinduced_le_iff_le_induced
theorem coinduced_le_iff_le_induced {f : α → β} {tα : TopologicalSpace α}
    {tβ : TopologicalSpace β} : tα.coinduced f ≤ tβ ↔ tα ≤ tβ.induced f 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {tα : TopologicalSpace α} {tβ : TopologicalSpace β}
Goal: TopologicalSpace.coinduced f tα ≤ tβ ↔ tα ≤ TopologicalSpace.induced f tβ
-- Continuous.le_induced
theorem Continuous.le_induced (h : Continuous[t, t'] f) : t ≤ t'.induced f 
Arguments: {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {t' : TopologicalSpace β} {f : α → β} (h : Continuous f)
Goal: t ≤ TopologicalSpace.induced f t'
-- gc_coinduced_induced
theorem gc_coinduced_induced (f : α → β) :
    GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f)
-- induced_mono
theorem induced_mono (h : t₁ ≤ t₂) : t₁.induced g ≤ t₂.induced g 
Arguments: {α : Type u_1} {β : Type u_2} {t₁ t₂ : TopologicalSpace α} {g : β → α} (h : t₁ ≤ t₂)
Goal: TopologicalSpace.induced g t₁ ≤ TopologicalSpace.induced g t₂
-- coinduced_mono
theorem coinduced_mono (h : t₁ ≤ t₂) : t₁.coinduced f ≤ t₂.coinduced f 
Arguments: {α : Type u_1} {β : Type u_2} {t₁ t₂ : TopologicalSpace α} {f : α → β} (h : t₁ ≤ t₂)
Goal: TopologicalSpace.coinduced f t₁ ≤ TopologicalSpace.coinduced f t₂
-- induced_top
@[simp]
theorem induced_top : (⊤ : TopologicalSpace α).induced g = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} {g : β → α}
Goal: TopologicalSpace.induced g ⊤ = ⊤
-- induced_inf
@[simp]
theorem induced_inf : (t₁ ⊓ t₂).induced g = t₁.induced g ⊓ t₂.induced g 
Arguments: {α : Type u_1} {β : Type u_2} {t₁ t₂ : TopologicalSpace α} {g : β → α}
Goal: TopologicalSpace.induced g (t₁ ⊓ t₂) = TopologicalSpace.induced g t₁ ⊓ TopologicalSpace.induced g t₂
-- induced_iInf
@[simp]
theorem induced_iInf {ι : Sort w} {t : ι → TopologicalSpace α} :
    (⨅ i, t i).induced g = ⨅ i, (t i).induced g 
Arguments: {α : Type u_1} {β : Type u_2} {g : β → α} {ι : Sort w} {t : ι → TopologicalSpace α}
Goal: TopologicalSpace.induced g (⨅ i, t i) = ⨅ i, TopologicalSpace.induced g (t i)
-- coinduced_bot
@[simp]
theorem coinduced_bot : (⊥ : TopologicalSpace α).coinduced f = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β}
Goal: TopologicalSpace.coinduced f ⊥ = ⊥
-- coinduced_sup
@[simp]
theorem coinduced_sup : (t₁ ⊔ t₂).coinduced f = t₁.coinduced f ⊔ t₂.coinduced f 
Arguments: {α : Type u_1} {β : Type u_2} {t₁ t₂ : TopologicalSpace α} {f : α → β}
Goal: TopologicalSpace.coinduced f (t₁ ⊔ t₂) = TopologicalSpace.coinduced f t₁ ⊔ TopologicalSpace.coinduced f t₂
-- coinduced_iSup
@[simp]
theorem coinduced_iSup {ι : Sort w} {t : ι → TopologicalSpace α} :
    (⨆ i, t i).coinduced f = ⨆ i, (t i).coinduced f 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {ι : Sort w} {t : ι → TopologicalSpace α}
Goal: TopologicalSpace.coinduced f (⨆ i, t i) = ⨆ i, TopologicalSpace.coinduced f (t i)
-- induced_id
theorem induced_id [t : TopologicalSpace α] : t.induced id = t 
Arguments: {α : Type u_1} [t : TopologicalSpace α]
Goal: TopologicalSpace.induced id t = t
-- induced_compose
theorem induced_compose {tγ : TopologicalSpace γ} {f : α → β} {g : β → γ} :
    (tγ.induced g).induced f = tγ.induced (g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {tγ : TopologicalSpace γ} {f : α → β} {g : β → γ}
Goal: TopologicalSpace.induced f (TopologicalSpace.induced g tγ) = TopologicalSpace.induced (g ∘ f) tγ
-- induced_const
theorem induced_const [t : TopologicalSpace α] {x : α} : (t.induced fun _ : β => x) = ⊤ 
Arguments: {α : Type u_1} {β : Type u_2} [t : TopologicalSpace α] {x : α}
Goal: TopologicalSpace.induced (fun x_1 => x) t = ⊤
-- coinduced_id
theorem coinduced_id [t : TopologicalSpace α] : t.coinduced id = t 
Arguments: {α : Type u_1} [t : TopologicalSpace α]
Goal: TopologicalSpace.coinduced id t = t
-- coinduced_compose
theorem coinduced_compose [tα : TopologicalSpace α] {f : α → β} {g : β → γ} :
    (tα.coinduced f).coinduced g = tα.coinduced (g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [tα : TopologicalSpace α] {f : α → β} {g : β → γ}
Goal: TopologicalSpace.coinduced g (TopologicalSpace.coinduced f tα) = TopologicalSpace.coinduced (g ∘ f) tα