File: Mathlib/Topology/ContinuousFunction/Basic.lean

full_name: ContinuousMap
code: /-- The type of continuous maps from `α` to `β`.

When possible, instead of parametrizing results over `(f : C(α, β))`,
you should parametrize over `{F : Type*} [ContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `ContinuousMapClass`. -/
structure ContinuousMap (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] where
  /-- The function `α → β` -/
  protected toFun : α → β
  /-- Proposition that `toFun` is continuous -/
  protected continuous_toFun : Continuous toFun := by continuity
goal: Type (max u_1 u_2)

full_name: ContinuousMap.toFun
code: /-- The type of continuous maps from `α` to `β`.

When possible, instead of parametrizing results over `(f : C(α, β))`,
you should parametrize over `{F : Type*} [ContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `ContinuousMapClass`. -/
structure ContinuousMap (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] where
  /-- The function `α → β` -/
  protected toFun : α → β
  /-- Proposition that `toFun` is continuous -/
  protected continuous_toFun : Continuous toFun := by continuity
goal: α → β

full_name: ContinuousMap.continuous_toFun
code: /-- The type of continuous maps from `α` to `β`.

When possible, instead of parametrizing results over `(f : C(α, β))`,
you should parametrize over `{F : Type*} [ContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `ContinuousMapClass`. -/
structure ContinuousMap (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] where
  /-- The function `α → β` -/
  protected toFun : α → β
  /-- Proposition that `toFun` is continuous -/
  protected continuous_toFun : Continuous toFun := by continuity
goal: Continuous self.toFun

full_name: «_aux_Mathlib_Topology_ContinuousFunction_Basic___macroRules_termC(_,_)_1»
code: /-- The type of continuous maps from `α` to `β`. -/
notation "C(" α ", " β ")" => ContinuousMap α β
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_ContinuousFunction_Basic___unexpand_ContinuousMap_1
code: /-- The type of continuous maps from `α` to `β`. -/
notation "C(" α ", " β ")" => ContinuousMap α β
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousMapClass.map_continuous
code: /-- `ContinuousMapClass F α β` states that `F` is a type of continuous maps.

You should extend this class when you extend `ContinuousMap`. -/
class ContinuousMapClass (F α β : Type*) [TopologicalSpace α] [TopologicalSpace β]
    [FunLike F α β] : Prop where
  /-- Continuity -/
  map_continuous (f : F) : Continuous f
goal: Continuous ⇑f

full_name: ContinuousMapClass
code: /-- `ContinuousMapClass F α β` states that `F` is a type of continuous maps.

You should extend this class when you extend `ContinuousMap`. -/
class ContinuousMapClass (F α β : Type*) [TopologicalSpace α] [TopologicalSpace β]
    [FunLike F α β] : Prop where
  /-- Continuity -/
  map_continuous (f : F) : Continuous f
goal: Prop

full_name: map_continuousAt
code: theorem map_continuousAt (f : F) (a : α) : ContinuousAt f a 
goal: ContinuousAt (⇑f) a

full_name: map_continuousWithinAt
code: theorem map_continuousWithinAt (f : F) (s : Set α) (a : α) : ContinuousWithinAt f s a 
goal: ContinuousWithinAt (⇑f) s a

full_name: toContinuousMap
code: /-- Coerce a bundled morphism with a `ContinuousMapClass` instance to a `ContinuousMap`. -/
@[coe] def toContinuousMap (f : F) : C(α, β) 
goal: C(α, β)

full_name: instCoeTCContinuousMap
code: instance : CoeTC F C(α, β) 
goal: CoeTC F C(α, β)

full_name: ContinuousMap.funLike
code: instance funLike : FunLike C(α, β) α β 
goal: FunLike C(α, β) α β

full_name: ContinuousMap.toContinuousMapClass
code: instance toContinuousMapClass : ContinuousMapClass C(α, β) α β 
goal: ContinuousMapClass C(α, β) α β

full_name: ContinuousMap.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe {f : C(α, β)} : f.toFun = (f : α → β) 
goal: f.toFun = ⇑f

full_name: ContinuousMap.instCanLiftForallCoeContinuous
code: instance : CanLift (α → β) C(α, β) DFunLike.coe Continuous 
goal: CanLift (α → β) C(α, β) DFunLike.coe Continuous

full_name: ContinuousMap.Simps.apply
code: /-- See note [custom simps projection]. -/
def Simps.apply (f : C(α, β)) : α → β 
goal: α → β

full_name: ContinuousMap.coe_coe
code: @[simp] -- Porting note: removed `norm_cast` attribute
protected theorem coe_coe {F : Type*} [FunLike F α β] [ContinuousMapClass F α β] (f : F) :
    ⇑(f : C(α, β)) = f 
goal: ⇑↑f = ⇑f

full_name: ContinuousMap.ext
code: @[ext]
theorem ext {f g : C(α, β)} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: ContinuousMap.copy
code: /-- Copy of a `ContinuousMap` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (f : C(α, β)) (f' : α → β) (h : f' = f) : C(α, β) 
goal: C(α, β)

full_name: ContinuousMap.coe_copy
code: @[simp]
theorem coe_copy (f : C(α, β)) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: ContinuousMap.copy_eq
code: theorem copy_eq (f : C(α, β)) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: ContinuousMap.continuous
code: /-- Deprecated. Use `map_continuous` instead. -/
protected theorem continuous (f : C(α, β)) : Continuous f 
goal: Continuous ⇑f

full_name: ContinuousMap.continuous_set_coe
code: @[continuity]
theorem continuous_set_coe (s : Set C(α, β)) (f : s) : Continuous (f : α → β) 
goal: Continuous ⇑↑f

full_name: ContinuousMap.continuousAt
code: /-- Deprecated. Use `map_continuousAt` instead. -/
protected theorem continuousAt (f : C(α, β)) (x : α) : ContinuousAt f x 
goal: ContinuousAt (⇑f) x

full_name: ContinuousMap.congr_fun
code: /-- Deprecated. Use `DFunLike.congr_fun` instead. -/
protected theorem congr_fun {f g : C(α, β)} (H : f = g) (x : α) : f x = g x 
goal: f x = g x

full_name: ContinuousMap.congr_arg
code: /-- Deprecated. Use `DFunLike.congr_arg` instead. -/
protected theorem congr_arg (f : C(α, β)) {x y : α} (h : x = y) : f x = f y 
goal: f x = f y

full_name: ContinuousMap.coe_injective
code: theorem coe_injective : @Function.Injective C(α, β) (α → β) (↑) 
goal: Function.Injective DFunLike.coe

full_name: ContinuousMap.coe_mk
code: @[simp]
theorem coe_mk (f : α → β) (h : Continuous f) : ⇑(⟨f, h⟩ : C(α, β)) = f 
goal: ⇑{ toFun := f, continuous_toFun := h } = f

full_name: ContinuousMap.map_specializes
code: theorem map_specializes (f : C(α, β)) {x y : α} (h : x ⤳ y) : f x ⤳ f y 
goal: f x ⤳ f y

full_name: ContinuousMap.equivFnOfDiscrete_symm_apply_apply
code: /--
The continuous functions from `α` to `β` are the same as the plain functions when `α` is discrete.
-/
@[simps]
def equivFnOfDiscrete [DiscreteTopology α] : C(α, β) ≃ (α → β) 
goal: ∀ (a : α), ((ContinuousMap.equivFnOfDiscrete α β).symm f) a = f a

full_name: ContinuousMap.equivFnOfDiscrete_apply
code: /--
The continuous functions from `α` to `β` are the same as the plain functions when `α` is discrete.
-/
@[simps]
def equivFnOfDiscrete [DiscreteTopology α] : C(α, β) ≃ (α → β) 
goal: (ContinuousMap.equivFnOfDiscrete α β) f a = f a

full_name: ContinuousMap.equivFnOfDiscrete
code: /--
The continuous functions from `α` to `β` are the same as the plain functions when `α` is discrete.
-/
@[simps]
def equivFnOfDiscrete [DiscreteTopology α] : C(α, β) ≃ (α → β) 
goal: C(α, β) ≃ (α → β)

full_name: ContinuousMap.id
code: /-- The identity as a continuous map. -/
protected def id : C(α, α) 
goal: C(α, α)

full_name: ContinuousMap.coe_id
code: @[simp]
theorem coe_id : ⇑(ContinuousMap.id α) = id 
goal: ⇑(ContinuousMap.id α) = id

full_name: ContinuousMap.const
code: /-- The constant map as a continuous map. -/
def const (b : β) : C(α, β) 
goal: C(α, β)

full_name: ContinuousMap.coe_const
code: @[simp]
theorem coe_const (b : β) : ⇑(const α b) = Function.const α b 
goal: ⇑(ContinuousMap.const α b) = Function.const α b

full_name: ContinuousMap.constPi
code: /-- `Function.const α b` as a bundled continuous function of `b`. -/
@[simps (config := .asFn)]
def constPi : C(β, α → β) 
goal: C(β, α → β)

full_name: ContinuousMap.constPi_apply
code: /-- `Function.const α b` as a bundled continuous function of `b`. -/
@[simps (config := .asFn)]
def constPi : C(β, α → β) 
goal: ⇑(ContinuousMap.constPi α) = fun b => Function.const α b

full_name: ContinuousMap.instInhabited
code: instance [Inhabited β] : Inhabited C(α, β) 
goal: Inhabited C(α, β)

full_name: ContinuousMap.id_apply
code: @[simp]
theorem id_apply (a : α) : ContinuousMap.id α a = a 
goal: (ContinuousMap.id α) a = a

full_name: ContinuousMap.const_apply
code: @[simp]
theorem const_apply (b : β) (a : α) : const α b a = b 
goal: (ContinuousMap.const α b) a = b

full_name: ContinuousMap.comp
code: /-- The composition of continuous maps, as a continuous map. -/
def comp (f : C(β, γ)) (g : C(α, β)) : C(α, γ) 
goal: C(α, γ)

full_name: ContinuousMap.coe_comp
code: @[simp]
theorem coe_comp (f : C(β, γ)) (g : C(α, β)) : ⇑(comp f g) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: ContinuousMap.comp_apply
code: @[simp]
theorem comp_apply (f : C(β, γ)) (g : C(α, β)) (a : α) : comp f g a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: ContinuousMap.comp_assoc
code: @[simp]
theorem comp_assoc (f : C(γ, δ)) (g : C(β, γ)) (h : C(α, β)) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: ContinuousMap.id_comp
code: @[simp]
theorem id_comp (f : C(α, β)) : (ContinuousMap.id _).comp f = f 
goal: (ContinuousMap.id β).comp f = f

full_name: ContinuousMap.comp_id
code: @[simp]
theorem comp_id (f : C(α, β)) : f.comp (ContinuousMap.id _) = f 
goal: f.comp (ContinuousMap.id α) = f

full_name: ContinuousMap.const_comp
code: @[simp]
theorem const_comp (c : γ) (f : C(α, β)) : (const β c).comp f = const α c 
goal: (ContinuousMap.const β c).comp f = ContinuousMap.const α c

full_name: ContinuousMap.comp_const
code: @[simp]
theorem comp_const (f : C(β, γ)) (b : β) : f.comp (const α b) = const α (f b) 
goal: f.comp (ContinuousMap.const α b) = ContinuousMap.const α (f b)

full_name: ContinuousMap.cancel_right
code: @[simp]
theorem cancel_right {f₁ f₂ : C(β, γ)} {g : C(α, β)} (hg : Surjective g) :
    f₁.comp g = f₂.comp g ↔ f₁ = f₂ 
goal: f₁.comp g = f₂.comp g ↔ f₁ = f₂

full_name: ContinuousMap.cancel_left
code: @[simp]
theorem cancel_left {f : C(β, γ)} {g₁ g₂ : C(α, β)} (hf : Injective f) :
    f.comp g₁ = f.comp g₂ ↔ g₁ = g₂ 
goal: f.comp g₁ = f.comp g₂ ↔ g₁ = g₂

full_name: ContinuousMap.instNontrivialOfNonempty
code: instance [Nonempty α] [Nontrivial β] : Nontrivial C(α, β) 
goal: Nontrivial C(α, β)

full_name: ContinuousMap.fst_apply
code: /-- `Prod.fst : (x, y) ↦ x` as a bundled continuous map. -/
@[simps (config := .asFn)]
def fst : C(α × β, α) 
goal: ⇑ContinuousMap.fst = Prod.fst

full_name: ContinuousMap.fst
code: /-- `Prod.fst : (x, y) ↦ x` as a bundled continuous map. -/
@[simps (config := .asFn)]
def fst : C(α × β, α) 
goal: C(α × β, α)

full_name: ContinuousMap.snd
code: /-- `Prod.snd : (x, y) ↦ y` as a bundled continuous map. -/
@[simps (config := .asFn)]
def snd : C(α × β, β) 
goal: C(α × β, β)

full_name: ContinuousMap.snd_apply
code: /-- `Prod.snd : (x, y) ↦ y` as a bundled continuous map. -/
@[simps (config := .asFn)]
def snd : C(α × β, β) 
goal: ⇑ContinuousMap.snd = Prod.snd

full_name: ContinuousMap.prodMk
code: /-- Given two continuous maps `f` and `g`, this is the continuous map `x ↦ (f x, g x)`. -/
def prodMk (f : C(α, β₁)) (g : C(α, β₂)) : C(α, β₁ × β₂) 
goal: C(α, β₁ × β₂)

full_name: ContinuousMap.prodMap
code: /-- Given two continuous maps `f` and `g`, this is the continuous map `(x, y) ↦ (f x, g y)`. -/
@[simps]
def prodMap (f : C(α₁, α₂)) (g : C(β₁, β₂)) : C(α₁ × β₁, α₂ × β₂) 
goal: C(α₁ × β₁, α₂ × β₂)

full_name: ContinuousMap.prodMap_apply
code: /-- Given two continuous maps `f` and `g`, this is the continuous map `(x, y) ↦ (f x, g y)`. -/
@[simps]
def prodMap (f : C(α₁, α₂)) (g : C(β₁, β₂)) : C(α₁ × β₁, α₂ × β₂) 
goal: ∀ (a : α₁ × β₁), (f.prodMap g) a = Prod.map (⇑f) (⇑g) a

full_name: ContinuousMap.prod_eval
code: @[simp]
theorem prod_eval (f : C(α, β₁)) (g : C(α, β₂)) (a : α) : (prodMk f g) a = (f a, g a) 
goal: (f.prodMk g) a = (f a, g a)

full_name: ContinuousMap.prodSwap
code: /-- `Prod.swap` bundled as a `ContinuousMap`. -/
@[simps!]
def prodSwap : C(α × β, β × α) 
goal: C(α × β, β × α)

full_name: ContinuousMap.prodSwap_apply
code: /-- `Prod.swap` bundled as a `ContinuousMap`. -/
@[simps!]
def prodSwap : C(α × β, β × α) 
goal: ContinuousMap.prodSwap x = (x.2, x.1)

full_name: ContinuousMap.sigmaMk_apply
code: /-- `Sigma.mk i` as a bundled continuous map. -/
@[simps apply]
def sigmaMk (i : I) : C(X i, Σ i, X i) 
goal: (ContinuousMap.sigmaMk i) snd = ⟨i, snd⟩

full_name: ContinuousMap.sigmaMk
code: /-- `Sigma.mk i` as a bundled continuous map. -/
@[simps apply]
def sigmaMk (i : I) : C(X i, Σ i, X i) 
goal: C(X i, (i : I) × X i)

full_name: ContinuousMap.sigma_apply
code: /--
To give a continuous map out of a disjoint union, it suffices to give a continuous map out of
each term. This is `Sigma.uncurry` for continuous maps.
-/
@[simps]
def sigma (f : ∀ i, C(X i, A)) : C((Σ i, X i), A) 
goal: (ContinuousMap.sigma f) ig = (f ig.fst) ig.snd

full_name: ContinuousMap.sigma
code: /--
To give a continuous map out of a disjoint union, it suffices to give a continuous map out of
each term. This is `Sigma.uncurry` for continuous maps.
-/
@[simps]
def sigma (f : ∀ i, C(X i, A)) : C((Σ i, X i), A) 
goal: C((i : I) × X i, A)

full_name: ContinuousMap.sigmaEquiv_symm_apply
code: /--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term. This is a version of `Equiv.piCurry` for continuous maps.
-/
@[simps]
def sigmaEquiv : (∀ i, C(X i, A)) ≃ C((Σ i, X i), A) 
goal: (ContinuousMap.sigmaEquiv A X).symm f i = f.comp (ContinuousMap.sigmaMk i)

full_name: ContinuousMap.sigmaEquiv
code: /--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term. This is a version of `Equiv.piCurry` for continuous maps.
-/
@[simps]
def sigmaEquiv : (∀ i, C(X i, A)) ≃ C((Σ i, X i), A) 
goal: ((i : I) → C(X i, A)) ≃ C((i : I) × X i, A)

full_name: ContinuousMap.sigmaEquiv_apply
code: /--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term. This is a version of `Equiv.piCurry` for continuous maps.
-/
@[simps]
def sigmaEquiv : (∀ i, C(X i, A)) ≃ C((Σ i, X i), A) 
goal: (ContinuousMap.sigmaEquiv A X) f = ContinuousMap.sigma f

full_name: ContinuousMap.pi
code: /-- Abbreviation for product of continuous maps, which is continuous -/
def pi (f : ∀ i, C(A, X i)) : C(A, ∀ i, X i) 
goal: C(A, (i : I) → X i)

full_name: ContinuousMap.pi_eval
code: @[simp]
theorem pi_eval (f : ∀ i, C(A, X i)) (a : A) : (pi f) a = fun i : I => (f i) a 
goal: (ContinuousMap.pi f) a = fun i => (f i) a

full_name: ContinuousMap.eval_apply
code: /-- Evaluation at point as a bundled continuous map. -/
@[simps (config := .asFn)]
def eval (i : I) : C(∀ j, X j, X i) 
goal: ⇑(ContinuousMap.eval i) = Function.eval i

full_name: ContinuousMap.eval
code: /-- Evaluation at point as a bundled continuous map. -/
@[simps (config := .asFn)]
def eval (i : I) : C(∀ j, X j, X i) 
goal: C((j : I) → X j, X i)

full_name: ContinuousMap.piEquiv_apply
code: /--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term
-/
@[simps]
def piEquiv : (∀ i, C(A, X i)) ≃ C(A, ∀ i, X i) 
goal: (ContinuousMap.piEquiv A X) f = ContinuousMap.pi f

full_name: ContinuousMap.piEquiv
code: /--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term
-/
@[simps]
def piEquiv : (∀ i, C(A, X i)) ≃ C(A, ∀ i, X i) 
goal: ((i : I) → C(A, X i)) ≃ C(A, (i : I) → X i)

full_name: ContinuousMap.piEquiv_symm_apply
code: /--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term
-/
@[simps]
def piEquiv : (∀ i, C(A, X i)) ≃ C(A, ∀ i, X i) 
goal: (ContinuousMap.piEquiv A X).symm f i = (ContinuousMap.eval i).comp f

full_name: ContinuousMap.piMap
code: /-- Combine a collection of bundled continuous maps `C(X i, Y i)` into a bundled continuous map
`C(∀ i, X i, ∀ i, Y i)`. -/
@[simps!]
def piMap (f : ∀ i, C(X i, Y i)) : C((i : I) → X i, (i : I) → Y i) 
goal: C((i : I) → X i, (i : I) → Y i)

full_name: ContinuousMap.piMap_apply
code: /-- Combine a collection of bundled continuous maps `C(X i, Y i)` into a bundled continuous map
`C(∀ i, X i, ∀ i, Y i)`. -/
@[simps!]
def piMap (f : ∀ i, C(X i, Y i)) : C((i : I) → X i, (i : I) → Y i) 
goal: (ContinuousMap.piMap f) a i = (f i) (a i)

full_name: ContinuousMap.precomp
code: /-- "Precomposition" as a continuous map between dependent types. -/
def precomp {ι : Type*} (φ : ι → I) : C((i : I) → X i, (i : ι) → X (φ i)) 
goal: C((i : I) → X i, (i : ι) → X (φ i))

full_name: ContinuousMap.restrict
code: /-- The restriction of a continuous function `α → β` to a subset `s` of `α`. -/
def restrict (f : C(α, β)) : C(s, β) 
goal: C(↑s, β)

full_name: ContinuousMap.coe_restrict
code: @[simp]
theorem coe_restrict (f : C(α, β)) : ⇑(f.restrict s) = f ∘ ((↑) : s → α) 
goal: ⇑(ContinuousMap.restrict s f) = ⇑f ∘ Subtype.val

full_name: ContinuousMap.restrict_apply
code: @[simp]
theorem restrict_apply (f : C(α, β)) (s : Set α) (x : s) : f.restrict s x = f x 
goal: (ContinuousMap.restrict s f) x = f ↑x

full_name: ContinuousMap.restrict_apply_mk
code: @[simp]
theorem restrict_apply_mk (f : C(α, β)) (s : Set α) (x : α) (hx : x ∈ s) :
    f.restrict s ⟨x, hx⟩ = f x 
goal: (ContinuousMap.restrict s f) ⟨x, hx⟩ = f x

full_name: ContinuousMap.injective_restrict
code: theorem injective_restrict [T2Space β] {s : Set α} (hs : Dense s) :
    Injective (restrict s : C(α, β) → C(s, β)) 
goal: Function.Injective (ContinuousMap.restrict s)

full_name: ContinuousMap.restrictPreimage_apply
code: /-- The restriction of a continuous map to the preimage of a set. -/
@[simps]
def restrictPreimage (f : C(α, β)) (s : Set β) : C(f ⁻¹' s, s) 
goal: ∀ (a : ↑(⇑f ⁻¹' s)), (f.restrictPreimage s) a = s.restrictPreimage (⇑f) a

full_name: ContinuousMap.restrictPreimage
code: /-- The restriction of a continuous map to the preimage of a set. -/
@[simps]
def restrictPreimage (f : C(α, β)) (s : Set β) : C(f ⁻¹' s, s) 
goal: C(↑(⇑f ⁻¹' s), ↑s)

full_name: ContinuousMap.liftCover
code: /-- A family `φ i` of continuous maps `C(S i, β)`, where the domains `S i` contain a neighbourhood
of each point in `α` and the functions `φ i` agree pairwise on intersections, can be glued to
construct a continuous map in `C(α, β)`. -/
noncomputable def liftCover : C(α, β) 
goal: C(α, β)

full_name: ContinuousMap.liftCover_coe
code: @[simp]
theorem liftCover_coe {i : ι} (x : S i) : liftCover S φ hφ hS x = φ i x 
goal: (ContinuousMap.liftCover S φ hφ hS) ↑x = (φ i) x

full_name: ContinuousMap.liftCover_restrict
code: theorem liftCover_restrict {i : ι} : (liftCover S φ hφ hS).restrict (S i) = φ i 
goal: ContinuousMap.restrict (S i) (ContinuousMap.liftCover S φ hφ hS) = φ i

full_name: ContinuousMap.liftCover'
code: /-- A family `F s` of continuous maps `C(s, β)`, where (1) the domains `s` are taken from a set `A`
of sets in `α` which contain a neighbourhood of each point in `α` and (2) the functions `F s` agree
pairwise on intersections, can be glued to construct a continuous map in `C(α, β)`. -/
noncomputable def liftCover' : C(α, β) 
goal: C(α, β)

full_name: ContinuousMap.liftCover_coe'
code: @[simp]
theorem liftCover_coe' {s : Set α} {hs : s ∈ A} (x : s) : liftCover' A F hF hA x = F s hs x 
goal: (ContinuousMap.liftCover' A F hF hA) ↑x = (F s hs) x

full_name: ContinuousMap.liftCover_restrict'
code: @[simp]
theorem liftCover_restrict' {s : Set α} {hs : s ∈ A} :
    (liftCover' A F hF hA).restrict s = F s hs 
goal: ContinuousMap.restrict s (ContinuousMap.liftCover' A F hF hA) = F s hs

full_name: Function.RightInverse.homeomorph
code: /-- `Setoid.quotientKerEquivOfRightInverse` as a homeomorphism. -/
@[simps!]
def Function.RightInverse.homeomorph {f' : C(Y, X)} (hf : Function.RightInverse f' f) :
    Quotient (Setoid.ker f) ≃ₜ Y 
goal: Quotient (Setoid.ker ⇑f) ≃ₜ Y

full_name: Function.RightInverse.homeomorph_symm_apply
code: /-- `Setoid.quotientKerEquivOfRightInverse` as a homeomorphism. -/
@[simps!]
def Function.RightInverse.homeomorph {f' : C(Y, X)} (hf : Function.RightInverse f' f) :
    Quotient (Setoid.ker f) ≃ₜ Y 
goal: hf.homeomorph.symm b = Quotient.mk'' (f' b)

full_name: Function.RightInverse.homeomorph_apply
code: /-- `Setoid.quotientKerEquivOfRightInverse` as a homeomorphism. -/
@[simps!]
def Function.RightInverse.homeomorph {f' : C(Y, X)} (hf : Function.RightInverse f' f) :
    Quotient (Setoid.ker f) ≃ₜ Y 
goal: hf.homeomorph a = a.liftOn' ⇑f ⋯

full_name: QuotientMap.homeomorph_symm_apply
code: /--
The homeomorphism from the quotient of a quotient map to its codomain. This is
`Setoid.quotientKerEquivOfSurjective` as a homeomorphism.
-/
@[simps!]
noncomputable def homeomorph (hf : QuotientMap f) : Quotient (Setoid.ker f) ≃ₜ Y 
goal: hf.homeomorph.symm b = Quotient.mk'' (Function.surjInv ⋯ b)

full_name: QuotientMap.homeomorph
code: /--
The homeomorphism from the quotient of a quotient map to its codomain. This is
`Setoid.quotientKerEquivOfSurjective` as a homeomorphism.
-/
@[simps!]
noncomputable def homeomorph (hf : QuotientMap f) : Quotient (Setoid.ker f) ≃ₜ Y 
goal: Quotient (Setoid.ker ⇑f) ≃ₜ Y

full_name: QuotientMap.homeomorph_apply
code: /--
The homeomorphism from the quotient of a quotient map to its codomain. This is
`Setoid.quotientKerEquivOfSurjective` as a homeomorphism.
-/
@[simps!]
noncomputable def homeomorph (hf : QuotientMap f) : Quotient (Setoid.ker f) ≃ₜ Y 
goal: hf.homeomorph a = a.liftOn' ⇑f ⋯

full_name: QuotientMap.lift_apply
code: /-- Descend a continuous map, which is constant on the fibres, along a quotient map. -/
@[simps]
noncomputable def lift : C(Y, Z) 
goal: ∀ (a : Y), (hf.lift g h) a = ((fun i => i.liftOn' ⇑g ⋯) ∘ ⇑hf.homeomorph.symm) a

full_name: QuotientMap.lift
code: /-- Descend a continuous map, which is constant on the fibres, along a quotient map. -/
@[simps]
noncomputable def lift : C(Y, Z) 
goal: C(Y, Z)

full_name: QuotientMap.lift_comp
code: /--
The obvious triangle induced by `QuotientMap.lift` commutes:
```
     g
  X --→ Z
  |   ↗
f |  / hf.lift g h
  v /
  Y
```
-/
@[simp]
theorem lift_comp : (hf.lift g h).comp f = g 
goal: (hf.lift g h).comp f = g

full_name: QuotientMap.liftEquiv_apply
code: /-- `QuotientMap.lift` as an equivalence. -/
@[simps]
noncomputable def liftEquiv : { g : C(X, Z) // Function.FactorsThrough g f} ≃ C(Y, Z) 
goal: hf.liftEquiv g = hf.lift ↑g ⋯

full_name: QuotientMap.liftEquiv_symm_apply_coe
code: /-- `QuotientMap.lift` as an equivalence. -/
@[simps]
noncomputable def liftEquiv : { g : C(X, Z) // Function.FactorsThrough g f} ≃ C(Y, Z) 
goal: ↑(hf.liftEquiv.symm g) = g.comp f

full_name: QuotientMap.liftEquiv
code: /-- `QuotientMap.lift` as an equivalence. -/
@[simps]
noncomputable def liftEquiv : { g : C(X, Z) // Function.FactorsThrough g f} ≃ C(Y, Z) 
goal: { g // Function.FactorsThrough ⇑g ⇑f } ≃ C(Y, Z)

full_name: Homeomorph.toContinuousMap
code: /-- The forward direction of a homeomorphism, as a bundled continuous map. -/
@[simps]
def toContinuousMap (e : α ≃ₜ β) : C(α, β) 
goal: C(α, β)

full_name: Homeomorph.toContinuousMap_apply
code: /-- The forward direction of a homeomorphism, as a bundled continuous map. -/
@[simps]
def toContinuousMap (e : α ≃ₜ β) : C(α, β) 
goal: e.toContinuousMap a = e a

full_name: Homeomorph.instCoeContinuousMap
code: /-- `Homeomorph.toContinuousMap` as a coercion. -/
instance : Coe (α ≃ₜ β) C(α, β) 
goal: Coe (α ≃ₜ β) C(α, β)

full_name: Homeomorph.coe_refl
code: @[simp]
theorem coe_refl : (Homeomorph.refl α : C(α, α)) = ContinuousMap.id α 
goal: (Homeomorph.refl α).toContinuousMap = ContinuousMap.id α

full_name: Homeomorph.coe_trans
code: @[simp]
theorem coe_trans : (f.trans g : C(α, γ)) = (g : C(β, γ)).comp f 
goal: (f.trans g).toContinuousMap = g.toContinuousMap.comp f.toContinuousMap

full_name: Homeomorph.symm_comp_toContinuousMap
code: /-- Left inverse to a continuous map from a homeomorphism, mirroring `Equiv.symm_comp_self`. -/
@[simp]
theorem symm_comp_toContinuousMap :
    (f.symm : C(β, α)).comp (f : C(α, β)) = ContinuousMap.id α 
goal: f.symm.toContinuousMap.comp f.toContinuousMap = ContinuousMap.id α

full_name: Homeomorph.toContinuousMap_comp_symm
code: /-- Right inverse to a continuous map from a homeomorphism, mirroring `Equiv.self_comp_symm`. -/
@[simp]
theorem toContinuousMap_comp_symm :
    (f : C(α, β)).comp (f.symm : C(β, α)) = ContinuousMap.id β 
goal: f.toContinuousMap.comp f.symm.toContinuousMap = ContinuousMap.id β