File: Mathlib/Topology/CompactOpen.lean

full_name: ContinuousMap.compactOpen
code: /-- The compact-open topology on the space of continuous maps `C(X, Y)`. -/
instance compactOpen : TopologicalSpace C(X, Y) 
goal: TopologicalSpace C(X, Y)

full_name: ContinuousMap.compactOpen_eq
code: /-- Definition of `ContinuousMap.compactOpen`. -/
theorem compactOpen_eq : @compactOpen X Y _ _ =
    .generateFrom (image2 (fun K U ↦ {f | MapsTo f K U}) {K | IsCompact K} {t | IsOpen t}) 
goal: ContinuousMap.compactOpen =
  TopologicalSpace.generateFrom (Set.image2 (fun K U => {f | Set.MapsTo (⇑f) K U}) {K | IsCompact K} {t | IsOpen t})

full_name: ContinuousMap.isOpen_setOf_mapsTo
code: theorem isOpen_setOf_mapsTo (hK : IsCompact K) (hU : IsOpen U) :
    IsOpen {f : C(X, Y) | MapsTo f K U} 
goal: IsOpen {f | Set.MapsTo (⇑f) K U}

full_name: ContinuousMap.eventually_mapsTo
code: lemma eventually_mapsTo {f : C(X, Y)} (hK : IsCompact K) (hU : IsOpen U) (h : MapsTo f K U) :
    ∀ᶠ g : C(X, Y) in 𝓝 f, MapsTo g K U 
goal: ∀ᶠ (g : C(X, Y)) in 𝓝 f, Set.MapsTo (⇑g) K U

full_name: ContinuousMap.nhds_compactOpen
code: lemma nhds_compactOpen (f : C(X, Y)) :
    𝓝 f = ⨅ (K : Set X) (_ : IsCompact K) (U : Set Y) (_ : IsOpen U) (_ : MapsTo f K U),
      𝓟 {g : C(X, Y) | MapsTo g K U} 
goal: 𝓝 f = ⨅ K, ⨅ (_ : IsCompact K), ⨅ U, ⨅ (_ : IsOpen U), ⨅ (_ : Set.MapsTo (⇑f) K U), 𝓟 {g | Set.MapsTo (⇑g) K U}

full_name: ContinuousMap.tendsto_nhds_compactOpen
code: lemma tendsto_nhds_compactOpen {l : Filter α} {f : α → C(Y, Z)} {g : C(Y, Z)} :
    Tendsto f l (𝓝 g) ↔
      ∀ K, IsCompact K → ∀ U, IsOpen U → MapsTo g K U → ∀ᶠ a in l, MapsTo (f a) K U 
goal: Filter.Tendsto f l (𝓝 g) ↔
  ∀ (K : Set Y), IsCompact K → ∀ (U : Set Z), IsOpen U → Set.MapsTo (⇑g) K U → ∀ᶠ (a : α) in l, Set.MapsTo (⇑(f a)) K U

full_name: ContinuousMap.continuous_compactOpen
code: lemma continuous_compactOpen {f : X → C(Y, Z)} :
    Continuous f ↔ ∀ K, IsCompact K → ∀ U, IsOpen U → IsOpen {x | MapsTo (f x) K U} 
goal: Continuous f ↔ ∀ (K : Set Y), IsCompact K → ∀ (U : Set Z), IsOpen U → IsOpen {x | Set.MapsTo (⇑(f x)) K U}

full_name: ContinuousMap.continuous_comp
code: /-- `C(X, ·)` is a functor. -/
theorem continuous_comp (g : C(Y, Z)) : Continuous (ContinuousMap.comp g : C(X, Y) → C(X, Z)) 
goal: Continuous g.comp

full_name: ContinuousMap.inducing_comp
code: /-- If `g : C(Y, Z)` is a topology inducing map,
then the composition `ContinuousMap.comp g : C(X, Y) → C(X, Z)` is a topology inducing map too. -/
theorem inducing_comp (g : C(Y, Z)) (hg : Inducing g) : Inducing (g.comp : C(X, Y) → C(X, Z)) 
goal: Inducing g.comp

full_name: ContinuousMap.embedding_comp
code: /-- If `g : C(Y, Z)` is a topological embedding,
then the composition `ContinuousMap.comp g : C(X, Y) → C(X, Z)` is an embedding too. -/
theorem embedding_comp (g : C(Y, Z)) (hg : Embedding g) : Embedding (g.comp : C(X, Y) → C(X, Z)) 
goal: Embedding g.comp

full_name: ContinuousMap.continuous_comp_left
code: /-- `C(·, Z)` is a functor. -/
theorem continuous_comp_left (f : C(X, Y)) : Continuous (fun g => g.comp f : C(Y, Z) → C(X, Z)) 
goal: Continuous fun g => g.comp f

full_name: Homeomorph.arrowCongr
code: /-- Any pair of homeomorphisms `X ≃ₜ Z` and `Y ≃ₜ T` gives rise to a homeomorphism
`C(X, Y) ≃ₜ C(Z, T)`. -/
protected def _root_.Homeomorph.arrowCongr (φ : X ≃ₜ Z) (ψ : Y ≃ₜ T) :
    C(X, Y) ≃ₜ C(Z, T) 
goal: C(X, Y) ≃ₜ C(Z, T)

full_name: ContinuousMap.continuous_comp'
code: /-- Composition is a continuous map from `C(X, Y) × C(Y, Z)` to `C(X, Z)`,
provided that `Y` is locally compact.
This is Prop. 9 of Chap. X, §3, №. 4 of Bourbaki's *Topologie Générale*. -/
theorem continuous_comp' : Continuous fun x : C(X, Y) × C(Y, Z) => x.2.comp x.1 
goal: Continuous fun x => x.2.comp x.1

full_name: Filter.Tendsto.compCM
code: lemma _root_.Filter.Tendsto.compCM {α : Type*} {l : Filter α} {g : α → C(Y, Z)} {g₀ : C(Y, Z)}
    {f : α → C(X, Y)} {f₀ : C(X, Y)} (hg : Tendsto g l (𝓝 g₀)) (hf : Tendsto f l (𝓝 f₀)) :
    Tendsto (fun a ↦ (g a).comp (f a)) l (𝓝 (g₀.comp f₀)) 
goal: Filter.Tendsto (fun a => (g a).comp (f a)) l (𝓝 (g₀.comp f₀))

full_name: ContinuousAt.compCM
code: nonrec lemma _root_.ContinuousAt.compCM (hg : ContinuousAt g a) (hf : ContinuousAt f a) :
    ContinuousAt (fun x ↦ (g x).comp (f x)) a 
goal: ContinuousAt (fun x => (g x).comp (f x)) a

full_name: ContinuousWithinAt.compCM
code: nonrec lemma _root_.ContinuousWithinAt.compCM (hg : ContinuousWithinAt g s a)
    (hf : ContinuousWithinAt f s a) : ContinuousWithinAt (fun x ↦ (g x).comp (f x)) s a 
goal: ContinuousWithinAt (fun x => (g x).comp (f x)) s a

full_name: ContinuousOn.compCM
code: lemma _root_.ContinuousOn.compCM (hg : ContinuousOn g s) (hf : ContinuousOn f s) :
    ContinuousOn (fun x ↦ (g x).comp (f x)) s 
goal: ContinuousOn (fun x => (g x).comp (f x)) s

full_name: Continuous.compCM
code: lemma _root_.Continuous.compCM (hg : Continuous g) (hf : Continuous f) :
    Continuous fun x => (g x).comp (f x) 
goal: Continuous fun x => (g x).comp (f x)

full_name: ContinuousMap.continuous.comp'
code: @[deprecated _root_.Continuous.compCM (since := "2024-01-30")]
lemma continuous.comp' (hf : Continuous f) (hg : Continuous g) :
    Continuous fun x => (g x).comp (f x) 
goal: Continuous fun x => (g x).comp (f x)

full_name: ContinuousMap.continuous_eval
code: /-- The evaluation map `C(X, Y) × X → Y` is continuous
if `X, Y` is a locally compact pair of spaces. -/
@[continuity]
theorem continuous_eval [LocallyCompactPair X Y] : Continuous fun p : C(X, Y) × X => p.1 p.2 
goal: Continuous fun p => p.1 p.2

full_name: ContinuousMap.continuous_eval_const
code: /-- Evaluation of a continuous map `f` at a point `x` is continuous in `f`.

Porting note: merged `continuous_eval_const` with `continuous_eval_const'` removing unneeded
assumptions. -/
@[continuity]
theorem continuous_eval_const (a : X) : Continuous fun f : C(X, Y) => f a 
goal: Continuous fun f => f a

full_name: ContinuousMap.continuous_coe
code: /-- Coercion from `C(X, Y)` with compact-open topology to `X → Y` with pointwise convergence
topology is a continuous map.

Porting note: merged `continuous_coe` with `continuous_coe'` removing unneeded assumptions. -/
theorem continuous_coe : Continuous ((⇑) : C(X, Y) → (X → Y)) 
goal: Continuous DFunLike.coe

full_name: ContinuousMap.isClosed_setOf_mapsTo
code: lemma isClosed_setOf_mapsTo {t : Set Y} (ht : IsClosed t) (s : Set X) :
    IsClosed {f : C(X, Y) | MapsTo f s t} 
goal: IsClosed {f | Set.MapsTo (⇑f) s t}

full_name: ContinuousMap.isClopen_setOf_mapsTo
code: lemma isClopen_setOf_mapsTo (hK : IsCompact K) (hU : IsClopen U) :
    IsClopen {f : C(X, Y) | MapsTo f K U} 
goal: IsClopen {f | Set.MapsTo (⇑f) K U}

full_name: ContinuousMap.specializes_coe
code: @[norm_cast]
lemma specializes_coe {f g : C(X, Y)} : ⇑f ⤳ ⇑g ↔ f ⤳ g 
goal: ⇑f ⤳ ⇑g ↔ f ⤳ g

full_name: ContinuousMap.inseparable_coe
code: @[norm_cast]
lemma inseparable_coe {f g : C(X, Y)} : Inseparable (f : X → Y) g ↔ Inseparable f g 
goal: Inseparable ⇑f ⇑g ↔ Inseparable f g

full_name: ContinuousMap.instT0Space
code: instance [T0Space Y] : T0Space C(X, Y) 
goal: T0Space C(X, Y)

full_name: ContinuousMap.instR0Space
code: instance [R0Space Y] : R0Space C(X, Y) 
goal: R0Space C(X, Y)

full_name: ContinuousMap.instT1Space
code: instance [T1Space Y] : T1Space C(X, Y) 
goal: T1Space C(X, Y)

full_name: ContinuousMap.instR1Space
code: instance [R1Space Y] : R1Space C(X, Y) 
goal: R1Space C(X, Y)

full_name: ContinuousMap.instT2Space
code: instance [T2Space Y] : T2Space C(X, Y) 
goal: T2Space C(X, Y)

full_name: ContinuousMap.instRegularSpace
code: instance [RegularSpace Y] : RegularSpace C(X, Y) 
goal: RegularSpace C(X, Y)

full_name: ContinuousMap.instT3Space
code: instance [T3Space Y] : T3Space C(X, Y) 
goal: T3Space C(X, Y)

full_name: ContinuousMap.continuous_restrict
code: /-- For any subset `s` of `X`, the restriction of continuous functions to `s` is continuous
as a function from `C(X, Y)` to `C(s, Y)` with their respective compact-open topologies. -/
theorem continuous_restrict (s : Set X) : Continuous fun F : C(X, Y) => F.restrict s 
goal: Continuous fun F => ContinuousMap.restrict s F

full_name: ContinuousMap.compactOpen_le_induced
code: theorem compactOpen_le_induced (s : Set X) :
    (ContinuousMap.compactOpen : TopologicalSpace C(X, Y)) ≤
      .induced (restrict s) ContinuousMap.compactOpen 
goal: ContinuousMap.compactOpen ≤ TopologicalSpace.induced (ContinuousMap.restrict s) ContinuousMap.compactOpen

full_name: ContinuousMap.compactOpen_eq_iInf_induced
code: /-- The compact-open topology on `C(X, Y)`
is equal to the infimum of the compact-open topologies on `C(s, Y)` for `s` a compact subset of `X`.
The key point of the proof is that for every compact set `K`,
the universal set `Set.univ : Set K` is a compact set as well. -/
theorem compactOpen_eq_iInf_induced :
    (ContinuousMap.compactOpen : TopologicalSpace C(X, Y)) =
      ⨅ (K : Set X) (_ : IsCompact K), .induced (.restrict K) ContinuousMap.compactOpen 
goal: ContinuousMap.compactOpen =
  ⨅ K, ⨅ (_ : IsCompact K), TopologicalSpace.induced (ContinuousMap.restrict K) ContinuousMap.compactOpen

full_name: ContinuousMap.nhds_compactOpen_eq_iInf_nhds_induced
code: theorem nhds_compactOpen_eq_iInf_nhds_induced (f : C(X, Y)) :
    𝓝 f = ⨅ (s) (hs : IsCompact s), (𝓝 (f.restrict s)).comap (ContinuousMap.restrict s) 
goal: 𝓝 f = ⨅ s, ⨅ (_ : IsCompact s), Filter.comap (ContinuousMap.restrict s) (𝓝 (ContinuousMap.restrict s f))

full_name: ContinuousMap.tendsto_compactOpen_restrict
code: theorem tendsto_compactOpen_restrict {ι : Type*} {l : Filter ι} {F : ι → C(X, Y)} {f : C(X, Y)}
    (hFf : Filter.Tendsto F l (𝓝 f)) (s : Set X) :
    Tendsto (fun i => (F i).restrict s) l (𝓝 (f.restrict s)) 
goal: Filter.Tendsto (fun i => ContinuousMap.restrict s (F i)) l (𝓝 (ContinuousMap.restrict s f))

full_name: ContinuousMap.tendsto_compactOpen_iff_forall
code: theorem tendsto_compactOpen_iff_forall {ι : Type*} {l : Filter ι} (F : ι → C(X, Y)) (f : C(X, Y)) :
    Tendsto F l (𝓝 f) ↔
      ∀ K, IsCompact K → Tendsto (fun i => (F i).restrict K) l (𝓝 (f.restrict K)) 
goal: Filter.Tendsto F l (𝓝 f) ↔
  ∀ (K : Set X),
    IsCompact K → Filter.Tendsto (fun i => ContinuousMap.restrict K (F i)) l (𝓝 (ContinuousMap.restrict K f))

full_name: ContinuousMap.exists_tendsto_compactOpen_iff_forall
code: /-- A family `F` of functions in `C(X, Y)` converges in the compact-open topology, if and only if
it converges in the compact-open topology on each compact subset of `X`. -/
theorem exists_tendsto_compactOpen_iff_forall [WeaklyLocallyCompactSpace X] [T2Space Y]
    {ι : Type*} {l : Filter ι} [Filter.NeBot l] (F : ι → C(X, Y)) :
    (∃ f, Filter.Tendsto F l (𝓝 f)) ↔
      ∀ s : Set X, IsCompact s → ∃ f, Filter.Tendsto (fun i => (F i).restrict s) l (𝓝 f) 
goal: (∃ f, Filter.Tendsto F l (𝓝 f)) ↔
  ∀ (s : Set X), IsCompact s → ∃ f, Filter.Tendsto (fun i => ContinuousMap.restrict s (F i)) l (𝓝 f)

full_name: ContinuousMap.coev_apply
code: /-- The coevaluation map `Y → C(X, Y × X)` sending a point `x : Y` to the continuous function
on `X` sending `y` to `(x, y)`. -/
@[simps (config := .asFn)]
def coev (b : Y) : C(X, Y × X) 
goal: ⇑(ContinuousMap.coev X Y b) = Prod.mk b

full_name: ContinuousMap.coev
code: /-- The coevaluation map `Y → C(X, Y × X)` sending a point `x : Y` to the continuous function
on `X` sending `y` to `(x, y)`. -/
@[simps (config := .asFn)]
def coev (b : Y) : C(X, Y × X) 
goal: C(X, Y × X)

full_name: ContinuousMap.image_coev
code: theorem image_coev {y : Y} (s : Set X) : coev X Y y '' s = {y} ×ˢ s 
goal: ⇑(ContinuousMap.coev X Y y) '' s = {y} ×ˢ s

full_name: ContinuousMap.continuous_coev
code: /-- The coevaluation map `Y → C(X, Y × X)` is continuous (always). -/
theorem continuous_coev : Continuous (coev X Y) 
goal: Continuous (ContinuousMap.coev X Y)

full_name: ContinuousMap.curry
code: /-- The curried form of a continuous map `α × β → γ` as a continuous map `α → C(β, γ)`.
    If `a × β` is locally compact, this is continuous. If `α` and `β` are both locally
    compact, then this is a homeomorphism, see `Homeomorph.curry`. -/
def curry (f : C(X × Y, Z)) : C(X, C(Y, Z)) 
goal: C(X, C(Y, Z))

full_name: ContinuousMap.curry_apply
code: @[simp]
theorem curry_apply (f : C(X × Y, Z)) (a : X) (b : Y) : f.curry a b = f (a, b) 
goal: (f.curry a) b = f (a, b)

full_name: ContinuousMap.curry'
code: /-- Auxiliary definition, see `ContinuousMap.curry` and `Homeomorph.curry`. -/
@[deprecated ContinuousMap.curry (since := "2024-03-05")]
def curry' (f : C(X × Y, Z)) (a : X) : C(Y, Z) 
goal: C(Y, Z)

full_name: ContinuousMap.continuous_curry'
code: /-- If a map `α × β → γ` is continuous, then its curried form `α → C(β, γ)` is continuous. -/
@[deprecated ContinuousMap.curry (since := "2024-03-05")]
theorem continuous_curry' (f : C(X × Y, Z)) : Continuous (curry' f) 
goal: Continuous f.curry'

full_name: ContinuousMap.continuous_of_continuous_uncurry
code: /-- To show continuity of a map `α → C(β, γ)`, it suffices to show that its uncurried form
    `α × β → γ` is continuous. -/
theorem continuous_of_continuous_uncurry (f : X → C(Y, Z))
    (h : Continuous (Function.uncurry fun x y => f x y)) : Continuous f 
goal: Continuous f

full_name: ContinuousMap.continuous_curry
code: /-- The currying process is a continuous map between function spaces. -/
theorem continuous_curry [LocallyCompactSpace (X × Y)] :
    Continuous (curry : C(X × Y, Z) → C(X, C(Y, Z))) 
goal: Continuous ContinuousMap.curry

full_name: ContinuousMap.continuous_uncurry_of_continuous
code: /-- The uncurried form of a continuous map `X → C(Y, Z)` is a continuous map `X × Y → Z`. -/
theorem continuous_uncurry_of_continuous [LocallyCompactSpace Y] (f : C(X, C(Y, Z))) :
    Continuous (Function.uncurry fun x y => f x y) 
goal: Continuous (Function.uncurry fun x y => (f x) y)

full_name: ContinuousMap.uncurry_apply
code: /-- The uncurried form of a continuous map `X → C(Y, Z)` as a continuous map `X × Y → Z` (if `Y` is
    locally compact). If `X` is also locally compact, then this is a homeomorphism between the two
    function spaces, see `Homeomorph.curry`. -/
@[simps]
def uncurry [LocallyCompactSpace Y] (f : C(X, C(Y, Z))) : C(X × Y, Z) 
goal: ∀ (a : X × Y), f.uncurry a = Function.uncurry (fun x y => (f x) y) a

full_name: ContinuousMap.uncurry
code: /-- The uncurried form of a continuous map `X → C(Y, Z)` as a continuous map `X × Y → Z` (if `Y` is
    locally compact). If `X` is also locally compact, then this is a homeomorphism between the two
    function spaces, see `Homeomorph.curry`. -/
@[simps]
def uncurry [LocallyCompactSpace Y] (f : C(X, C(Y, Z))) : C(X × Y, Z) 
goal: C(X × Y, Z)

full_name: ContinuousMap.continuous_uncurry
code: /-- The uncurrying process is a continuous map between function spaces. -/
theorem continuous_uncurry [LocallyCompactSpace X] [LocallyCompactSpace Y] :
    Continuous (uncurry : C(X, C(Y, Z)) → C(X × Y, Z)) 
goal: Continuous ContinuousMap.uncurry

full_name: ContinuousMap.const'
code: /-- The family of constant maps: `Y → C(X, Y)` as a continuous map. -/
def const' : C(Y, C(X, Y)) 
goal: C(Y, C(X, Y))

full_name: ContinuousMap.coe_const'
code: @[simp]
theorem coe_const' : (const' : Y → C(X, Y)) = const X 
goal: ⇑ContinuousMap.const' = ContinuousMap.const X

full_name: ContinuousMap.continuous_const'
code: theorem continuous_const' : Continuous (const X : Y → C(X, Y)) 
goal: Continuous (ContinuousMap.const X)

full_name: Homeomorph.curry
code: /-- Currying as a homeomorphism between the function spaces `C(X × Y, Z)` and `C(X, C(Y, Z))`. -/
def curry [LocallyCompactSpace X] [LocallyCompactSpace Y] : C(X × Y, Z) ≃ₜ C(X, C(Y, Z)) 
goal: C(X × Y, Z) ≃ₜ C(X, C(Y, Z))

full_name: Homeomorph.continuousMapOfUnique
code: /-- If `X` has a single element, then `Y` is homeomorphic to `C(X, Y)`. -/
def continuousMapOfUnique [Unique X] : Y ≃ₜ C(X, Y) 
goal: Y ≃ₜ C(X, Y)

full_name: Homeomorph.continuousMapOfUnique_apply
code: @[simp]
theorem continuousMapOfUnique_apply [Unique X] (y : Y) (x : X) : continuousMapOfUnique y x = y 
goal: (Homeomorph.continuousMapOfUnique y) x = y

full_name: Homeomorph.continuousMapOfUnique_symm_apply
code: @[simp]
theorem continuousMapOfUnique_symm_apply [Unique X] (f : C(X, Y)) :
    continuousMapOfUnique.symm f = f default 
goal: Homeomorph.continuousMapOfUnique.symm f = f default

full_name: QuotientMap.continuous_lift_prod_left
code: theorem QuotientMap.continuous_lift_prod_left (hf : QuotientMap f) {g : X × Y → Z}
    (hg : Continuous fun p : X₀ × Y => g (f p.1, p.2)) : Continuous g 
goal: Continuous g

full_name: QuotientMap.continuous_lift_prod_right
code: theorem QuotientMap.continuous_lift_prod_right (hf : QuotientMap f) {g : Y × X → Z}
    (hg : Continuous fun p : Y × X₀ => g (p.1, f p.2)) : Continuous g 
goal: Continuous g