File: Mathlib/Topology/ContinuousOn.lean

full_name: nhds_bind_nhdsWithin
code: @[simp]
theorem nhds_bind_nhdsWithin {a : α} {s : Set α} : ((𝓝 a).bind fun x => 𝓝[s] x) = 𝓝[s] a 
goal: ((𝓝 a).bind fun x => 𝓝[s] x) = 𝓝[s] a

full_name: eventually_nhds_nhdsWithin
code: @[simp]
theorem eventually_nhds_nhdsWithin {a : α} {s : Set α} {p : α → Prop} :
    (∀ᶠ y in 𝓝 a, ∀ᶠ x in 𝓝[s] y, p x) ↔ ∀ᶠ x in 𝓝[s] a, p x 
goal: (∀ᶠ (y : α) in 𝓝 a, ∀ᶠ (x : α) in 𝓝[s] y, p x) ↔ ∀ᶠ (x : α) in 𝓝[s] a, p x

full_name: eventually_nhdsWithin_iff
code: theorem eventually_nhdsWithin_iff {a : α} {s : Set α} {p : α → Prop} :
    (∀ᶠ x in 𝓝[s] a, p x) ↔ ∀ᶠ x in 𝓝 a, x ∈ s → p x 
goal: (∀ᶠ (x : α) in 𝓝[s] a, p x) ↔ ∀ᶠ (x : α) in 𝓝 a, x ∈ s → p x

full_name: frequently_nhdsWithin_iff
code: theorem frequently_nhdsWithin_iff {z : α} {s : Set α} {p : α → Prop} :
    (∃ᶠ x in 𝓝[s] z, p x) ↔ ∃ᶠ x in 𝓝 z, p x ∧ x ∈ s 
goal: (∃ᶠ (x : α) in 𝓝[s] z, p x) ↔ ∃ᶠ (x : α) in 𝓝 z, p x ∧ x ∈ s

full_name: mem_closure_ne_iff_frequently_within
code: theorem mem_closure_ne_iff_frequently_within {z : α} {s : Set α} :
    z ∈ closure (s \ {z}) ↔ ∃ᶠ x in 𝓝[≠] z, x ∈ s 
goal: z ∈ closure (s \ {z}) ↔ ∃ᶠ (x : α) in 𝓝[≠] z, x ∈ s

full_name: eventually_nhdsWithin_nhdsWithin
code: @[simp]
theorem eventually_nhdsWithin_nhdsWithin {a : α} {s : Set α} {p : α → Prop} :
    (∀ᶠ y in 𝓝[s] a, ∀ᶠ x in 𝓝[s] y, p x) ↔ ∀ᶠ x in 𝓝[s] a, p x 
goal: (∀ᶠ (y : α) in 𝓝[s] a, ∀ᶠ (x : α) in 𝓝[s] y, p x) ↔ ∀ᶠ (x : α) in 𝓝[s] a, p x

full_name: nhdsWithin_eq
code: theorem nhdsWithin_eq (a : α) (s : Set α) :
    𝓝[s] a = ⨅ t ∈ { t : Set α | a ∈ t ∧ IsOpen t }, 𝓟 (t ∩ s) 
goal: 𝓝[s] a = ⨅ t ∈ {t | a ∈ t ∧ IsOpen t}, 𝓟 (t ∩ s)

full_name: nhdsWithin_univ
code: @[simp] lemma nhdsWithin_univ (a : α) : 𝓝[Set.univ] a = 𝓝 a 
goal: 𝓝[Set.univ] a = 𝓝 a

full_name: nhdsWithin_hasBasis
code: theorem nhdsWithin_hasBasis {p : β → Prop} {s : β → Set α} {a : α} (h : (𝓝 a).HasBasis p s)
    (t : Set α) : (𝓝[t] a).HasBasis p fun i => s i ∩ t 
goal: (𝓝[t] a).HasBasis p fun i => s i ∩ t

full_name: nhdsWithin_basis_open
code: theorem nhdsWithin_basis_open (a : α) (t : Set α) :
    (𝓝[t] a).HasBasis (fun u => a ∈ u ∧ IsOpen u) fun u => u ∩ t 
goal: (𝓝[t] a).HasBasis (fun u => a ∈ u ∧ IsOpen u) fun u => u ∩ t

full_name: mem_nhdsWithin
code: theorem mem_nhdsWithin {t : Set α} {a : α} {s : Set α} :
    t ∈ 𝓝[s] a ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t 
goal: t ∈ 𝓝[s] a ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t

full_name: mem_nhdsWithin_iff_exists_mem_nhds_inter
code: theorem mem_nhdsWithin_iff_exists_mem_nhds_inter {t : Set α} {a : α} {s : Set α} :
    t ∈ 𝓝[s] a ↔ ∃ u ∈ 𝓝 a, u ∩ s ⊆ t 
goal: t ∈ 𝓝[s] a ↔ ∃ u ∈ 𝓝 a, u ∩ s ⊆ t

full_name: diff_mem_nhdsWithin_compl
code: theorem diff_mem_nhdsWithin_compl {x : α} {s : Set α} (hs : s ∈ 𝓝 x) (t : Set α) :
    s \ t ∈ 𝓝[tᶜ] x 
goal: s \ t ∈ 𝓝[tᶜ] x

full_name: diff_mem_nhdsWithin_diff
code: theorem diff_mem_nhdsWithin_diff {x : α} {s t : Set α} (hs : s ∈ 𝓝[t] x) (t' : Set α) :
    s \ t' ∈ 𝓝[t \ t'] x 
goal: s \ t' ∈ 𝓝[t \ t'] x

full_name: nhds_of_nhdsWithin_of_nhds
code: theorem nhds_of_nhdsWithin_of_nhds {s t : Set α} {a : α} (h1 : s ∈ 𝓝 a) (h2 : t ∈ 𝓝[s] a) :
    t ∈ 𝓝 a 
goal: t ∈ 𝓝 a

full_name: mem_nhdsWithin_iff_eventually
code: theorem mem_nhdsWithin_iff_eventually {s t : Set α} {x : α} :
    t ∈ 𝓝[s] x ↔ ∀ᶠ y in 𝓝 x, y ∈ s → y ∈ t 
goal: t ∈ 𝓝[s] x ↔ ∀ᶠ (y : α) in 𝓝 x, y ∈ s → y ∈ t

full_name: mem_nhdsWithin_iff_eventuallyEq
code: theorem mem_nhdsWithin_iff_eventuallyEq {s t : Set α} {x : α} :
    t ∈ 𝓝[s] x ↔ s =ᶠ[𝓝 x] (s ∩ t : Set α) 
goal: t ∈ 𝓝[s] x ↔ s =ᶠ[𝓝 x] s ∩ t

full_name: nhdsWithin_eq_iff_eventuallyEq
code: theorem nhdsWithin_eq_iff_eventuallyEq {s t : Set α} {x : α} : 𝓝[s] x = 𝓝[t] x ↔ s =ᶠ[𝓝 x] t 
goal: 𝓝[s] x = 𝓝[t] x ↔ s =ᶠ[𝓝 x] t

full_name: nhdsWithin_le_iff
code: theorem nhdsWithin_le_iff {s t : Set α} {x : α} : 𝓝[s] x ≤ 𝓝[t] x ↔ t ∈ 𝓝[s] x 
goal: 𝓝[s] x ≤ 𝓝[t] x ↔ t ∈ 𝓝[s] x

full_name: preimage_nhdsWithin_coinduced'
code: theorem preimage_nhdsWithin_coinduced' {π : α → β} {s : Set β} {t : Set α} {a : α} (h : a ∈ t)
    (hs : s ∈ @nhds β (.coinduced (fun x : t => π x) inferInstance) (π a)) :
    π ⁻¹' s ∈ 𝓝[t] a 
goal: π ⁻¹' s ∈ 𝓝[t] a

full_name: mem_nhdsWithin_of_mem_nhds
code: theorem mem_nhdsWithin_of_mem_nhds {s t : Set α} {a : α} (h : s ∈ 𝓝 a) : s ∈ 𝓝[t] a 
goal: s ∈ 𝓝[t] a

full_name: self_mem_nhdsWithin
code: theorem self_mem_nhdsWithin {a : α} {s : Set α} : s ∈ 𝓝[s] a 
goal: s ∈ 𝓝[s] a

full_name: eventually_mem_nhdsWithin
code: theorem eventually_mem_nhdsWithin {a : α} {s : Set α} : ∀ᶠ x in 𝓝[s] a, x ∈ s 
goal: ∀ᶠ (x : α) in 𝓝[s] a, x ∈ s

full_name: inter_mem_nhdsWithin
code: theorem inter_mem_nhdsWithin (s : Set α) {t : Set α} {a : α} (h : t ∈ 𝓝 a) : s ∩ t ∈ 𝓝[s] a 
goal: s ∩ t ∈ 𝓝[s] a

full_name: pure_le_nhdsWithin
code: theorem pure_le_nhdsWithin {a : α} {s : Set α} (ha : a ∈ s) : pure a ≤ 𝓝[s] a 
goal: pure a ≤ 𝓝[s] a

full_name: mem_of_mem_nhdsWithin
code: theorem mem_of_mem_nhdsWithin {a : α} {s t : Set α} (ha : a ∈ s) (ht : t ∈ 𝓝[s] a) : a ∈ t 
goal: a ∈ t

full_name: Filter.Eventually.self_of_nhdsWithin
code: theorem Filter.Eventually.self_of_nhdsWithin {p : α → Prop} {s : Set α} {x : α}
    (h : ∀ᶠ y in 𝓝[s] x, p y) (hx : x ∈ s) : p x 
goal: p x

full_name: tendsto_const_nhdsWithin
code: theorem tendsto_const_nhdsWithin {l : Filter β} {s : Set α} {a : α} (ha : a ∈ s) :
    Tendsto (fun _ : β => a) l (𝓝[s] a) 
goal: Filter.Tendsto (fun x => a) l (𝓝[s] a)

full_name: nhdsWithin_restrict''
code: theorem nhdsWithin_restrict'' {a : α} (s : Set α) {t : Set α} (h : t ∈ 𝓝[s] a) :
    𝓝[s] a = 𝓝[s ∩ t] a 
goal: 𝓝[s] a = 𝓝[s ∩ t] a

full_name: nhdsWithin_restrict'
code: theorem nhdsWithin_restrict' {a : α} (s : Set α) {t : Set α} (h : t ∈ 𝓝 a) : 𝓝[s] a = 𝓝[s ∩ t] a 
goal: 𝓝[s] a = 𝓝[s ∩ t] a

full_name: nhdsWithin_restrict
code: theorem nhdsWithin_restrict {a : α} (s : Set α) {t : Set α} (h₀ : a ∈ t) (h₁ : IsOpen t) :
    𝓝[s] a = 𝓝[s ∩ t] a 
goal: 𝓝[s] a = 𝓝[s ∩ t] a

full_name: nhdsWithin_le_of_mem
code: theorem nhdsWithin_le_of_mem {a : α} {s t : Set α} (h : s ∈ 𝓝[t] a) : 𝓝[t] a ≤ 𝓝[s] a 
goal: 𝓝[t] a ≤ 𝓝[s] a

full_name: nhdsWithin_le_nhds
code: theorem nhdsWithin_le_nhds {a : α} {s : Set α} : 𝓝[s] a ≤ 𝓝 a 
goal: 𝓝[s] a ≤ 𝓝 a

full_name: nhdsWithin_eq_nhdsWithin'
code: theorem nhdsWithin_eq_nhdsWithin' {a : α} {s t u : Set α} (hs : s ∈ 𝓝 a) (h₂ : t ∩ s = u ∩ s) :
    𝓝[t] a = 𝓝[u] a 
goal: 𝓝[t] a = 𝓝[u] a

full_name: nhdsWithin_eq_nhdsWithin
code: theorem nhdsWithin_eq_nhdsWithin {a : α} {s t u : Set α} (h₀ : a ∈ s) (h₁ : IsOpen s)
    (h₂ : t ∩ s = u ∩ s) : 𝓝[t] a = 𝓝[u] a 
goal: 𝓝[t] a = 𝓝[u] a

full_name: nhdsWithin_eq_nhds
code: @[simp] theorem nhdsWithin_eq_nhds {a : α} {s : Set α} : 𝓝[s] a = 𝓝 a ↔ s ∈ 𝓝 a 
goal: 𝓝[s] a = 𝓝 a ↔ s ∈ 𝓝 a

full_name: IsOpen.nhdsWithin_eq
code: theorem IsOpen.nhdsWithin_eq {a : α} {s : Set α} (h : IsOpen s) (ha : a ∈ s) : 𝓝[s] a = 𝓝 a 
goal: 𝓝[s] a = 𝓝 a

full_name: preimage_nhds_within_coinduced
code: theorem preimage_nhds_within_coinduced {π : α → β} {s : Set β} {t : Set α} {a : α} (h : a ∈ t)
    (ht : IsOpen t)
    (hs : s ∈ @nhds β (.coinduced (fun x : t => π x) inferInstance) (π a)) :
    π ⁻¹' s ∈ 𝓝 a 
goal: π ⁻¹' s ∈ 𝓝 a

full_name: nhdsWithin_empty
code: @[simp]
theorem nhdsWithin_empty (a : α) : 𝓝[∅] a = ⊥ 
goal: 𝓝[∅] a = ⊥

full_name: nhdsWithin_union
code: theorem nhdsWithin_union (a : α) (s t : Set α) : 𝓝[s ∪ t] a = 𝓝[s] a ⊔ 𝓝[t] a 
goal: 𝓝[s ∪ t] a = 𝓝[s] a ⊔ 𝓝[t] a

full_name: nhdsWithin_biUnion
code: theorem nhdsWithin_biUnion {ι} {I : Set ι} (hI : I.Finite) (s : ι → Set α) (a : α) :
    𝓝[⋃ i ∈ I, s i] a = ⨆ i ∈ I, 𝓝[s i] a 
goal: 𝓝[⋃ i ∈ I, s i] a = ⨆ i ∈ I, 𝓝[s i] a

full_name: nhdsWithin_sUnion
code: theorem nhdsWithin_sUnion {S : Set (Set α)} (hS : S.Finite) (a : α) :
    𝓝[⋃₀ S] a = ⨆ s ∈ S, 𝓝[s] a 
goal: 𝓝[⋃₀ S] a = ⨆ s ∈ S, 𝓝[s] a

full_name: nhdsWithin_iUnion
code: theorem nhdsWithin_iUnion {ι} [Finite ι] (s : ι → Set α) (a : α) :
    𝓝[⋃ i, s i] a = ⨆ i, 𝓝[s i] a 
goal: 𝓝[⋃ i, s i] a = ⨆ i, 𝓝[s i] a

full_name: nhdsWithin_inter
code: theorem nhdsWithin_inter (a : α) (s t : Set α) : 𝓝[s ∩ t] a = 𝓝[s] a ⊓ 𝓝[t] a 
goal: 𝓝[s ∩ t] a = 𝓝[s] a ⊓ 𝓝[t] a

full_name: nhdsWithin_inter'
code: theorem nhdsWithin_inter' (a : α) (s t : Set α) : 𝓝[s ∩ t] a = 𝓝[s] a ⊓ 𝓟 t 
goal: 𝓝[s ∩ t] a = 𝓝[s] a ⊓ 𝓟 t

full_name: nhdsWithin_inter_of_mem
code: theorem nhdsWithin_inter_of_mem {a : α} {s t : Set α} (h : s ∈ 𝓝[t] a) : 𝓝[s ∩ t] a = 𝓝[t] a 
goal: 𝓝[s ∩ t] a = 𝓝[t] a

full_name: nhdsWithin_inter_of_mem'
code: theorem nhdsWithin_inter_of_mem' {a : α} {s t : Set α} (h : t ∈ 𝓝[s] a) : 𝓝[s ∩ t] a = 𝓝[s] a 
goal: 𝓝[s ∩ t] a = 𝓝[s] a

full_name: nhdsWithin_singleton
code: @[simp]
theorem nhdsWithin_singleton (a : α) : 𝓝[{a}] a = pure a 
goal: 𝓝[{a}] a = pure a

full_name: nhdsWithin_insert
code: @[simp]
theorem nhdsWithin_insert (a : α) (s : Set α) : 𝓝[insert a s] a = pure a ⊔ 𝓝[s] a 
goal: 𝓝[insert a s] a = pure a ⊔ 𝓝[s] a

full_name: mem_nhdsWithin_insert
code: theorem mem_nhdsWithin_insert {a : α} {s t : Set α} : t ∈ 𝓝[insert a s] a ↔ a ∈ t ∧ t ∈ 𝓝[s] a 
goal: t ∈ 𝓝[insert a s] a ↔ a ∈ t ∧ t ∈ 𝓝[s] a

full_name: insert_mem_nhdsWithin_insert
code: theorem insert_mem_nhdsWithin_insert {a : α} {s t : Set α} (h : t ∈ 𝓝[s] a) :
    insert a t ∈ 𝓝[insert a s] a 
goal: insert a t ∈ 𝓝[insert a s] a

full_name: insert_mem_nhds_iff
code: theorem insert_mem_nhds_iff {a : α} {s : Set α} : insert a s ∈ 𝓝 a ↔ s ∈ 𝓝[≠] a 
goal: insert a s ∈ 𝓝 a ↔ s ∈ 𝓝[≠] a

full_name: nhdsWithin_compl_singleton_sup_pure
code: @[simp]
theorem nhdsWithin_compl_singleton_sup_pure (a : α) : 𝓝[≠] a ⊔ pure a = 𝓝 a 
goal: 𝓝[≠] a ⊔ pure a = 𝓝 a

full_name: nhdsWithin_prod
code: theorem nhdsWithin_prod {α : Type*} [TopologicalSpace α] {β : Type*} [TopologicalSpace β]
    {s u : Set α} {t v : Set β} {a : α} {b : β} (hu : u ∈ 𝓝[s] a) (hv : v ∈ 𝓝[t] b) :
    u ×ˢ v ∈ 𝓝[s ×ˢ t] (a, b) 
goal: u ×ˢ v ∈ 𝓝[s ×ˢ t] (a, b)

full_name: nhdsWithin_pi_eq'
code: theorem nhdsWithin_pi_eq' {I : Set ι} (hI : I.Finite) (s : ∀ i, Set (π i)) (x : ∀ i, π i) :
    𝓝[pi I s] x = ⨅ i, comap (fun x => x i) (𝓝 (x i) ⊓ ⨅ (_ : i ∈ I), 𝓟 (s i)) 
goal: 𝓝[I.pi s] x = ⨅ i, Filter.comap (fun x => x i) (𝓝 (x i) ⊓ ⨅ (_ : i ∈ I), 𝓟 (s i))

full_name: nhdsWithin_pi_eq
code: theorem nhdsWithin_pi_eq {I : Set ι} (hI : I.Finite) (s : ∀ i, Set (π i)) (x : ∀ i, π i) :
    𝓝[pi I s] x =
      (⨅ i ∈ I, comap (fun x => x i) (𝓝[s i] x i)) ⊓
        ⨅ (i) (_ : i ∉ I), comap (fun x => x i) (𝓝 (x i)) 
goal: 𝓝[I.pi s] x =
  (⨅ i ∈ I, Filter.comap (fun x => x i) (𝓝[s i] x i)) ⊓ ⨅ i, ⨅ (_ : i ∉ I), Filter.comap (fun x => x i) (𝓝 (x i))

full_name: nhdsWithin_pi_univ_eq
code: theorem nhdsWithin_pi_univ_eq [Finite ι] (s : ∀ i, Set (π i)) (x : ∀ i, π i) :
    𝓝[pi univ s] x = ⨅ i, comap (fun x => x i) (𝓝[s i] x i) 
goal: 𝓝[Set.univ.pi s] x = ⨅ i, Filter.comap (fun x => x i) (𝓝[s i] x i)

full_name: nhdsWithin_pi_eq_bot
code: theorem nhdsWithin_pi_eq_bot {I : Set ι} {s : ∀ i, Set (π i)} {x : ∀ i, π i} :
    𝓝[pi I s] x = ⊥ ↔ ∃ i ∈ I, 𝓝[s i] x i = ⊥ 
goal: 𝓝[I.pi s] x = ⊥ ↔ ∃ i ∈ I, 𝓝[s i] x i = ⊥

full_name: nhdsWithin_pi_neBot
code: theorem nhdsWithin_pi_neBot {I : Set ι} {s : ∀ i, Set (π i)} {x : ∀ i, π i} :
    (𝓝[pi I s] x).NeBot ↔ ∀ i ∈ I, (𝓝[s i] x i).NeBot 
goal: (𝓝[I.pi s] x).NeBot ↔ ∀ i ∈ I, (𝓝[s i] x i).NeBot

full_name: instNeBotNhdsWithinUnivPi
code: instance instNeBotNhdsWithinUnivPi {s : ∀ i, Set (π i)} {x : ∀ i, π i}
    [∀ i, (𝓝[s i] x i).NeBot] : (𝓝[pi univ s] x).NeBot 
goal: (𝓝[Set.univ.pi s] x).NeBot

full_name: Pi.instNeBotNhdsWithinIio
code: instance Pi.instNeBotNhdsWithinIio [Nonempty ι] [∀ i, Preorder (π i)] {x : ∀ i, π i}
    [∀ i, (𝓝[<] x i).NeBot] : (𝓝[<] x).NeBot 
goal: (𝓝[<] x).NeBot

full_name: Pi.instNeBotNhdsWithinIoi
code: instance Pi.instNeBotNhdsWithinIoi [Nonempty ι] [∀ i, Preorder (π i)] {x : ∀ i, π i}
    [∀ i, (𝓝[>] x i).NeBot] : (𝓝[>] x).NeBot 
goal: (𝓝[>] x).NeBot

full_name: Filter.Tendsto.piecewise_nhdsWithin
code: theorem Filter.Tendsto.piecewise_nhdsWithin {f g : α → β} {t : Set α} [∀ x, Decidable (x ∈ t)]
    {a : α} {s : Set α} {l : Filter β} (h₀ : Tendsto f (𝓝[s ∩ t] a) l)
    (h₁ : Tendsto g (𝓝[s ∩ tᶜ] a) l) : Tendsto (piecewise t f g) (𝓝[s] a) l 
goal: Filter.Tendsto (t.piecewise f g) (𝓝[s] a) l

full_name: Filter.Tendsto.if_nhdsWithin
code: theorem Filter.Tendsto.if_nhdsWithin {f g : α → β} {p : α → Prop} [DecidablePred p] {a : α}
    {s : Set α} {l : Filter β} (h₀ : Tendsto f (𝓝[s ∩ { x | p x }] a) l)
    (h₁ : Tendsto g (𝓝[s ∩ { x | ¬p x }] a) l) :
    Tendsto (fun x => if p x then f x else g x) (𝓝[s] a) l 
goal: Filter.Tendsto (fun x => if p x then f x else g x) (𝓝[s] a) l

full_name: map_nhdsWithin
code: theorem map_nhdsWithin (f : α → β) (a : α) (s : Set α) :
    map f (𝓝[s] a) = ⨅ t ∈ { t : Set α | a ∈ t ∧ IsOpen t }, 𝓟 (f '' (t ∩ s)) 
goal: Filter.map f (𝓝[s] a) = ⨅ t ∈ {t | a ∈ t ∧ IsOpen t}, 𝓟 (f '' (t ∩ s))

full_name: tendsto_nhdsWithin_mono_left
code: theorem tendsto_nhdsWithin_mono_left {f : α → β} {a : α} {s t : Set α} {l : Filter β} (hst : s ⊆ t)
    (h : Tendsto f (𝓝[t] a) l) : Tendsto f (𝓝[s] a) l 
goal: Filter.Tendsto f (𝓝[s] a) l

full_name: tendsto_nhdsWithin_mono_right
code: theorem tendsto_nhdsWithin_mono_right {f : β → α} {l : Filter β} {a : α} {s t : Set α} (hst : s ⊆ t)
    (h : Tendsto f l (𝓝[s] a)) : Tendsto f l (𝓝[t] a) 
goal: Filter.Tendsto f l (𝓝[t] a)

full_name: tendsto_nhdsWithin_of_tendsto_nhds
code: theorem tendsto_nhdsWithin_of_tendsto_nhds {f : α → β} {a : α} {s : Set α} {l : Filter β}
    (h : Tendsto f (𝓝 a) l) : Tendsto f (𝓝[s] a) l 
goal: Filter.Tendsto f (𝓝[s] a) l

full_name: eventually_mem_of_tendsto_nhdsWithin
code: theorem eventually_mem_of_tendsto_nhdsWithin {f : β → α} {a : α} {s : Set α} {l : Filter β}
    (h : Tendsto f l (𝓝[s] a)) : ∀ᶠ i in l, f i ∈ s 
goal: ∀ᶠ (i : β) in l, f i ∈ s

full_name: tendsto_nhds_of_tendsto_nhdsWithin
code: theorem tendsto_nhds_of_tendsto_nhdsWithin {f : β → α} {a : α} {s : Set α} {l : Filter β}
    (h : Tendsto f l (𝓝[s] a)) : Tendsto f l (𝓝 a) 
goal: Filter.Tendsto f l (𝓝 a)

full_name: nhdsWithin_neBot_of_mem
code: theorem nhdsWithin_neBot_of_mem {s : Set α} {x : α} (hx : x ∈ s) : NeBot (𝓝[s] x) 
goal: (𝓝[s] x).NeBot

full_name: IsClosed.mem_of_nhdsWithin_neBot
code: theorem IsClosed.mem_of_nhdsWithin_neBot {s : Set α} (hs : IsClosed s) {x : α}
    (hx : NeBot <| 𝓝[s] x) : x ∈ s 
goal: x ∈ s

full_name: DenseRange.nhdsWithin_neBot
code: theorem DenseRange.nhdsWithin_neBot {ι : Type*} {f : ι → α} (h : DenseRange f) (x : α) :
    NeBot (𝓝[range f] x) 
goal: (𝓝[Set.range f] x).NeBot

full_name: mem_closure_pi
code: theorem mem_closure_pi {ι : Type*} {α : ι → Type*} [∀ i, TopologicalSpace (α i)] {I : Set ι}
    {s : ∀ i, Set (α i)} {x : ∀ i, α i} : x ∈ closure (pi I s) ↔ ∀ i ∈ I, x i ∈ closure (s i) 
goal: x ∈ closure (I.pi s) ↔ ∀ i ∈ I, x i ∈ closure (s i)

full_name: closure_pi_set
code: theorem closure_pi_set {ι : Type*} {α : ι → Type*} [∀ i, TopologicalSpace (α i)] (I : Set ι)
    (s : ∀ i, Set (α i)) : closure (pi I s) = pi I fun i => closure (s i) 
goal: closure (I.pi s) = I.pi fun i => closure (s i)

full_name: dense_pi
code: theorem dense_pi {ι : Type*} {α : ι → Type*} [∀ i, TopologicalSpace (α i)] {s : ∀ i, Set (α i)}
    (I : Set ι) (hs : ∀ i ∈ I, Dense (s i)) : Dense (pi I s) 
goal: Dense (I.pi s)

full_name: eventuallyEq_nhdsWithin_iff
code: theorem eventuallyEq_nhdsWithin_iff {f g : α → β} {s : Set α} {a : α} :
    f =ᶠ[𝓝[s] a] g ↔ ∀ᶠ x in 𝓝 a, x ∈ s → f x = g x 
goal: f =ᶠ[𝓝[s] a] g ↔ ∀ᶠ (x : α) in 𝓝 a, x ∈ s → f x = g x

full_name: eventuallyEq_nhdsWithin_of_eqOn
code: theorem eventuallyEq_nhdsWithin_of_eqOn {f g : α → β} {s : Set α} {a : α} (h : EqOn f g s) :
    f =ᶠ[𝓝[s] a] g 
goal: f =ᶠ[𝓝[s] a] g

full_name: Set.EqOn.eventuallyEq_nhdsWithin
code: theorem Set.EqOn.eventuallyEq_nhdsWithin {f g : α → β} {s : Set α} {a : α} (h : EqOn f g s) :
    f =ᶠ[𝓝[s] a] g 
goal: f =ᶠ[𝓝[s] a] g

full_name: tendsto_nhdsWithin_congr
code: theorem tendsto_nhdsWithin_congr {f g : α → β} {s : Set α} {a : α} {l : Filter β}
    (hfg : ∀ x ∈ s, f x = g x) (hf : Tendsto f (𝓝[s] a) l) : Tendsto g (𝓝[s] a) l 
goal: Filter.Tendsto g (𝓝[s] a) l

full_name: eventually_nhdsWithin_of_forall
code: theorem eventually_nhdsWithin_of_forall {s : Set α} {a : α} {p : α → Prop} (h : ∀ x ∈ s, p x) :
    ∀ᶠ x in 𝓝[s] a, p x 
goal: ∀ᶠ (x : α) in 𝓝[s] a, p x

full_name: tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within
code: theorem tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within {a : α} {l : Filter β} {s : Set α}
    (f : β → α) (h1 : Tendsto f l (𝓝 a)) (h2 : ∀ᶠ x in l, f x ∈ s) : Tendsto f l (𝓝[s] a) 
goal: Filter.Tendsto f l (𝓝[s] a)

full_name: tendsto_nhdsWithin_iff
code: theorem tendsto_nhdsWithin_iff {a : α} {l : Filter β} {s : Set α} {f : β → α} :
    Tendsto f l (𝓝[s] a) ↔ Tendsto f l (𝓝 a) ∧ ∀ᶠ n in l, f n ∈ s 
goal: Filter.Tendsto f l (𝓝[s] a) ↔ Filter.Tendsto f l (𝓝 a) ∧ ∀ᶠ (n : β) in l, f n ∈ s

full_name: tendsto_nhdsWithin_range
code: @[simp]
theorem tendsto_nhdsWithin_range {a : α} {l : Filter β} {f : β → α} :
    Tendsto f l (𝓝[range f] a) ↔ Tendsto f l (𝓝 a) 
goal: Filter.Tendsto f l (𝓝[Set.range f] a) ↔ Filter.Tendsto f l (𝓝 a)

full_name: Filter.EventuallyEq.eq_of_nhdsWithin
code: theorem Filter.EventuallyEq.eq_of_nhdsWithin {s : Set α} {f g : α → β} {a : α} (h : f =ᶠ[𝓝[s] a] g)
    (hmem : a ∈ s) : f a = g a 
goal: f a = g a

full_name: eventually_nhdsWithin_of_eventually_nhds
code: theorem eventually_nhdsWithin_of_eventually_nhds {α : Type*} [TopologicalSpace α] {s : Set α}
    {a : α} {p : α → Prop} (h : ∀ᶠ x in 𝓝 a, p x) : ∀ᶠ x in 𝓝[s] a, p x 
goal: ∀ᶠ (x : α) in 𝓝[s] a, p x

full_name: mem_nhdsWithin_subtype
code: theorem mem_nhdsWithin_subtype {s : Set α} {a : { x // x ∈ s }} {t u : Set { x // x ∈ s }} :
    t ∈ 𝓝[u] a ↔ t ∈ comap ((↑) : s → α) (𝓝[(↑) '' u] a) 
goal: t ∈ 𝓝[u] a ↔ t ∈ Filter.comap Subtype.val (𝓝[Subtype.val '' u] ↑a)

full_name: nhdsWithin_subtype
code: theorem nhdsWithin_subtype (s : Set α) (a : { x // x ∈ s }) (t : Set { x // x ∈ s }) :
    𝓝[t] a = comap ((↑) : s → α) (𝓝[(↑) '' t] a) 
goal: 𝓝[t] a = Filter.comap Subtype.val (𝓝[Subtype.val '' t] ↑a)

full_name: nhdsWithin_eq_map_subtype_coe
code: theorem nhdsWithin_eq_map_subtype_coe {s : Set α} {a : α} (h : a ∈ s) :
    𝓝[s] a = map ((↑) : s → α) (𝓝 ⟨a, h⟩) 
goal: 𝓝[s] a = Filter.map Subtype.val (𝓝 ⟨a, h⟩)

full_name: mem_nhds_subtype_iff_nhdsWithin
code: theorem mem_nhds_subtype_iff_nhdsWithin {s : Set α} {a : s} {t : Set s} :
    t ∈ 𝓝 a ↔ (↑) '' t ∈ 𝓝[s] (a : α) 
goal: t ∈ 𝓝 a ↔ Subtype.val '' t ∈ 𝓝[s] ↑a

full_name: preimage_coe_mem_nhds_subtype
code: theorem preimage_coe_mem_nhds_subtype {s t : Set α} {a : s} : (↑) ⁻¹' t ∈ 𝓝 a ↔ t ∈ 𝓝[s] ↑a 
goal: Subtype.val ⁻¹' t ∈ 𝓝 a ↔ t ∈ 𝓝[s] ↑a

full_name: eventually_nhds_subtype_iff
code: theorem eventually_nhds_subtype_iff (s : Set α) (a : s) (P : α → Prop) :
    (∀ᶠ x : s in 𝓝 a, P x) ↔ ∀ᶠ x in 𝓝[s] a, P x 
goal: (∀ᶠ (x : ↑s) in 𝓝 a, P ↑x) ↔ ∀ᶠ (x : α) in 𝓝[s] ↑a, P x

full_name: frequently_nhds_subtype_iff
code: theorem frequently_nhds_subtype_iff (s : Set α) (a : s) (P : α → Prop) :
    (∃ᶠ x : s in 𝓝 a, P x) ↔ ∃ᶠ x in 𝓝[s] a, P x 
goal: (∃ᶠ (x : ↑s) in 𝓝 a, P ↑x) ↔ ∃ᶠ (x : α) in 𝓝[s] ↑a, P x

full_name: tendsto_nhdsWithin_iff_subtype
code: theorem tendsto_nhdsWithin_iff_subtype {s : Set α} {a : α} (h : a ∈ s) (f : α → β) (l : Filter β) :
    Tendsto f (𝓝[s] a) l ↔ Tendsto (s.restrict f) (𝓝 ⟨a, h⟩) l 
goal: Filter.Tendsto f (𝓝[s] a) l ↔ Filter.Tendsto (s.restrict f) (𝓝 ⟨a, h⟩) l

full_name: ContinuousWithinAt.tendsto
code: /-- If a function is continuous within `s` at `x`, then it tends to `f x` within `s` by definition.
We register this fact for use with the dot notation, especially to use `Filter.Tendsto.comp` as
`ContinuousWithinAt.comp` will have a different meaning. -/
theorem ContinuousWithinAt.tendsto {f : α → β} {s : Set α} {x : α} (h : ContinuousWithinAt f s x) :
    Tendsto f (𝓝[s] x) (𝓝 (f x)) 
goal: Filter.Tendsto f (𝓝[s] x) (𝓝 (f x))

full_name: ContinuousOn.continuousWithinAt
code: theorem ContinuousOn.continuousWithinAt {f : α → β} {s : Set α} {x : α} (hf : ContinuousOn f s)
    (hx : x ∈ s) : ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: continuousWithinAt_univ
code: theorem continuousWithinAt_univ (f : α → β) (x : α) :
    ContinuousWithinAt f Set.univ x ↔ ContinuousAt f x 
goal: ContinuousWithinAt f Set.univ x ↔ ContinuousAt f x

full_name: continuous_iff_continuousOn_univ
code: theorem continuous_iff_continuousOn_univ {f : α → β} : Continuous f ↔ ContinuousOn f univ 
goal: Continuous f ↔ ContinuousOn f Set.univ

full_name: continuousWithinAt_iff_continuousAt_restrict
code: theorem continuousWithinAt_iff_continuousAt_restrict (f : α → β) {x : α} {s : Set α} (h : x ∈ s) :
    ContinuousWithinAt f s x ↔ ContinuousAt (s.restrict f) ⟨x, h⟩ 
goal: ContinuousWithinAt f s x ↔ ContinuousAt (s.restrict f) ⟨x, h⟩

full_name: ContinuousWithinAt.tendsto_nhdsWithin
code: theorem ContinuousWithinAt.tendsto_nhdsWithin {f : α → β} {x : α} {s : Set α} {t : Set β}
    (h : ContinuousWithinAt f s x) (ht : MapsTo f s t) : Tendsto f (𝓝[s] x) (𝓝[t] f x) 
goal: Filter.Tendsto f (𝓝[s] x) (𝓝[t] f x)

full_name: ContinuousWithinAt.tendsto_nhdsWithin_image
code: theorem ContinuousWithinAt.tendsto_nhdsWithin_image {f : α → β} {x : α} {s : Set α}
    (h : ContinuousWithinAt f s x) : Tendsto f (𝓝[s] x) (𝓝[f '' s] f x) 
goal: Filter.Tendsto f (𝓝[s] x) (𝓝[f '' s] f x)

full_name: ContinuousWithinAt.prod_map
code: theorem ContinuousWithinAt.prod_map {f : α → γ} {g : β → δ} {s : Set α} {t : Set β} {x : α} {y : β}
    (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g t y) :
    ContinuousWithinAt (Prod.map f g) (s ×ˢ t) (x, y) 
goal: ContinuousWithinAt (Prod.map f g) (s ×ˢ t) (x, y)

full_name: continuousWithinAt_prod_of_discrete_left
code: theorem continuousWithinAt_prod_of_discrete_left [DiscreteTopology α]
    {f : α × β → γ} {s : Set (α × β)} {x : α × β} :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt (f ⟨x.1, ·⟩) {b | (x.1, b) ∈ s} x.2 
goal: ContinuousWithinAt f s x ↔ ContinuousWithinAt (fun x_1 => f (x.1, x_1)) {b | (x.1, b) ∈ s} x.2

full_name: continuousWithinAt_prod_of_discrete_right
code: theorem continuousWithinAt_prod_of_discrete_right [DiscreteTopology β]
    {f : α × β → γ} {s : Set (α × β)} {x : α × β} :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt (f ⟨·, x.2⟩) {a | (a, x.2) ∈ s} x.1 
goal: ContinuousWithinAt f s x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) {a | (a, x.2) ∈ s} x.1

full_name: continuousAt_prod_of_discrete_left
code: theorem continuousAt_prod_of_discrete_left [DiscreteTopology α] {f : α × β → γ} {x : α × β} :
    ContinuousAt f x ↔ ContinuousAt (f ⟨x.1, ·⟩) x.2 
goal: ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x.1, x_1)) x.2

full_name: continuousAt_prod_of_discrete_right
code: theorem continuousAt_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} {x : α × β} :
    ContinuousAt f x ↔ ContinuousAt (f ⟨·, x.2⟩) x.1 
goal: ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x_1, x.2)) x.1

full_name: continuousOn_prod_of_discrete_left
code: theorem continuousOn_prod_of_discrete_left [DiscreteTopology α] {f : α × β → γ} {s : Set (α × β)} :
    ContinuousOn f s ↔ ∀ a, ContinuousOn (f ⟨a, ·⟩) {b | (a, b) ∈ s} 
goal: ContinuousOn f s ↔ ∀ (a : α), ContinuousOn (fun x => f (a, x)) {b | (a, b) ∈ s}

full_name: continuousOn_prod_of_discrete_right
code: theorem continuousOn_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} {s : Set (α × β)} :
    ContinuousOn f s ↔ ∀ b, ContinuousOn (f ⟨·, b⟩) {a | (a, b) ∈ s} 
goal: ContinuousOn f s ↔ ∀ (b : β), ContinuousOn (fun x => f (x, b)) {a | (a, b) ∈ s}

full_name: continuous_prod_of_discrete_left
code: /-- If a function `f a b` is such that `y ↦ f a b` is continuous for all `a`, and `a` lives in a
discrete space, then `f` is continuous, and vice versa. -/
theorem continuous_prod_of_discrete_left [DiscreteTopology α] {f : α × β → γ} :
    Continuous f ↔ ∀ a, Continuous (f ⟨a, ·⟩) 
goal: Continuous f ↔ ∀ (a : α), Continuous fun x => f (a, x)

full_name: continuous_prod_of_discrete_right
code: theorem continuous_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} :
    Continuous f ↔ ∀ b, Continuous (f ⟨·, b⟩) 
goal: Continuous f ↔ ∀ (b : β), Continuous fun x => f (x, b)

full_name: isOpenMap_prod_of_discrete_left
code: theorem isOpenMap_prod_of_discrete_left [DiscreteTopology α] {f : α × β → γ} :
    IsOpenMap f ↔ ∀ a, IsOpenMap (f ⟨a, ·⟩) 
goal: IsOpenMap f ↔ ∀ (a : α), IsOpenMap fun x => f (a, x)

full_name: isOpenMap_prod_of_discrete_right
code: theorem isOpenMap_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} :
    IsOpenMap f ↔ ∀ b, IsOpenMap (f ⟨·, b⟩) 
goal: IsOpenMap f ↔ ∀ (b : β), IsOpenMap fun x => f (x, b)

full_name: continuousWithinAt_pi
code: theorem continuousWithinAt_pi {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    {f : α → ∀ i, π i} {s : Set α} {x : α} :
    ContinuousWithinAt f s x ↔ ∀ i, ContinuousWithinAt (fun y => f y i) s x 
goal: ContinuousWithinAt f s x ↔ ∀ (i : ι), ContinuousWithinAt (fun y => f y i) s x

full_name: continuousOn_pi
code: theorem continuousOn_pi {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    {f : α → ∀ i, π i} {s : Set α} : ContinuousOn f s ↔ ∀ i, ContinuousOn (fun y => f y i) s 
goal: ContinuousOn f s ↔ ∀ (i : ι), ContinuousOn (fun y => f y i) s

full_name: continuousOn_pi'
code: @[fun_prop]
theorem continuousOn_pi' {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    {f : α → ∀ i, π i} {s : Set α} (hf : ∀ i, ContinuousOn (fun y => f y i) s) :
    ContinuousOn f s 
goal: ContinuousOn f s

full_name: ContinuousWithinAt.fin_insertNth
code: theorem ContinuousWithinAt.fin_insertNth {n} {π : Fin (n + 1) → Type*}
    [∀ i, TopologicalSpace (π i)] (i : Fin (n + 1)) {f : α → π i} {a : α} {s : Set α}
    (hf : ContinuousWithinAt f s a) {g : α → ∀ j : Fin n, π (i.succAbove j)}
    (hg : ContinuousWithinAt g s a) : ContinuousWithinAt (fun a => i.insertNth (f a) (g a)) s a 
goal: ContinuousWithinAt (fun a => i.insertNth (f a) (g a)) s a

full_name: ContinuousOn.fin_insertNth
code: nonrec theorem ContinuousOn.fin_insertNth {n} {π : Fin (n + 1) → Type*}
    [∀ i, TopologicalSpace (π i)] (i : Fin (n + 1)) {f : α → π i} {s : Set α}
    (hf : ContinuousOn f s) {g : α → ∀ j : Fin n, π (i.succAbove j)} (hg : ContinuousOn g s) :
    ContinuousOn (fun a => i.insertNth (f a) (g a)) s 
goal: ContinuousOn (fun a => i.insertNth (f a) (g a)) s

full_name: continuousOn_iff
code: theorem continuousOn_iff {f : α → β} {s : Set α} :
    ContinuousOn f s ↔
      ∀ x ∈ s, ∀ t : Set β, IsOpen t → f x ∈ t → ∃ u, IsOpen u ∧ x ∈ u ∧ u ∩ s ⊆ f ⁻¹' t 
goal: ContinuousOn f s ↔ ∀ x ∈ s, ∀ (t : Set β), IsOpen t → f x ∈ t → ∃ u, IsOpen u ∧ x ∈ u ∧ u ∩ s ⊆ f ⁻¹' t

full_name: continuousOn_iff_continuous_restrict
code: theorem continuousOn_iff_continuous_restrict {f : α → β} {s : Set α} :
    ContinuousOn f s ↔ Continuous (s.restrict f) 
goal: ContinuousOn f s ↔ Continuous (s.restrict f)

full_name: ContinuousOn.restrict_mapsTo
code: theorem ContinuousOn.restrict_mapsTo {f : α → β} {s : Set α} {t : Set β} (hf : ContinuousOn f s)
    (ht : MapsTo f s t) : Continuous (ht.restrict f s t) 
goal: Continuous (Set.MapsTo.restrict f s t ht)

full_name: continuousOn_iff'
code: theorem continuousOn_iff' {f : α → β} {s : Set α} :
    ContinuousOn f s ↔ ∀ t : Set β, IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s 
goal: ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → ∃ u, IsOpen u ∧ f ⁻¹' t ∩ s = u ∩ s

full_name: ContinuousOn.mono_dom
code: /-- If a function is continuous on a set for some topologies, then it is
continuous on the same set with respect to any finer topology on the source space. -/
theorem ContinuousOn.mono_dom {α β : Type*} {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β}
    (h₁ : t₂ ≤ t₁) {s : Set α} {f : α → β} (h₂ : @ContinuousOn α β t₁ t₃ f s) :
    @ContinuousOn α β t₂ t₃ f s 
goal: ContinuousOn f s

full_name: ContinuousOn.mono_rng
code: /-- If a function is continuous on a set for some topologies, then it is
continuous on the same set with respect to any coarser topology on the target space. -/
theorem ContinuousOn.mono_rng {α β : Type*} {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β}
    (h₁ : t₂ ≤ t₃) {s : Set α} {f : α → β} (h₂ : @ContinuousOn α β t₁ t₂ f s) :
    @ContinuousOn α β t₁ t₃ f s 
goal: ContinuousOn f s

full_name: continuousOn_iff_isClosed
code: theorem continuousOn_iff_isClosed {f : α → β} {s : Set α} :
    ContinuousOn f s ↔ ∀ t : Set β, IsClosed t → ∃ u, IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s 
goal: ContinuousOn f s ↔ ∀ (t : Set β), IsClosed t → ∃ u, IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s

full_name: ContinuousOn.prod_map
code: theorem ContinuousOn.prod_map {f : α → γ} {g : β → δ} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hg : ContinuousOn g t) : ContinuousOn (Prod.map f g) (s ×ˢ t) 
goal: ContinuousOn (Prod.map f g) (s ×ˢ t)

full_name: continuous_of_cover_nhds
code: theorem continuous_of_cover_nhds {ι : Sort*} {f : α → β} {s : ι → Set α}
    (hs : ∀ x : α, ∃ i, s i ∈ 𝓝 x) (hf : ∀ i, ContinuousOn f (s i)) :
    Continuous f 
goal: Continuous f

full_name: continuousOn_empty
code: theorem continuousOn_empty (f : α → β) : ContinuousOn f ∅ 
goal: ContinuousOn f ∅

full_name: continuousOn_singleton
code: @[simp]
theorem continuousOn_singleton (f : α → β) (a : α) : ContinuousOn f {a} 
goal: ContinuousOn f {a}

full_name: Set.Subsingleton.continuousOn
code: theorem Set.Subsingleton.continuousOn {s : Set α} (hs : s.Subsingleton) (f : α → β) :
    ContinuousOn f s 
goal: ContinuousOn f s

full_name: nhdsWithin_le_comap
code: theorem nhdsWithin_le_comap {x : α} {s : Set α} {f : α → β} (ctsf : ContinuousWithinAt f s x) :
    𝓝[s] x ≤ comap f (𝓝[f '' s] f x) 
goal: 𝓝[s] x ≤ Filter.comap f (𝓝[f '' s] f x)

full_name: ContinuousWithinAt.mono
code: theorem ContinuousWithinAt.mono {f : α → β} {s t : Set α} {x : α} (h : ContinuousWithinAt f t x)
    (hs : s ⊆ t) : ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: ContinuousWithinAt.mono_of_mem
code: theorem ContinuousWithinAt.mono_of_mem {f : α → β} {s t : Set α} {x : α}
    (h : ContinuousWithinAt f t x) (hs : t ∈ 𝓝[s] x) : ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: continuousWithinAt_congr_nhds
code: theorem continuousWithinAt_congr_nhds {f : α → β} {s t : Set α} {x : α} (h : 𝓝[s] x = 𝓝[t] x) :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt f t x 
goal: ContinuousWithinAt f s x ↔ ContinuousWithinAt f t x

full_name: continuousWithinAt_inter'
code: theorem continuousWithinAt_inter' {f : α → β} {s t : Set α} {x : α} (h : t ∈ 𝓝[s] x) :
    ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x 
goal: ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x

full_name: continuousWithinAt_inter
code: theorem continuousWithinAt_inter {f : α → β} {s t : Set α} {x : α} (h : t ∈ 𝓝 x) :
    ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x 
goal: ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x

full_name: continuousWithinAt_union
code: theorem continuousWithinAt_union {f : α → β} {s t : Set α} {x : α} :
    ContinuousWithinAt f (s ∪ t) x ↔ ContinuousWithinAt f s x ∧ ContinuousWithinAt f t x 
goal: ContinuousWithinAt f (s ∪ t) x ↔ ContinuousWithinAt f s x ∧ ContinuousWithinAt f t x

full_name: ContinuousWithinAt.union
code: theorem ContinuousWithinAt.union {f : α → β} {s t : Set α} {x : α} (hs : ContinuousWithinAt f s x)
    (ht : ContinuousWithinAt f t x) : ContinuousWithinAt f (s ∪ t) x 
goal: ContinuousWithinAt f (s ∪ t) x

full_name: ContinuousWithinAt.mem_closure_image
code: theorem ContinuousWithinAt.mem_closure_image {f : α → β} {s : Set α} {x : α}
    (h : ContinuousWithinAt f s x) (hx : x ∈ closure s) : f x ∈ closure (f '' s) 
goal: f x ∈ closure (f '' s)

full_name: ContinuousWithinAt.mem_closure
code: theorem ContinuousWithinAt.mem_closure {f : α → β} {s : Set α} {x : α} {A : Set β}
    (h : ContinuousWithinAt f s x) (hx : x ∈ closure s) (hA : MapsTo f s A) : f x ∈ closure A 
goal: f x ∈ closure A

full_name: Set.MapsTo.closure_of_continuousWithinAt
code: theorem Set.MapsTo.closure_of_continuousWithinAt {f : α → β} {s : Set α} {t : Set β}
    (h : MapsTo f s t) (hc : ∀ x ∈ closure s, ContinuousWithinAt f s x) :
    MapsTo f (closure s) (closure t) 
goal: Set.MapsTo f (closure s) (closure t)

full_name: Set.MapsTo.closure_of_continuousOn
code: theorem Set.MapsTo.closure_of_continuousOn {f : α → β} {s : Set α} {t : Set β} (h : MapsTo f s t)
    (hc : ContinuousOn f (closure s)) : MapsTo f (closure s) (closure t) 
goal: Set.MapsTo f (closure s) (closure t)

full_name: ContinuousWithinAt.image_closure
code: theorem ContinuousWithinAt.image_closure {f : α → β} {s : Set α}
    (hf : ∀ x ∈ closure s, ContinuousWithinAt f s x) : f '' closure s ⊆ closure (f '' s) 
goal: f '' closure s ⊆ closure (f '' s)

full_name: ContinuousOn.image_closure
code: theorem ContinuousOn.image_closure {f : α → β} {s : Set α} (hf : ContinuousOn f (closure s)) :
    f '' closure s ⊆ closure (f '' s) 
goal: f '' closure s ⊆ closure (f '' s)

full_name: continuousWithinAt_singleton
code: @[simp]
theorem continuousWithinAt_singleton {f : α → β} {x : α} : ContinuousWithinAt f {x} x 
goal: ContinuousWithinAt f {x} x

full_name: continuousWithinAt_insert_self
code: @[simp]
theorem continuousWithinAt_insert_self {f : α → β} {x : α} {s : Set α} :
    ContinuousWithinAt f (insert x s) x ↔ ContinuousWithinAt f s x 
goal: ContinuousWithinAt f (insert x s) x ↔ ContinuousWithinAt f s x

full_name: ContinuousWithinAt.diff_iff
code: theorem ContinuousWithinAt.diff_iff {f : α → β} {s t : Set α} {x : α}
    (ht : ContinuousWithinAt f t x) : ContinuousWithinAt f (s \ t) x ↔ ContinuousWithinAt f s x 
goal: ContinuousWithinAt f (s \ t) x ↔ ContinuousWithinAt f s x

full_name: continuousWithinAt_diff_self
code: @[simp]
theorem continuousWithinAt_diff_self {f : α → β} {s : Set α} {x : α} :
    ContinuousWithinAt f (s \ {x}) x ↔ ContinuousWithinAt f s x 
goal: ContinuousWithinAt f (s \ {x}) x ↔ ContinuousWithinAt f s x

full_name: continuousWithinAt_compl_self
code: @[simp]
theorem continuousWithinAt_compl_self {f : α → β} {a : α} :
    ContinuousWithinAt f {a}ᶜ a ↔ ContinuousAt f a 
goal: ContinuousWithinAt f {a}ᶜ a ↔ ContinuousAt f a

full_name: continuousWithinAt_update_same
code: @[simp]
theorem continuousWithinAt_update_same [DecidableEq α] {f : α → β} {s : Set α} {x : α} {y : β} :
    ContinuousWithinAt (update f x y) s x ↔ Tendsto f (𝓝[s \ {x}] x) (𝓝 y) 
goal: ContinuousWithinAt (Function.update f x y) s x ↔ Filter.Tendsto f (𝓝[s \ {x}] x) (𝓝 y)

full_name: continuousAt_update_same
code: @[simp]
theorem continuousAt_update_same [DecidableEq α] {f : α → β} {x : α} {y : β} :
    ContinuousAt (Function.update f x y) x ↔ Tendsto f (𝓝[≠] x) (𝓝 y) 
goal: ContinuousAt (Function.update f x y) x ↔ Filter.Tendsto f (𝓝[≠] x) (𝓝 y)

full_name: IsOpenMap.continuousOn_image_of_leftInvOn
code: theorem IsOpenMap.continuousOn_image_of_leftInvOn {f : α → β} {s : Set α}
    (h : IsOpenMap (s.restrict f)) {finv : β → α} (hleft : LeftInvOn finv f s) :
    ContinuousOn finv (f '' s) 
goal: ContinuousOn finv (f '' s)

full_name: IsOpenMap.continuousOn_range_of_leftInverse
code: theorem IsOpenMap.continuousOn_range_of_leftInverse {f : α → β} (hf : IsOpenMap f) {finv : β → α}
    (hleft : Function.LeftInverse finv f) : ContinuousOn finv (range f) 
goal: ContinuousOn finv (Set.range f)

full_name: ContinuousOn.congr_mono
code: theorem ContinuousOn.congr_mono {f g : α → β} {s s₁ : Set α} (h : ContinuousOn f s)
    (h' : EqOn g f s₁) (h₁ : s₁ ⊆ s) : ContinuousOn g s₁ 
goal: ContinuousOn g s₁

full_name: ContinuousOn.congr
code: theorem ContinuousOn.congr {f g : α → β} {s : Set α} (h : ContinuousOn f s) (h' : EqOn g f s) :
    ContinuousOn g s 
goal: ContinuousOn g s

full_name: continuousOn_congr
code: theorem continuousOn_congr {f g : α → β} {s : Set α} (h' : EqOn g f s) :
    ContinuousOn g s ↔ ContinuousOn f s 
goal: ContinuousOn g s ↔ ContinuousOn f s

full_name: ContinuousAt.continuousWithinAt
code: theorem ContinuousAt.continuousWithinAt {f : α → β} {s : Set α} {x : α} (h : ContinuousAt f x) :
    ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: continuousWithinAt_iff_continuousAt
code: theorem continuousWithinAt_iff_continuousAt {f : α → β} {s : Set α} {x : α} (h : s ∈ 𝓝 x) :
    ContinuousWithinAt f s x ↔ ContinuousAt f x 
goal: ContinuousWithinAt f s x ↔ ContinuousAt f x

full_name: ContinuousWithinAt.continuousAt
code: theorem ContinuousWithinAt.continuousAt {f : α → β} {s : Set α} {x : α}
    (h : ContinuousWithinAt f s x) (hs : s ∈ 𝓝 x) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: IsOpen.continuousOn_iff
code: theorem IsOpen.continuousOn_iff {f : α → β} {s : Set α} (hs : IsOpen s) :
    ContinuousOn f s ↔ ∀ ⦃a⦄, a ∈ s → ContinuousAt f a 
goal: ContinuousOn f s ↔ ∀ ⦃a : α⦄, a ∈ s → ContinuousAt f a

full_name: ContinuousOn.continuousAt
code: theorem ContinuousOn.continuousAt {f : α → β} {s : Set α} {x : α} (h : ContinuousOn f s)
    (hx : s ∈ 𝓝 x) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: ContinuousAt.continuousOn
code: theorem ContinuousAt.continuousOn {f : α → β} {s : Set α} (hcont : ∀ x ∈ s, ContinuousAt f x) :
    ContinuousOn f s 
goal: ContinuousOn f s

full_name: ContinuousWithinAt.comp
code: theorem ContinuousWithinAt.comp {g : β → γ} {f : α → β} {s : Set α} {t : Set β} {x : α}
    (hg : ContinuousWithinAt g t (f x)) (hf : ContinuousWithinAt f s x) (h : MapsTo f s t) :
    ContinuousWithinAt (g ∘ f) s x 
goal: ContinuousWithinAt (g ∘ f) s x

full_name: ContinuousWithinAt.comp'
code: theorem ContinuousWithinAt.comp' {g : β → γ} {f : α → β} {s : Set α} {t : Set β} {x : α}
    (hg : ContinuousWithinAt g t (f x)) (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (g ∘ f) (s ∩ f ⁻¹' t) x 
goal: ContinuousWithinAt (g ∘ f) (s ∩ f ⁻¹' t) x

full_name: ContinuousAt.comp_continuousWithinAt
code: theorem ContinuousAt.comp_continuousWithinAt {g : β → γ} {f : α → β} {s : Set α} {x : α}
    (hg : ContinuousAt g (f x)) (hf : ContinuousWithinAt f s x) : ContinuousWithinAt (g ∘ f) s x 
goal: ContinuousWithinAt (g ∘ f) s x

full_name: ContinuousOn.comp
code: theorem ContinuousOn.comp {g : β → γ} {f : α → β} {s : Set α} {t : Set β} (hg : ContinuousOn g t)
    (hf : ContinuousOn f s) (h : MapsTo f s t) : ContinuousOn (g ∘ f) s 
goal: ContinuousOn (g ∘ f) s

full_name: ContinuousOn.comp''
code: @[fun_prop]
theorem ContinuousOn.comp'' {g : β → γ} {f : α → β} {s : Set α} {t : Set β} (hg : ContinuousOn g t)
    (hf : ContinuousOn f s) (h : Set.MapsTo f s t) : ContinuousOn (fun x => g (f x)) s 
goal: ContinuousOn (fun x => g (f x)) s

full_name: ContinuousOn.mono
code: theorem ContinuousOn.mono {f : α → β} {s t : Set α} (hf : ContinuousOn f s) (h : t ⊆ s) :
    ContinuousOn f t 
goal: ContinuousOn f t

full_name: antitone_continuousOn
code: theorem antitone_continuousOn {f : α → β} : Antitone (ContinuousOn f) 
goal: Antitone (ContinuousOn f)

full_name: ContinuousOn.comp'
code: @[fun_prop]
theorem ContinuousOn.comp' {g : β → γ} {f : α → β} {s : Set α} {t : Set β} (hg : ContinuousOn g t)
    (hf : ContinuousOn f s) : ContinuousOn (g ∘ f) (s ∩ f ⁻¹' t) 
goal: ContinuousOn (g ∘ f) (s ∩ f ⁻¹' t)

full_name: Continuous.continuousOn
code: @[fun_prop]
theorem Continuous.continuousOn {f : α → β} {s : Set α} (h : Continuous f) : ContinuousOn f s 
goal: ContinuousOn f s

full_name: Continuous.continuousWithinAt
code: theorem Continuous.continuousWithinAt {f : α → β} {s : Set α} {x : α} (h : Continuous f) :
    ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: Continuous.comp_continuousOn
code: theorem Continuous.comp_continuousOn {g : β → γ} {f : α → β} {s : Set α} (hg : Continuous g)
    (hf : ContinuousOn f s) : ContinuousOn (g ∘ f) s 
goal: ContinuousOn (g ∘ f) s

full_name: Continuous.comp_continuousOn'
code: @[fun_prop]
theorem Continuous.comp_continuousOn'
    {α β γ : Type*} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] {g : β → γ}
    {f : α → β} {s : Set α} (hg : Continuous g) (hf : ContinuousOn f s) :
    ContinuousOn (fun x ↦ g (f x)) s 
goal: ContinuousOn (fun x => g (f x)) s

full_name: ContinuousOn.comp_continuous
code: theorem ContinuousOn.comp_continuous {g : β → γ} {f : α → β} {s : Set β} (hg : ContinuousOn g s)
    (hf : Continuous f) (hs : ∀ x, f x ∈ s) : Continuous (g ∘ f) 
goal: Continuous (g ∘ f)

full_name: continuousOn_apply
code: @[fun_prop]
theorem continuousOn_apply {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    (i : ι) (s) : ContinuousOn (fun p : ∀ i, π i => p i) s 
goal: ContinuousOn (fun p => p i) s

full_name: ContinuousWithinAt.preimage_mem_nhdsWithin
code: theorem ContinuousWithinAt.preimage_mem_nhdsWithin {f : α → β} {x : α} {s : Set α} {t : Set β}
    (h : ContinuousWithinAt f s x) (ht : t ∈ 𝓝 (f x)) : f ⁻¹' t ∈ 𝓝[s] x 
goal: f ⁻¹' t ∈ 𝓝[s] x

full_name: Set.LeftInvOn.map_nhdsWithin_eq
code: theorem Set.LeftInvOn.map_nhdsWithin_eq {f : α → β} {g : β → α} {x : β} {s : Set β}
    (h : LeftInvOn f g s) (hx : f (g x) = x) (hf : ContinuousWithinAt f (g '' s) (g x))
    (hg : ContinuousWithinAt g s x) : map g (𝓝[s] x) = 𝓝[g '' s] g x 
goal: Filter.map g (𝓝[s] x) = 𝓝[g '' s] g x

full_name: Function.LeftInverse.map_nhds_eq
code: theorem Function.LeftInverse.map_nhds_eq {f : α → β} {g : β → α} {x : β}
    (h : Function.LeftInverse f g) (hf : ContinuousWithinAt f (range g) (g x))
    (hg : ContinuousAt g x) : map g (𝓝 x) = 𝓝[range g] g x 
goal: Filter.map g (𝓝 x) = 𝓝[Set.range g] g x

full_name: ContinuousWithinAt.preimage_mem_nhdsWithin'
code: theorem ContinuousWithinAt.preimage_mem_nhdsWithin' {f : α → β} {x : α} {s : Set α} {t : Set β}
    (h : ContinuousWithinAt f s x) (ht : t ∈ 𝓝[f '' s] f x) : f ⁻¹' t ∈ 𝓝[s] x 
goal: f ⁻¹' t ∈ 𝓝[s] x

full_name: ContinuousWithinAt.preimage_mem_nhdsWithin''
code: theorem ContinuousWithinAt.preimage_mem_nhdsWithin''
    {f : α → β} {x : α} {y : β} {s t : Set β}
    (h : ContinuousWithinAt f (f ⁻¹' s) x) (ht : t ∈ 𝓝[s] y) (hxy : y = f x) :
    f ⁻¹' t ∈ 𝓝[f ⁻¹' s] x 
goal: f ⁻¹' t ∈ 𝓝[f ⁻¹' s] x

full_name: Filter.EventuallyEq.congr_continuousWithinAt
code: theorem Filter.EventuallyEq.congr_continuousWithinAt {f g : α → β} {s : Set α} {x : α}
    (h : f =ᶠ[𝓝[s] x] g) (hx : f x = g x) :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt g s x 
goal: ContinuousWithinAt f s x ↔ ContinuousWithinAt g s x

full_name: ContinuousWithinAt.congr_of_eventuallyEq
code: theorem ContinuousWithinAt.congr_of_eventuallyEq {f f₁ : α → β} {s : Set α} {x : α}
    (h : ContinuousWithinAt f s x) (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) :
    ContinuousWithinAt f₁ s x 
goal: ContinuousWithinAt f₁ s x

full_name: ContinuousWithinAt.congr
code: theorem ContinuousWithinAt.congr {f f₁ : α → β} {s : Set α} {x : α} (h : ContinuousWithinAt f s x)
    (h₁ : ∀ y ∈ s, f₁ y = f y) (hx : f₁ x = f x) : ContinuousWithinAt f₁ s x 
goal: ContinuousWithinAt f₁ s x

full_name: ContinuousWithinAt.congr_mono
code: theorem ContinuousWithinAt.congr_mono {f g : α → β} {s s₁ : Set α} {x : α}
    (h : ContinuousWithinAt f s x) (h' : EqOn g f s₁) (h₁ : s₁ ⊆ s) (hx : g x = f x) :
    ContinuousWithinAt g s₁ x 
goal: ContinuousWithinAt g s₁ x

full_name: continuousOn_const
code: @[fun_prop]
theorem continuousOn_const {s : Set α} {c : β} : ContinuousOn (fun _ => c) s 
goal: ContinuousOn (fun x => c) s

full_name: continuousWithinAt_const
code: theorem continuousWithinAt_const {b : β} {s : Set α} {x : α} :
    ContinuousWithinAt (fun _ : α => b) s x 
goal: ContinuousWithinAt (fun x => b) s x

full_name: continuousOn_id
code: theorem continuousOn_id {s : Set α} : ContinuousOn id s 
goal: ContinuousOn id s

full_name: continuousOn_id'
code: @[fun_prop]
theorem continuousOn_id' (s : Set α) : ContinuousOn (fun x : α => x) s 
goal: ContinuousOn (fun x => x) s

full_name: continuousWithinAt_id
code: theorem continuousWithinAt_id {s : Set α} {x : α} : ContinuousWithinAt id s x 
goal: ContinuousWithinAt id s x

full_name: continuousOn_open_iff
code: theorem continuousOn_open_iff {f : α → β} {s : Set α} (hs : IsOpen s) :
    ContinuousOn f s ↔ ∀ t, IsOpen t → IsOpen (s ∩ f ⁻¹' t) 
goal: ContinuousOn f s ↔ ∀ (t : Set β), IsOpen t → IsOpen (s ∩ f ⁻¹' t)

full_name: ContinuousOn.isOpen_inter_preimage
code: theorem ContinuousOn.isOpen_inter_preimage {f : α → β} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hs : IsOpen s) (ht : IsOpen t) : IsOpen (s ∩ f ⁻¹' t) 
goal: IsOpen (s ∩ f ⁻¹' t)

full_name: ContinuousOn.isOpen_preimage
code: theorem ContinuousOn.isOpen_preimage {f : α → β} {s : Set α} {t : Set β} (h : ContinuousOn f s)
    (hs : IsOpen s) (hp : f ⁻¹' t ⊆ s) (ht : IsOpen t) : IsOpen (f ⁻¹' t) 
goal: IsOpen (f ⁻¹' t)

full_name: ContinuousOn.preimage_isClosed_of_isClosed
code: theorem ContinuousOn.preimage_isClosed_of_isClosed {f : α → β} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hs : IsClosed s) (ht : IsClosed t) : IsClosed (s ∩ f ⁻¹' t) 
goal: IsClosed (s ∩ f ⁻¹' t)

full_name: ContinuousOn.preimage_interior_subset_interior_preimage
code: theorem ContinuousOn.preimage_interior_subset_interior_preimage {f : α → β} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hs : IsOpen s) : s ∩ f ⁻¹' interior t ⊆ s ∩ interior (f ⁻¹' t) 
goal: s ∩ f ⁻¹' interior t ⊆ s ∩ interior (f ⁻¹' t)

full_name: continuousOn_of_locally_continuousOn
code: theorem continuousOn_of_locally_continuousOn {f : α → β} {s : Set α}
    (h : ∀ x ∈ s, ∃ t, IsOpen t ∧ x ∈ t ∧ ContinuousOn f (s ∩ t)) : ContinuousOn f s 
goal: ContinuousOn f s

full_name: continuousOn_to_generateFrom_iff
code: theorem continuousOn_to_generateFrom_iff {s : Set α} {T : Set (Set β)} {f : α → β} :
    @ContinuousOn α β _ (.generateFrom T) f s ↔ ∀ x ∈ s, ∀ t ∈ T, f x ∈ t → f ⁻¹' t ∈ 𝓝[s] x 
goal: ContinuousOn f s ↔ ∀ x ∈ s, ∀ t ∈ T, f x ∈ t → f ⁻¹' t ∈ 𝓝[s] x

full_name: continuousOn_isOpen_of_generateFrom
code: theorem continuousOn_isOpen_of_generateFrom {β : Type*} {s : Set α} {T : Set (Set β)} {f : α → β}
    (h : ∀ t ∈ T, IsOpen (s ∩ f ⁻¹' t)) :
    @ContinuousOn α β _ (.generateFrom T) f s 
goal: ContinuousOn f s

full_name: ContinuousWithinAt.prod
code: theorem ContinuousWithinAt.prod {f : α → β} {g : α → γ} {s : Set α} {x : α}
    (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (fun x => (f x, g x)) s x 
goal: ContinuousWithinAt (fun x => (f x, g x)) s x

full_name: ContinuousOn.prod
code: @[fun_prop]
theorem ContinuousOn.prod {f : α → β} {g : α → γ} {s : Set α} (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) : ContinuousOn (fun x => (f x, g x)) s 
goal: ContinuousOn (fun x => (f x, g x)) s

full_name: ContinuousAt.comp₂_continuousWithinAt
code: theorem ContinuousAt.comp₂_continuousWithinAt {f : β × γ → δ} {g : α → β} {h : α → γ} {x : α}
    {s : Set α} (hf : ContinuousAt f (g x, h x)) (hg : ContinuousWithinAt g s x)
    (hh : ContinuousWithinAt h s x) :
    ContinuousWithinAt (fun x ↦ f (g x, h x)) s x 
goal: ContinuousWithinAt (fun x => f (g x, h x)) s x

full_name: ContinuousAt.comp₂_continuousWithinAt_of_eq
code: theorem ContinuousAt.comp₂_continuousWithinAt_of_eq {f : β × γ → δ} {g : α → β}
    {h : α → γ} {x : α} {s : Set α} {y : β × γ} (hf : ContinuousAt f y)
    (hg : ContinuousWithinAt g s x) (hh : ContinuousWithinAt h s x) (e : (g x, h x) = y) :
    ContinuousWithinAt (fun x ↦ f (g x, h x)) s x 
goal: ContinuousWithinAt (fun x => f (g x, h x)) s x

full_name: Inducing.continuousWithinAt_iff
code: theorem Inducing.continuousWithinAt_iff {f : α → β} {g : β → γ} (hg : Inducing g) {s : Set α}
    {x : α} : ContinuousWithinAt f s x ↔ ContinuousWithinAt (g ∘ f) s x 
goal: ContinuousWithinAt f s x ↔ ContinuousWithinAt (g ∘ f) s x

full_name: Inducing.continuousOn_iff
code: theorem Inducing.continuousOn_iff {f : α → β} {g : β → γ} (hg : Inducing g) {s : Set α} :
    ContinuousOn f s ↔ ContinuousOn (g ∘ f) s 
goal: ContinuousOn f s ↔ ContinuousOn (g ∘ f) s

full_name: Embedding.continuousOn_iff
code: theorem Embedding.continuousOn_iff {f : α → β} {g : β → γ} (hg : Embedding g) {s : Set α} :
    ContinuousOn f s ↔ ContinuousOn (g ∘ f) s 
goal: ContinuousOn f s ↔ ContinuousOn (g ∘ f) s

full_name: Embedding.map_nhdsWithin_eq
code: theorem Embedding.map_nhdsWithin_eq {f : α → β} (hf : Embedding f) (s : Set α) (x : α) :
    map f (𝓝[s] x) = 𝓝[f '' s] f x 
goal: Filter.map f (𝓝[s] x) = 𝓝[f '' s] f x

full_name: OpenEmbedding.map_nhdsWithin_preimage_eq
code: theorem OpenEmbedding.map_nhdsWithin_preimage_eq {f : α → β} (hf : OpenEmbedding f) (s : Set β)
    (x : α) : map f (𝓝[f ⁻¹' s] x) = 𝓝[s] f x 
goal: Filter.map f (𝓝[f ⁻¹' s] x) = 𝓝[s] f x

full_name: QuotientMap.continuousOn_isOpen_iff
code: theorem QuotientMap.continuousOn_isOpen_iff {f : α → β} {g : β → γ} (h : QuotientMap f) {s : Set β}
    (hs : IsOpen s) : ContinuousOn g s ↔ ContinuousOn (g ∘ f) (f ⁻¹' s) 
goal: ContinuousOn g s ↔ ContinuousOn (g ∘ f) (f ⁻¹' s)

full_name: continuousWithinAt_of_not_mem_closure
code: theorem continuousWithinAt_of_not_mem_closure {f : α → β} {s : Set α} {x : α} (hx : x ∉ closure s) :
    ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: ContinuousOn.if'
code: theorem ContinuousOn.if' {s : Set α} {p : α → Prop} {f g : α → β} [∀ a, Decidable (p a)]
    (hpf : ∀ a ∈ s ∩ frontier { a | p a },
      Tendsto f (𝓝[s ∩ { a | p a }] a) (𝓝 <| if p a then f a else g a))
    (hpg :
      ∀ a ∈ s ∩ frontier { a | p a },
        Tendsto g (𝓝[s ∩ { a | ¬p a }] a) (𝓝 <| if p a then f a else g a))
    (hf : ContinuousOn f <| s ∩ { a | p a }) (hg : ContinuousOn g <| s ∩ { a | ¬p a }) :
    ContinuousOn (fun a => if p a then f a else g a) s 
goal: ContinuousOn (fun a => if p a then f a else g a) s

full_name: ContinuousOn.piecewise'
code: theorem ContinuousOn.piecewise' {s t : Set α} {f g : α → β} [∀ a, Decidable (a ∈ t)]
    (hpf : ∀ a ∈ s ∩ frontier t, Tendsto f (𝓝[s ∩ t] a) (𝓝 (piecewise t f g a)))
    (hpg : ∀ a ∈ s ∩ frontier t, Tendsto g (𝓝[s ∩ tᶜ] a) (𝓝 (piecewise t f g a)))
    (hf : ContinuousOn f <| s ∩ t) (hg : ContinuousOn g <| s ∩ tᶜ) :
    ContinuousOn (piecewise t f g) s 
goal: ContinuousOn (t.piecewise f g) s

full_name: ContinuousOn.if
code: theorem ContinuousOn.if {α β : Type*} [TopologicalSpace α] [TopologicalSpace β] {p : α → Prop}
    [∀ a, Decidable (p a)] {s : Set α} {f g : α → β}
    (hp : ∀ a ∈ s ∩ frontier { a | p a }, f a = g a)
    (hf : ContinuousOn f <| s ∩ closure { a | p a })
    (hg : ContinuousOn g <| s ∩ closure { a | ¬p a }) :
    ContinuousOn (fun a => if p a then f a else g a) s 
goal: ContinuousOn (fun a => if p a then f a else g a) s

full_name: ContinuousOn.piecewise
code: theorem ContinuousOn.piecewise {s t : Set α} {f g : α → β} [∀ a, Decidable (a ∈ t)]
    (ht : ∀ a ∈ s ∩ frontier t, f a = g a) (hf : ContinuousOn f <| s ∩ closure t)
    (hg : ContinuousOn g <| s ∩ closure tᶜ) : ContinuousOn (piecewise t f g) s 
goal: ContinuousOn (t.piecewise f g) s

full_name: continuous_if'
code: theorem continuous_if' {p : α → Prop} {f g : α → β} [∀ a, Decidable (p a)]
    (hpf : ∀ a ∈ frontier { x | p x }, Tendsto f (𝓝[{ x | p x }] a) (𝓝 <| ite (p a) (f a) (g a)))
    (hpg : ∀ a ∈ frontier { x | p x }, Tendsto g (𝓝[{ x | ¬p x }] a) (𝓝 <| ite (p a) (f a) (g a)))
    (hf : ContinuousOn f { x | p x }) (hg : ContinuousOn g { x | ¬p x }) :
    Continuous fun a => ite (p a) (f a) (g a) 
goal: Continuous fun a => if p a then f a else g a

full_name: continuous_if
code: theorem continuous_if {p : α → Prop} {f g : α → β} [∀ a, Decidable (p a)]
    (hp : ∀ a ∈ frontier { x | p x }, f a = g a) (hf : ContinuousOn f (closure { x | p x }))
    (hg : ContinuousOn g (closure { x | ¬p x })) :
    Continuous fun a => if p a then f a else g a 
goal: Continuous fun a => if p a then f a else g a

full_name: Continuous.if
code: theorem Continuous.if {p : α → Prop} {f g : α → β} [∀ a, Decidable (p a)]
    (hp : ∀ a ∈ frontier { x | p x }, f a = g a) (hf : Continuous f) (hg : Continuous g) :
    Continuous fun a => if p a then f a else g a 
goal: Continuous fun a => if p a then f a else g a

full_name: continuous_if_const
code: theorem continuous_if_const (p : Prop) {f g : α → β} [Decidable p] (hf : p → Continuous f)
    (hg : ¬p → Continuous g) : Continuous fun a => if p then f a else g a 
goal: Continuous fun a => if p then f a else g a

full_name: Continuous.if_const
code: theorem Continuous.if_const (p : Prop) {f g : α → β} [Decidable p] (hf : Continuous f)
    (hg : Continuous g) : Continuous fun a => if p then f a else g a 
goal: Continuous fun a => if p then f a else g a

full_name: continuous_piecewise
code: theorem continuous_piecewise {s : Set α} {f g : α → β} [∀ a, Decidable (a ∈ s)]
    (hs : ∀ a ∈ frontier s, f a = g a) (hf : ContinuousOn f (closure s))
    (hg : ContinuousOn g (closure sᶜ)) : Continuous (piecewise s f g) 
goal: Continuous (s.piecewise f g)

full_name: Continuous.piecewise
code: theorem Continuous.piecewise {s : Set α} {f g : α → β} [∀ a, Decidable (a ∈ s)]
    (hs : ∀ a ∈ frontier s, f a = g a) (hf : Continuous f) (hg : Continuous g) :
    Continuous (piecewise s f g) 
goal: Continuous (s.piecewise f g)

full_name: continuous_indicator
code: @[to_additive]
lemma continuous_mulIndicator (hs : ∀ a ∈ frontier s, f a = 1) (hf : ContinuousOn f (closure s)) :
    Continuous (mulIndicator s f) 
goal: Continuous (s.indicator f)

full_name: continuous_mulIndicator
code: @[to_additive]
lemma continuous_mulIndicator (hs : ∀ a ∈ frontier s, f a = 1) (hf : ContinuousOn f (closure s)) :
    Continuous (mulIndicator s f) 
goal: Continuous (s.mulIndicator f)

full_name: Continuous.mulIndicator
code: @[to_additive]
protected lemma Continuous.mulIndicator (hs : ∀ a ∈ frontier s, f a = 1) (hf : Continuous f) :
    Continuous (mulIndicator s f) 
goal: Continuous (s.mulIndicator f)

full_name: Continuous.indicator
code: @[to_additive]
protected lemma Continuous.mulIndicator (hs : ∀ a ∈ frontier s, f a = 1) (hf : Continuous f) :
    Continuous (mulIndicator s f) 
goal: Continuous (s.indicator f)

full_name: IsOpen.ite'
code: theorem IsOpen.ite' {s s' t : Set α} (hs : IsOpen s) (hs' : IsOpen s')
    (ht : ∀ x ∈ frontier t, x ∈ s ↔ x ∈ s') : IsOpen (t.ite s s') 
goal: IsOpen (t.ite s s')

full_name: IsOpen.ite
code: theorem IsOpen.ite {s s' t : Set α} (hs : IsOpen s) (hs' : IsOpen s')
    (ht : s ∩ frontier t = s' ∩ frontier t) : IsOpen (t.ite s s') 
goal: IsOpen (t.ite s s')

full_name: ite_inter_closure_eq_of_inter_frontier_eq
code: theorem ite_inter_closure_eq_of_inter_frontier_eq {s s' t : Set α}
    (ht : s ∩ frontier t = s' ∩ frontier t) : t.ite s s' ∩ closure t = s ∩ closure t 
goal: t.ite s s' ∩ closure t = s ∩ closure t

full_name: ite_inter_closure_compl_eq_of_inter_frontier_eq
code: theorem ite_inter_closure_compl_eq_of_inter_frontier_eq {s s' t : Set α}
    (ht : s ∩ frontier t = s' ∩ frontier t) : t.ite s s' ∩ closure tᶜ = s' ∩ closure tᶜ 
goal: t.ite s s' ∩ closure tᶜ = s' ∩ closure tᶜ

full_name: continuousOn_piecewise_ite'
code: theorem continuousOn_piecewise_ite' {s s' t : Set α} {f f' : α → β} [∀ x, Decidable (x ∈ t)]
    (h : ContinuousOn f (s ∩ closure t)) (h' : ContinuousOn f' (s' ∩ closure tᶜ))
    (H : s ∩ frontier t = s' ∩ frontier t) (Heq : EqOn f f' (s ∩ frontier t)) :
    ContinuousOn (t.piecewise f f') (t.ite s s') 
goal: ContinuousOn (t.piecewise f f') (t.ite s s')

full_name: continuousOn_piecewise_ite
code: theorem continuousOn_piecewise_ite {s s' t : Set α} {f f' : α → β} [∀ x, Decidable (x ∈ t)]
    (h : ContinuousOn f s) (h' : ContinuousOn f' s') (H : s ∩ frontier t = s' ∩ frontier t)
    (Heq : EqOn f f' (s ∩ frontier t)) : ContinuousOn (t.piecewise f f') (t.ite s s') 
goal: ContinuousOn (t.piecewise f f') (t.ite s s')

full_name: frontier_inter_open_inter
code: theorem frontier_inter_open_inter {s t : Set α} (ht : IsOpen t) :
    frontier (s ∩ t) ∩ t = frontier s ∩ t 
goal: frontier (s ∩ t) ∩ t = frontier s ∩ t

full_name: continuousOn_fst
code: theorem continuousOn_fst {s : Set (α × β)} : ContinuousOn Prod.fst s 
goal: ContinuousOn Prod.fst s

full_name: continuousWithinAt_fst
code: theorem continuousWithinAt_fst {s : Set (α × β)} {p : α × β} : ContinuousWithinAt Prod.fst s p 
goal: ContinuousWithinAt Prod.fst s p

full_name: ContinuousOn.fst
code: @[fun_prop]
theorem ContinuousOn.fst {f : α → β × γ} {s : Set α} (hf : ContinuousOn f s) :
    ContinuousOn (fun x => (f x).1) s 
goal: ContinuousOn (fun x => (f x).1) s

full_name: ContinuousWithinAt.fst
code: theorem ContinuousWithinAt.fst {f : α → β × γ} {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => (f x).fst) s a 
goal: ContinuousWithinAt (fun x => (f x).1) s a

full_name: continuousOn_snd
code: theorem continuousOn_snd {s : Set (α × β)} : ContinuousOn Prod.snd s 
goal: ContinuousOn Prod.snd s

full_name: continuousWithinAt_snd
code: theorem continuousWithinAt_snd {s : Set (α × β)} {p : α × β} : ContinuousWithinAt Prod.snd s p 
goal: ContinuousWithinAt Prod.snd s p

full_name: ContinuousOn.snd
code: @[fun_prop]
theorem ContinuousOn.snd {f : α → β × γ} {s : Set α} (hf : ContinuousOn f s) :
    ContinuousOn (fun x => (f x).2) s 
goal: ContinuousOn (fun x => (f x).2) s

full_name: ContinuousWithinAt.snd
code: theorem ContinuousWithinAt.snd {f : α → β × γ} {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => (f x).snd) s a 
goal: ContinuousWithinAt (fun x => (f x).2) s a

full_name: continuousWithinAt_prod_iff
code: theorem continuousWithinAt_prod_iff {f : α → β × γ} {s : Set α} {x : α} :
    ContinuousWithinAt f s x ↔
      ContinuousWithinAt (Prod.fst ∘ f) s x ∧ ContinuousWithinAt (Prod.snd ∘ f) s x 
goal: ContinuousWithinAt f s x ↔ ContinuousWithinAt (Prod.fst ∘ f) s x ∧ ContinuousWithinAt (Prod.snd ∘ f) s x