File: Mathlib/Topology/List.lean

full_name: instTopologicalSpaceList
code: instance : TopologicalSpace (List α) 
goal: TopologicalSpace (List α)

full_name: nhds_list
code: theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as 
goal: 𝓝 as = traverse 𝓝 as

full_name: nhds_nil
code: @[simp]
theorem nhds_nil : 𝓝 ([] : List α) = pure [] 
goal: 𝓝 [] = pure []

full_name: nhds_cons
code: theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*> 𝓝 l 
goal: 𝓝 (a :: l) = Seq.seq (List.cons <$> 𝓝 a) fun x => 𝓝 l

full_name: List.tendsto_cons
code: theorem List.tendsto_cons {a : α} {l : List α} :
    Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a::l)) 
goal: Filter.Tendsto (fun p => p.1 :: p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: l))

full_name: Filter.Tendsto.cons
code: 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)) 
goal: Filter.Tendsto (fun a => f a :: g a) a (𝓝 (b :: l))

full_name: List.tendsto_cons_iff
code: 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 
goal: Filter.Tendsto f (𝓝 (a :: l)) b ↔ Filter.Tendsto (fun p => f (p.1 :: p.2)) (𝓝 a ×ˢ 𝓝 l) b

full_name: List.continuous_cons
code: theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α) 
goal: Continuous fun x => x.1 :: x.2

full_name: List.tendsto_nhds
code: 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)
  
goal: Filter.Tendsto f (𝓝 l) (r l)

full_name: List.instDiscreteTopology
code: instance [DiscreteTopology α] : DiscreteTopology (List α) 
goal: DiscreteTopology (List α)

full_name: List.continuousAt_length
code: theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l 
goal: ContinuousAt List.length l

full_name: List.tendsto_insertNth'
code: theorem tendsto_insertNth' {a : α} :
    ∀ {n : ℕ} {l : List α},
      Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n a l))
  
goal: Filter.Tendsto (fun p => List.insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (List.insertNth n a l))

full_name: List.tendsto_insertNth
code: 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)) 
goal: Filter.Tendsto (fun b => List.insertNth n (f b) (g b)) b (𝓝 (List.insertNth n a l))

full_name: List.continuous_insertNth
code: theorem continuous_insertNth {n : ℕ} : Continuous fun p : α × List α => insertNth n p.1 p.2 
goal: Continuous fun p => List.insertNth n p.1 p.2

full_name: List.tendsto_eraseIdx
code: theorem tendsto_eraseIdx :
    ∀ {n : ℕ} {l : List α}, Tendsto (eraseIdx · n) (𝓝 l) (𝓝 (eraseIdx l n))
  
goal: Filter.Tendsto (fun x => x.eraseIdx n) (𝓝 l) (𝓝 (l.eraseIdx n))

full_name: List.continuous_eraseIdx
code: theorem continuous_eraseIdx {n : ℕ} : Continuous fun l : List α => eraseIdx l n 
goal: Continuous fun l => l.eraseIdx n

full_name: List.tendsto_prod
code: @[to_additive]
theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
    Tendsto List.prod (𝓝 l) (𝓝 l.prod) 
goal: Filter.Tendsto List.prod (𝓝 l) (𝓝 l.prod)

full_name: List.tendsto_sum
code: @[to_additive]
theorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :
    Tendsto List.prod (𝓝 l) (𝓝 l.prod) 
goal: Filter.Tendsto List.sum (𝓝 l) (𝓝 l.sum)

full_name: List.continuous_prod
code: @[to_additive]
theorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α) 
goal: Continuous List.prod

full_name: List.continuous_sum
code: @[to_additive]
theorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α) 
goal: Continuous List.sum

full_name: Vector.instTopologicalSpaceVector
code: instance (n : ℕ) : TopologicalSpace (Vector α n) 
goal: TopologicalSpace (Mathlib.Vector α n)

full_name: Vector.tendsto_cons
code: theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :
    Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l)) 
goal: Filter.Tendsto (fun p => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l))

full_name: Vector.tendsto_insertNth
code: 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))
  
goal: Filter.Tendsto (fun p => Mathlib.Vector.insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (Mathlib.Vector.insertNth a i l))

full_name: Vector.continuous_insertNth'
code: theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :
    Continuous fun p : α × Vector α n => Vector.insertNth p.1 i p.2 
goal: Continuous fun p => Mathlib.Vector.insertNth p.1 i p.2

full_name: Vector.continuous_insertNth
code: 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) 
goal: Continuous fun b => Mathlib.Vector.insertNth (f b) i (g b)

full_name: Vector.continuousAt_eraseIdx
code: theorem continuousAt_eraseIdx {n : ℕ} {i : Fin (n + 1)} :
    ∀ {l : Vector α (n + 1)}, ContinuousAt (Vector.eraseIdx i) l
  
goal: ContinuousAt (Mathlib.Vector.eraseIdx i) l

full_name: Vector.continuous_eraseIdx
code: theorem continuous_eraseIdx {n : ℕ} {i : Fin (n + 1)} :
    Continuous (Vector.eraseIdx i : Vector α (n + 1) → Vector α n) 
goal: Continuous (Mathlib.Vector.eraseIdx i)