File: Mathlib/Topology/Homeomorph.lean

full_name: Homeomorph.continuous_toFun
code: /-- Homeomorphism between `X` and `Y`, also called topological isomorphism -/
structure Homeomorph (X : Type*) (Y : Type*) [TopologicalSpace X] [TopologicalSpace Y]
    extends X ≃ Y where
  /-- The forward map of a homeomorphism is a continuous function. -/
  continuous_toFun : Continuous toFun := by continuity
  /-- The inverse map of a homeomorphism is a continuous function. -/
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous self.toFun

full_name: Homeomorph.continuous_invFun
code: /-- Homeomorphism between `X` and `Y`, also called topological isomorphism -/
structure Homeomorph (X : Type*) (Y : Type*) [TopologicalSpace X] [TopologicalSpace Y]
    extends X ≃ Y where
  /-- The forward map of a homeomorphism is a continuous function. -/
  continuous_toFun : Continuous toFun := by continuity
  /-- The inverse map of a homeomorphism is a continuous function. -/
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous self.invFun

full_name: Homeomorph
code: /-- Homeomorphism between `X` and `Y`, also called topological isomorphism -/
structure Homeomorph (X : Type*) (Y : Type*) [TopologicalSpace X] [TopologicalSpace Y]
    extends X ≃ Y where
  /-- The forward map of a homeomorphism is a continuous function. -/
  continuous_toFun : Continuous toFun := by continuity
  /-- The inverse map of a homeomorphism is a continuous function. -/
  continuous_invFun : Continuous invFun := by continuity
goal: Type (max u_4 u_5)

full_name: _aux_Mathlib_Topology_Homeomorph___unexpand_Homeomorph_1
code: @[inherit_doc]
infixl:25 " ≃ₜ " => Homeomorph
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_Homeomorph___macroRules_term_≃ₜ__1»
code: @[inherit_doc]
infixl:25 " ≃ₜ " => Homeomorph
goal: Lean.Macro

full_name: Homeomorph.toEquiv_injective
code: theorem toEquiv_injective : Function.Injective (toEquiv : X ≃ₜ Y → X ≃ Y)
  
goal: Function.Injective Homeomorph.toEquiv

full_name: Homeomorph.instEquivLike
code: instance : EquivLike (X ≃ₜ Y) X Y 
goal: EquivLike (X ≃ₜ Y) X Y

full_name: Homeomorph.instCoeFunForall
code: instance : CoeFun (X ≃ₜ Y) fun _ ↦ X → Y 
goal: CoeFun (X ≃ₜ Y) fun x => X → Y

full_name: Homeomorph.homeomorph_mk_coe
code: @[simp] theorem homeomorph_mk_coe (a : X ≃ Y) (b c) : (Homeomorph.mk a b c : X → Y) = a 
goal: ⇑{ toEquiv := a, continuous_toFun := b, continuous_invFun := c } = ⇑a

full_name: Homeomorph.empty
code: /-- The unique homeomorphism between two empty types. -/
protected def empty [IsEmpty X] [IsEmpty Y] : X ≃ₜ Y 
goal: X ≃ₜ Y

full_name: Homeomorph.symm
code: /-- Inverse of a homeomorphism. -/
@[symm]
protected def symm (h : X ≃ₜ Y) : Y ≃ₜ X 
goal: Y ≃ₜ X

full_name: Homeomorph.symm_symm
code: @[simp] theorem symm_symm (h : X ≃ₜ Y) : h.symm.symm = h 
goal: h.symm.symm = h

full_name: Homeomorph.symm_bijective
code: theorem symm_bijective : Function.Bijective (Homeomorph.symm : (X ≃ₜ Y) → Y ≃ₜ X) 
goal: Function.Bijective Homeomorph.symm

full_name: Homeomorph.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (h : X ≃ₜ Y) : Y → X 
goal: Y → X

full_name: Homeomorph.coe_toEquiv
code: @[simp]
theorem coe_toEquiv (h : X ≃ₜ Y) : ⇑h.toEquiv = h 
goal: ⇑h.toEquiv = ⇑h

full_name: Homeomorph.coe_symm_toEquiv
code: @[simp]
theorem coe_symm_toEquiv (h : X ≃ₜ Y) : ⇑h.toEquiv.symm = h.symm 
goal: ⇑h.symm = ⇑h.symm

full_name: Homeomorph.ext
code: @[ext]
theorem ext {h h' : X ≃ₜ Y} (H : ∀ x, h x = h' x) : h = h' 
goal: h = h'

full_name: Homeomorph.refl
code: /-- Identity map as a homeomorphism. -/
@[simps! (config := .asFn) apply]
protected def refl (X : Type*) [TopologicalSpace X] : X ≃ₜ X 
goal: X ≃ₜ X

full_name: Homeomorph.refl_apply
code: /-- Identity map as a homeomorphism. -/
@[simps! (config := .asFn) apply]
protected def refl (X : Type*) [TopologicalSpace X] : X ≃ₜ X 
goal: ⇑(Homeomorph.refl X) = id

full_name: Homeomorph.trans
code: /-- Composition of two homeomorphisms. -/
@[trans]
protected def trans (h₁ : X ≃ₜ Y) (h₂ : Y ≃ₜ Z) : X ≃ₜ Z 
goal: X ≃ₜ Z

full_name: Homeomorph.trans_apply
code: @[simp]
theorem trans_apply (h₁ : X ≃ₜ Y) (h₂ : Y ≃ₜ Z) (x : X) : h₁.trans h₂ x = h₂ (h₁ x) 
goal: (h₁.trans h₂) x = h₂ (h₁ x)

full_name: Homeomorph.symm_trans_apply
code: @[simp]
theorem symm_trans_apply (f : X ≃ₜ Y) (g : Y ≃ₜ Z) (z : Z) :
    (f.trans g).symm z = f.symm (g.symm z) 
goal: (f.trans g).symm z = f.symm (g.symm z)

full_name: Homeomorph.homeomorph_mk_coe_symm
code: @[simp]
theorem homeomorph_mk_coe_symm (a : X ≃ Y) (b c) :
    ((Homeomorph.mk a b c).symm : Y → X) = a.symm 
goal: ⇑{ toEquiv := a, continuous_toFun := b, continuous_invFun := c }.symm = ⇑a.symm

full_name: Homeomorph.refl_symm
code: @[simp]
theorem refl_symm : (Homeomorph.refl X).symm = Homeomorph.refl X 
goal: (Homeomorph.refl X).symm = Homeomorph.refl X

full_name: Homeomorph.continuous
code: @[continuity, fun_prop]
protected theorem continuous (h : X ≃ₜ Y) : Continuous h 
goal: Continuous ⇑h

full_name: Homeomorph.continuous_symm
code: @[continuity]
protected theorem continuous_symm (h : X ≃ₜ Y) : Continuous h.symm 
goal: Continuous ⇑h.symm

full_name: Homeomorph.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (h : X ≃ₜ Y) (y : Y) : h (h.symm y) = y 
goal: h (h.symm y) = y

full_name: Homeomorph.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (h : X ≃ₜ Y) (x : X) : h.symm (h x) = x 
goal: h.symm (h x) = x

full_name: Homeomorph.self_trans_symm
code: @[simp]
theorem self_trans_symm (h : X ≃ₜ Y) : h.trans h.symm = Homeomorph.refl X 
goal: h.trans h.symm = Homeomorph.refl X

full_name: Homeomorph.symm_trans_self
code: @[simp]
theorem symm_trans_self (h : X ≃ₜ Y) : h.symm.trans h = Homeomorph.refl Y 
goal: h.symm.trans h = Homeomorph.refl Y

full_name: Homeomorph.bijective
code: protected theorem bijective (h : X ≃ₜ Y) : Function.Bijective h 
goal: Function.Bijective ⇑h

full_name: Homeomorph.injective
code: protected theorem injective (h : X ≃ₜ Y) : Function.Injective h 
goal: Function.Injective ⇑h

full_name: Homeomorph.surjective
code: protected theorem surjective (h : X ≃ₜ Y) : Function.Surjective h 
goal: Function.Surjective ⇑h

full_name: Homeomorph.changeInv
code: /-- Change the homeomorphism `f` to make the inverse function definitionally equal to `g`. -/
def changeInv (f : X ≃ₜ Y) (g : Y → X) (hg : Function.RightInverse g f) : X ≃ₜ Y 
goal: X ≃ₜ Y

full_name: Homeomorph.symm_comp_self
code: @[simp]
theorem symm_comp_self (h : X ≃ₜ Y) : h.symm ∘ h = id 
goal: ⇑h.symm ∘ ⇑h = id

full_name: Homeomorph.self_comp_symm
code: @[simp]
theorem self_comp_symm (h : X ≃ₜ Y) : h ∘ h.symm = id 
goal: ⇑h ∘ ⇑h.symm = id

full_name: Homeomorph.range_coe
code: @[simp]
theorem range_coe (h : X ≃ₜ Y) : range h = univ 
goal: Set.range ⇑h = Set.univ

full_name: Homeomorph.image_symm
code: theorem image_symm (h : X ≃ₜ Y) : image h.symm = preimage h 
goal: Set.image ⇑h.symm = Set.preimage ⇑h

full_name: Homeomorph.preimage_symm
code: theorem preimage_symm (h : X ≃ₜ Y) : preimage h.symm = image h 
goal: Set.preimage ⇑h.symm = Set.image ⇑h

full_name: Homeomorph.image_preimage
code: @[simp]
theorem image_preimage (h : X ≃ₜ Y) (s : Set Y) : h '' (h ⁻¹' s) = s 
goal: ⇑h '' (⇑h ⁻¹' s) = s

full_name: Homeomorph.preimage_image
code: @[simp]
theorem preimage_image (h : X ≃ₜ Y) (s : Set X) : h ⁻¹' (h '' s) = s 
goal: ⇑h ⁻¹' (⇑h '' s) = s

full_name: Homeomorph.image_compl
code: lemma image_compl (h : X ≃ₜ Y) (s : Set X) : h '' (sᶜ) = (h '' s)ᶜ 
goal: ⇑h '' sᶜ = (⇑h '' s)ᶜ

full_name: Homeomorph.inducing
code: protected theorem inducing (h : X ≃ₜ Y) : Inducing h 
goal: Inducing ⇑h

full_name: Homeomorph.induced_eq
code: theorem induced_eq (h : X ≃ₜ Y) : TopologicalSpace.induced h ‹_› = ‹_› 
goal: TopologicalSpace.induced (⇑h) inst✝ = inst✝¹

full_name: Homeomorph.quotientMap
code: protected theorem quotientMap (h : X ≃ₜ Y) : QuotientMap h 
goal: QuotientMap ⇑h

full_name: Homeomorph.coinduced_eq
code: theorem coinduced_eq (h : X ≃ₜ Y) : TopologicalSpace.coinduced h ‹_› = ‹_› 
goal: TopologicalSpace.coinduced (⇑h) inst✝ = inst✝¹

full_name: Homeomorph.embedding
code: protected theorem embedding (h : X ≃ₜ Y) : Embedding h 
goal: Embedding ⇑h

full_name: Homeomorph.ofEmbedding
code: /-- Homeomorphism given an embedding. -/
noncomputable def ofEmbedding (f : X → Y) (hf : Embedding f) : X ≃ₜ Set.range f 
goal: X ≃ₜ ↑(Set.range f)

full_name: Homeomorph.secondCountableTopology
code: protected theorem secondCountableTopology [SecondCountableTopology Y]
    (h : X ≃ₜ Y) : SecondCountableTopology X 
goal: SecondCountableTopology X

full_name: Homeomorph.isCompact_image
code: /-- If `h : X → Y` is a homeomorphism, `h(s)` is compact iff `s` is. -/
@[simp]
theorem isCompact_image {s : Set X} (h : X ≃ₜ Y) : IsCompact (h '' s) ↔ IsCompact s 
goal: IsCompact (⇑h '' s) ↔ IsCompact s

full_name: Homeomorph.isCompact_preimage
code: /-- If `h : X → Y` is a homeomorphism, `h⁻¹(s)` is compact iff `s` is. -/
@[simp]
theorem isCompact_preimage {s : Set Y} (h : X ≃ₜ Y) : IsCompact (h ⁻¹' s) ↔ IsCompact s 
goal: IsCompact (⇑h ⁻¹' s) ↔ IsCompact s

full_name: Homeomorph.isSigmaCompact_image
code: /-- If `h : X → Y` is a homeomorphism, `s` is σ-compact iff `h(s)` is. -/
@[simp]
theorem isSigmaCompact_image {s : Set X} (h : X ≃ₜ Y) :
    IsSigmaCompact (h '' s) ↔ IsSigmaCompact s 
goal: IsSigmaCompact (⇑h '' s) ↔ IsSigmaCompact s

full_name: Homeomorph.isSigmaCompact_preimage
code: /-- If `h : X → Y` is a homeomorphism, `h⁻¹(s)` is σ-compact iff `s` is. -/
@[simp]
theorem isSigmaCompact_preimage {s : Set Y} (h : X ≃ₜ Y) :
    IsSigmaCompact (h ⁻¹' s) ↔ IsSigmaCompact s 
goal: IsSigmaCompact (⇑h ⁻¹' s) ↔ IsSigmaCompact s

full_name: Homeomorph.isPreconnected_image
code: @[simp]
theorem isPreconnected_image {s : Set X} (h : X ≃ₜ Y) :
    IsPreconnected (h '' s) ↔ IsPreconnected s 
goal: IsPreconnected (⇑h '' s) ↔ IsPreconnected s

full_name: Homeomorph.isPreconnected_preimage
code: @[simp]
theorem isPreconnected_preimage {s : Set Y} (h : X ≃ₜ Y) :
    IsPreconnected (h ⁻¹' s) ↔ IsPreconnected s 
goal: IsPreconnected (⇑h ⁻¹' s) ↔ IsPreconnected s

full_name: Homeomorph.isConnected_image
code: @[simp]
theorem isConnected_image {s : Set X} (h : X ≃ₜ Y) :
    IsConnected (h '' s) ↔ IsConnected s 
goal: IsConnected (⇑h '' s) ↔ IsConnected s

full_name: Homeomorph.isConnected_preimage
code: @[simp]
theorem isConnected_preimage {s : Set Y} (h : X ≃ₜ Y) :
    IsConnected (h ⁻¹' s) ↔ IsConnected s 
goal: IsConnected (⇑h ⁻¹' s) ↔ IsConnected s

full_name: Homeomorph.image_connectedComponentIn
code: theorem image_connectedComponentIn {s : Set X} (h : X ≃ₜ Y) {x : X} (hx : x ∈ s) :
    h '' connectedComponentIn s x = connectedComponentIn (h '' s) (h x) 
goal: ⇑h '' connectedComponentIn s x = connectedComponentIn (⇑h '' s) (h x)

full_name: Homeomorph.comap_cocompact
code: @[simp]
theorem comap_cocompact (h : X ≃ₜ Y) : comap h (cocompact Y) = cocompact X 
goal: Filter.comap (⇑h) (Filter.cocompact Y) = Filter.cocompact X

full_name: Homeomorph.map_cocompact
code: @[simp]
theorem map_cocompact (h : X ≃ₜ Y) : map h (cocompact X) = cocompact Y 
goal: Filter.map (⇑h) (Filter.cocompact X) = Filter.cocompact Y

full_name: Homeomorph.compactSpace
code: protected theorem compactSpace [CompactSpace X] (h : X ≃ₜ Y) : CompactSpace Y 
goal: CompactSpace Y

full_name: Homeomorph.t0Space
code: protected theorem t0Space [T0Space X] (h : X ≃ₜ Y) : T0Space Y 
goal: T0Space Y

full_name: Homeomorph.t1Space
code: protected theorem t1Space [T1Space X] (h : X ≃ₜ Y) : T1Space Y 
goal: T1Space Y

full_name: Homeomorph.t2Space
code: protected theorem t2Space [T2Space X] (h : X ≃ₜ Y) : T2Space Y 
goal: T2Space Y

full_name: Homeomorph.t3Space
code: protected theorem t3Space [T3Space X] (h : X ≃ₜ Y) : T3Space Y 
goal: T3Space Y

full_name: Homeomorph.denseEmbedding
code: protected theorem denseEmbedding (h : X ≃ₜ Y) : DenseEmbedding h 
goal: DenseEmbedding ⇑h

full_name: Homeomorph.isOpen_preimage
code: @[simp]
theorem isOpen_preimage (h : X ≃ₜ Y) {s : Set Y} : IsOpen (h ⁻¹' s) ↔ IsOpen s 
goal: IsOpen (⇑h ⁻¹' s) ↔ IsOpen s

full_name: Homeomorph.isOpen_image
code: @[simp]
theorem isOpen_image (h : X ≃ₜ Y) {s : Set X} : IsOpen (h '' s) ↔ IsOpen s 
goal: IsOpen (⇑h '' s) ↔ IsOpen s

full_name: Homeomorph.isOpenMap
code: protected theorem isOpenMap (h : X ≃ₜ Y) : IsOpenMap h 
goal: IsOpenMap ⇑h

full_name: Homeomorph.isClosed_preimage
code: @[simp]
theorem isClosed_preimage (h : X ≃ₜ Y) {s : Set Y} : IsClosed (h ⁻¹' s) ↔ IsClosed s 
goal: IsClosed (⇑h ⁻¹' s) ↔ IsClosed s

full_name: Homeomorph.isClosed_image
code: @[simp]
theorem isClosed_image (h : X ≃ₜ Y) {s : Set X} : IsClosed (h '' s) ↔ IsClosed s 
goal: IsClosed (⇑h '' s) ↔ IsClosed s

full_name: Homeomorph.isClosedMap
code: protected theorem isClosedMap (h : X ≃ₜ Y) : IsClosedMap h 
goal: IsClosedMap ⇑h

full_name: Homeomorph.openEmbedding
code: protected theorem openEmbedding (h : X ≃ₜ Y) : OpenEmbedding h 
goal: OpenEmbedding ⇑h

full_name: Homeomorph.closedEmbedding
code: protected theorem closedEmbedding (h : X ≃ₜ Y) : ClosedEmbedding h 
goal: ClosedEmbedding ⇑h

full_name: Homeomorph.normalSpace
code: protected theorem normalSpace [NormalSpace X] (h : X ≃ₜ Y) : NormalSpace Y 
goal: NormalSpace Y

full_name: Homeomorph.t4Space
code: protected theorem t4Space [T4Space X] (h : X ≃ₜ Y) : T4Space Y 
goal: T4Space Y

full_name: Homeomorph.preimage_closure
code: theorem preimage_closure (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' closure s = closure (h ⁻¹' s) 
goal: ⇑h ⁻¹' closure s = closure (⇑h ⁻¹' s)

full_name: Homeomorph.image_closure
code: theorem image_closure (h : X ≃ₜ Y) (s : Set X) : h '' closure s = closure (h '' s) 
goal: ⇑h '' closure s = closure (⇑h '' s)

full_name: Homeomorph.preimage_interior
code: theorem preimage_interior (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' interior s = interior (h ⁻¹' s) 
goal: ⇑h ⁻¹' interior s = interior (⇑h ⁻¹' s)

full_name: Homeomorph.image_interior
code: theorem image_interior (h : X ≃ₜ Y) (s : Set X) : h '' interior s = interior (h '' s) 
goal: ⇑h '' interior s = interior (⇑h '' s)

full_name: Homeomorph.preimage_frontier
code: theorem preimage_frontier (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' frontier s = frontier (h ⁻¹' s) 
goal: ⇑h ⁻¹' frontier s = frontier (⇑h ⁻¹' s)

full_name: Homeomorph.image_frontier
code: theorem image_frontier (h : X ≃ₜ Y) (s : Set X) : h '' frontier s = frontier (h '' s) 
goal: ⇑h '' frontier s = frontier (⇑h '' s)

full_name: HasCompactSupport.comp_homeomorph
code: @[to_additive]
theorem _root_.HasCompactMulSupport.comp_homeomorph {M} [One M] {f : Y → M}
    (hf : HasCompactMulSupport f) (φ : X ≃ₜ Y) : HasCompactMulSupport (f ∘ φ) 
goal: HasCompactSupport (f ∘ ⇑φ)

full_name: HasCompactMulSupport.comp_homeomorph
code: @[to_additive]
theorem _root_.HasCompactMulSupport.comp_homeomorph {M} [One M] {f : Y → M}
    (hf : HasCompactMulSupport f) (φ : X ≃ₜ Y) : HasCompactMulSupport (f ∘ φ) 
goal: HasCompactMulSupport (f ∘ ⇑φ)

full_name: Homeomorph.map_nhds_eq
code: @[simp]
theorem map_nhds_eq (h : X ≃ₜ Y) (x : X) : map h (𝓝 x) = 𝓝 (h x) 
goal: Filter.map (⇑h) (𝓝 x) = 𝓝 (h x)

full_name: Homeomorph.map_punctured_nhds_eq
code: @[simp]
theorem map_punctured_nhds_eq (h : X ≃ₜ Y) (x : X) : map h (𝓝[≠] x) = 𝓝[≠] (h x) 
goal: Filter.map (⇑h) (𝓝[≠] x) = 𝓝[≠] h x

full_name: Homeomorph.symm_map_nhds_eq
code: theorem symm_map_nhds_eq (h : X ≃ₜ Y) (x : X) : map h.symm (𝓝 (h x)) = 𝓝 x 
goal: Filter.map (⇑h.symm) (𝓝 (h x)) = 𝓝 x

full_name: Homeomorph.nhds_eq_comap
code: theorem nhds_eq_comap (h : X ≃ₜ Y) (x : X) : 𝓝 x = comap h (𝓝 (h x)) 
goal: 𝓝 x = Filter.comap (⇑h) (𝓝 (h x))

full_name: Homeomorph.comap_nhds_eq
code: @[simp]
theorem comap_nhds_eq (h : X ≃ₜ Y) (y : Y) : comap h (𝓝 y) = 𝓝 (h.symm y) 
goal: Filter.comap (⇑h) (𝓝 y) = 𝓝 (h.symm y)

full_name: Homeomorph.locallyConnectedSpace
code: /-- If the codomain of a homeomorphism is a locally connected space, then the domain is also
a locally connected space. -/
theorem locallyConnectedSpace [i : LocallyConnectedSpace Y] (h : X ≃ₜ Y) :
    LocallyConnectedSpace X 
goal: LocallyConnectedSpace X

full_name: Homeomorph.locallyCompactSpace_iff
code: /-- The codomain of a homeomorphism is a locally compact space if and only if
the domain is a locally compact space. -/
theorem locallyCompactSpace_iff (h : X ≃ₜ Y) :
    LocallyCompactSpace X ↔ LocallyCompactSpace Y 
goal: LocallyCompactSpace X ↔ LocallyCompactSpace Y

full_name: Homeomorph.homeomorphOfContinuousOpen
code: /-- If a bijective map `e : X ≃ Y` is continuous and open, then it is a homeomorphism. -/
def homeomorphOfContinuousOpen (e : X ≃ Y) (h₁ : Continuous e) (h₂ : IsOpenMap e) : X ≃ₜ Y 
goal: X ≃ₜ Y

full_name: Homeomorph.comp_continuousOn_iff
code: @[simp]
theorem comp_continuousOn_iff (h : X ≃ₜ Y) (f : Z → X) (s : Set Z) :
    ContinuousOn (h ∘ f) s ↔ ContinuousOn f s 
goal: ContinuousOn (⇑h ∘ f) s ↔ ContinuousOn f s

full_name: Homeomorph.comp_continuous_iff
code: @[simp]
theorem comp_continuous_iff (h : X ≃ₜ Y) {f : Z → X} : Continuous (h ∘ f) ↔ Continuous f 
goal: Continuous (⇑h ∘ f) ↔ Continuous f

full_name: Homeomorph.comp_continuous_iff'
code: @[simp]
theorem comp_continuous_iff' (h : X ≃ₜ Y) {f : Y → Z} : Continuous (f ∘ h) ↔ Continuous f 
goal: Continuous (f ∘ ⇑h) ↔ Continuous f

full_name: Homeomorph.comp_continuousAt_iff
code: theorem comp_continuousAt_iff (h : X ≃ₜ Y) (f : Z → X) (z : Z) :
    ContinuousAt (h ∘ f) z ↔ ContinuousAt f z 
goal: ContinuousAt (⇑h ∘ f) z ↔ ContinuousAt f z

full_name: Homeomorph.comp_continuousAt_iff'
code: theorem comp_continuousAt_iff' (h : X ≃ₜ Y) (f : Y → Z) (x : X) :
    ContinuousAt (f ∘ h) x ↔ ContinuousAt f (h x) 
goal: ContinuousAt (f ∘ ⇑h) x ↔ ContinuousAt f (h x)

full_name: Homeomorph.comp_continuousWithinAt_iff
code: theorem comp_continuousWithinAt_iff (h : X ≃ₜ Y) (f : Z → X) (s : Set Z) (z : Z) :
    ContinuousWithinAt f s z ↔ ContinuousWithinAt (h ∘ f) s z 
goal: ContinuousWithinAt f s z ↔ ContinuousWithinAt (⇑h ∘ f) s z

full_name: Homeomorph.comp_isOpenMap_iff
code: @[simp]
theorem comp_isOpenMap_iff (h : X ≃ₜ Y) {f : Z → X} : IsOpenMap (h ∘ f) ↔ IsOpenMap f 
goal: IsOpenMap (⇑h ∘ f) ↔ IsOpenMap f

full_name: Homeomorph.comp_isOpenMap_iff'
code: @[simp]
theorem comp_isOpenMap_iff' (h : X ≃ₜ Y) {f : Y → Z} : IsOpenMap (f ∘ h) ↔ IsOpenMap f 
goal: IsOpenMap (f ∘ ⇑h) ↔ IsOpenMap f

full_name: Homeomorph.subtype_symm_apply_coe
code: /-- A homeomorphism `h : X ≃ₜ Y` lifts to a homeomorphism between subtypes corresponding to
predicates `p : X → Prop` and `q : Y → Prop` so long as `p = q ∘ h`. -/
@[simps!]
def subtype {p : X → Prop} {q : Y → Prop} (h : X ≃ₜ Y) (h_iff : ∀ x, p x ↔ q (h x)) :
    {x // p x} ≃ₜ {y // q y} 
goal: ↑((h.subtype h_iff).symm b) = h.symm ↑b

full_name: Homeomorph.subtype_apply_coe
code: /-- A homeomorphism `h : X ≃ₜ Y` lifts to a homeomorphism between subtypes corresponding to
predicates `p : X → Prop` and `q : Y → Prop` so long as `p = q ∘ h`. -/
@[simps!]
def subtype {p : X → Prop} {q : Y → Prop} (h : X ≃ₜ Y) (h_iff : ∀ x, p x ↔ q (h x)) :
    {x // p x} ≃ₜ {y // q y} 
goal: ↑((h.subtype h_iff) a) = h ↑a

full_name: Homeomorph.subtype
code: /-- A homeomorphism `h : X ≃ₜ Y` lifts to a homeomorphism between subtypes corresponding to
predicates `p : X → Prop` and `q : Y → Prop` so long as `p = q ∘ h`. -/
@[simps!]
def subtype {p : X → Prop} {q : Y → Prop} (h : X ≃ₜ Y) (h_iff : ∀ x, p x ↔ q (h x)) :
    {x // p x} ≃ₜ {y // q y} 
goal: { x // p x } ≃ₜ { y // q y }

full_name: Homeomorph.subtype_toEquiv
code: @[simp]
lemma subtype_toEquiv {p : X → Prop} {q : Y → Prop} (h : X ≃ₜ Y) (h_iff : ∀ x, p x ↔ q (h x)) :
    (h.subtype h_iff).toEquiv = h.toEquiv.subtypeEquiv h_iff 
goal: (h.subtype h_iff).toEquiv = h.subtypeEquiv h_iff

full_name: Homeomorph.sets
code: /-- A homeomorphism `h : X ≃ₜ Y` lifts to a homeomorphism between sets `s : Set X` and `t : Set Y`
whenever `h` maps `s` onto `t`. -/
abbrev sets {s : Set X} {t : Set Y} (h : X ≃ₜ Y) (h_eq : s = h ⁻¹' t) : s ≃ₜ t 
goal: ↑s ≃ₜ ↑t

full_name: Homeomorph.setCongr
code: /-- If two sets are equal, then they are homeomorphic. -/
def setCongr {s t : Set X} (h : s = t) : s ≃ₜ t 
goal: ↑s ≃ₜ ↑t

full_name: Homeomorph.sumCongr
code: /-- Sum of two homeomorphisms. -/
def sumCongr (h₁ : X ≃ₜ X') (h₂ : Y ≃ₜ Y') : X ⊕ Y ≃ₜ X' ⊕ Y' 
goal: X ⊕ Y ≃ₜ X' ⊕ Y'

full_name: Homeomorph.prodCongr
code: /-- Product of two homeomorphisms. -/
def prodCongr (h₁ : X ≃ₜ X') (h₂ : Y ≃ₜ Y') : X × Y ≃ₜ X' × Y' 
goal: X × Y ≃ₜ X' × Y'

full_name: Homeomorph.prodCongr_symm
code: @[simp]
theorem prodCongr_symm (h₁ : X ≃ₜ X') (h₂ : Y ≃ₜ Y') :
    (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm 
goal: (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm

full_name: Homeomorph.coe_prodCongr
code: @[simp]
theorem coe_prodCongr (h₁ : X ≃ₜ X') (h₂ : Y ≃ₜ Y') : ⇑(h₁.prodCongr h₂) = Prod.map h₁ h₂ 
goal: ⇑(h₁.prodCongr h₂) = Prod.map ⇑h₁ ⇑h₂

full_name: Homeomorph.prodComm
code: /-- `X × Y` is homeomorphic to `Y × X`. -/
def prodComm : X × Y ≃ₜ Y × X 
goal: X × Y ≃ₜ Y × X

full_name: Homeomorph.prodComm_symm
code: @[simp]
theorem prodComm_symm : (prodComm X Y).symm = prodComm Y X 
goal: (Homeomorph.prodComm X Y).symm = Homeomorph.prodComm Y X

full_name: Homeomorph.coe_prodComm
code: @[simp]
theorem coe_prodComm : ⇑(prodComm X Y) = Prod.swap 
goal: ⇑(Homeomorph.prodComm X Y) = Prod.swap

full_name: Homeomorph.prodAssoc
code: /-- `(X × Y) × Z` is homeomorphic to `X × (Y × Z)`. -/
def prodAssoc : (X × Y) × Z ≃ₜ X × Y × Z 
goal: (X × Y) × Z ≃ₜ X × Y × Z

full_name: Homeomorph.prodPUnit_apply
code: /-- `X × {*}` is homeomorphic to `X`. -/
@[simps! (config := .asFn) apply]
def prodPUnit : X × PUnit ≃ₜ X 
goal: ⇑(Homeomorph.prodPUnit X) = fun p => p.1

full_name: Homeomorph.prodPUnit
code: /-- `X × {*}` is homeomorphic to `X`. -/
@[simps! (config := .asFn) apply]
def prodPUnit : X × PUnit ≃ₜ X 
goal: X × PUnit.{u_6 + 1} ≃ₜ X

full_name: Homeomorph.punitProd
code: /-- `{*} × X` is homeomorphic to `X`. -/
def punitProd : PUnit × X ≃ₜ X 
goal: PUnit.{u_6 + 1} × X ≃ₜ X

full_name: Homeomorph.coe_punitProd
code: @[simp] theorem coe_punitProd : ⇑(punitProd X) = Prod.snd 
goal: ⇑(Homeomorph.punitProd X) = Prod.snd

full_name: Homeomorph.homeomorphOfUnique_apply
code: /-- If both `X` and `Y` have a unique element, then `X ≃ₜ Y`. -/
@[simps!]
def homeomorphOfUnique [Unique X] [Unique Y] : X ≃ₜ Y 
goal: ∀ (a : X), (Homeomorph.homeomorphOfUnique X Y) a = default

full_name: Homeomorph.homeomorphOfUnique
code: /-- If both `X` and `Y` have a unique element, then `X ≃ₜ Y`. -/
@[simps!]
def homeomorphOfUnique [Unique X] [Unique Y] : X ≃ₜ Y 
goal: X ≃ₜ Y

full_name: Homeomorph.homeomorphOfUnique_symm_apply
code: /-- If both `X` and `Y` have a unique element, then `X ≃ₜ Y`. -/
@[simps!]
def homeomorphOfUnique [Unique X] [Unique Y] : X ≃ₜ Y 
goal: ∀ (a : Y), (Homeomorph.homeomorphOfUnique X Y).symm a = default

full_name: Homeomorph.piCongrLeft_toEquiv
code: /-- `Equiv.piCongrLeft` as a homeomorphism: this is the natural homeomorphism
`Π i, Y (e i) ≃ₜ Π j, Y j` obtained from a bijection `ι ≃ ι'`. -/
@[simps! apply toEquiv]
def piCongrLeft {ι ι' : Type*} {Y : ι' → Type*} [∀ j, TopologicalSpace (Y j)]
    (e : ι ≃ ι') : (∀ i, Y (e i)) ≃ₜ ∀ j, Y j 
goal: (Homeomorph.piCongrLeft e).toEquiv = Equiv.piCongrLeft Y e

full_name: Homeomorph.piCongrLeft
code: /-- `Equiv.piCongrLeft` as a homeomorphism: this is the natural homeomorphism
`Π i, Y (e i) ≃ₜ Π j, Y j` obtained from a bijection `ι ≃ ι'`. -/
@[simps! apply toEquiv]
def piCongrLeft {ι ι' : Type*} {Y : ι' → Type*} [∀ j, TopologicalSpace (Y j)]
    (e : ι ≃ ι') : (∀ i, Y (e i)) ≃ₜ ∀ j, Y j 
goal: ((i : ι) → Y (e i)) ≃ₜ ((j : ι') → Y j)

full_name: Homeomorph.piCongrLeft_apply
code: /-- `Equiv.piCongrLeft` as a homeomorphism: this is the natural homeomorphism
`Π i, Y (e i) ≃ₜ Π j, Y j` obtained from a bijection `ι ≃ ι'`. -/
@[simps! apply toEquiv]
def piCongrLeft {ι ι' : Type*} {Y : ι' → Type*} [∀ j, TopologicalSpace (Y j)]
    (e : ι ≃ ι') : (∀ i, Y (e i)) ≃ₜ ∀ j, Y j 
goal: ∀ (a : (b : ι) → Y (e.symm.symm b)) (a_1 : ι'),
  (Homeomorph.piCongrLeft e) a a_1 = (Equiv.piCongrLeft' Y e.symm).symm a a_1

full_name: Homeomorph.piCongrRight_apply
code: /-- `Equiv.piCongrRight` as a homeomorphism: this is the natural homeomorphism
`Π i, Y₁ i ≃ₜ Π j, Y₂ i` obtained from homeomorphisms `Y₁ i ≃ₜ Y₂ i` for each `i`. -/
@[simps! apply toEquiv]
def piCongrRight {ι : Type*} {Y₁ Y₂ : ι → Type*} [∀ i, TopologicalSpace (Y₁ i)]
    [∀ i, TopologicalSpace (Y₂ i)] (F : ∀ i, Y₁ i ≃ₜ Y₂ i) : (∀ i, Y₁ i) ≃ₜ ∀ i, Y₂ i 
goal: (Homeomorph.piCongrRight F) H a = (F a) (H a)

full_name: Homeomorph.piCongrRight
code: /-- `Equiv.piCongrRight` as a homeomorphism: this is the natural homeomorphism
`Π i, Y₁ i ≃ₜ Π j, Y₂ i` obtained from homeomorphisms `Y₁ i ≃ₜ Y₂ i` for each `i`. -/
@[simps! apply toEquiv]
def piCongrRight {ι : Type*} {Y₁ Y₂ : ι → Type*} [∀ i, TopologicalSpace (Y₁ i)]
    [∀ i, TopologicalSpace (Y₂ i)] (F : ∀ i, Y₁ i ≃ₜ Y₂ i) : (∀ i, Y₁ i) ≃ₜ ∀ i, Y₂ i 
goal: ((i : ι) → Y₁ i) ≃ₜ ((i : ι) → Y₂ i)

full_name: Homeomorph.piCongrRight_toEquiv
code: /-- `Equiv.piCongrRight` as a homeomorphism: this is the natural homeomorphism
`Π i, Y₁ i ≃ₜ Π j, Y₂ i` obtained from homeomorphisms `Y₁ i ≃ₜ Y₂ i` for each `i`. -/
@[simps! apply toEquiv]
def piCongrRight {ι : Type*} {Y₁ Y₂ : ι → Type*} [∀ i, TopologicalSpace (Y₁ i)]
    [∀ i, TopologicalSpace (Y₂ i)] (F : ∀ i, Y₁ i ≃ₜ Y₂ i) : (∀ i, Y₁ i) ≃ₜ ∀ i, Y₂ i 
goal: (Homeomorph.piCongrRight F).toEquiv = Equiv.piCongrRight fun i => (F i).toEquiv

full_name: Homeomorph.piCongrRight_symm
code: @[simp]
theorem piCongrRight_symm {ι : Type*} {Y₁ Y₂ : ι → Type*} [∀ i, TopologicalSpace (Y₁ i)]
    [∀ i, TopologicalSpace (Y₂ i)] (F : ∀ i, Y₁ i ≃ₜ Y₂ i) :
    (piCongrRight F).symm = piCongrRight fun i => (F i).symm 
goal: (Homeomorph.piCongrRight F).symm = Homeomorph.piCongrRight fun i => (F i).symm

full_name: Homeomorph.piCongr_apply
code: /-- `Equiv.piCongr` as a homeomorphism: this is the natural homeomorphism
`Π i₁, Y₁ i ≃ₜ Π i₂, Y₂ i₂` obtained from a bijection `ι₁ ≃ ι₂` and homeomorphisms
`Y₁ i₁ ≃ₜ Y₂ (e i₁)` for each `i₁ : ι₁`. -/
@[simps! apply toEquiv]
def piCongr {ι₁ ι₂ : Type*} {Y₁ : ι₁ → Type*} {Y₂ : ι₂ → Type*}
    [∀ i₁, TopologicalSpace (Y₁ i₁)] [∀ i₂, TopologicalSpace (Y₂ i₂)]
    (e : ι₁ ≃ ι₂) (F : ∀ i₁, Y₁ i₁ ≃ₜ Y₂ (e i₁)) : (∀ i₁, Y₁ i₁) ≃ₜ ∀ i₂, Y₂ i₂ 
goal: ∀ (a : (i : ι₁) → Y₁ i) (i₂ : ι₂),
  (Homeomorph.piCongr e F) a i₂ = ⋯ ▸ (Equiv.piCongrRight fun i => (F i).toEquiv) a (e.symm i₂)

full_name: Homeomorph.piCongr
code: /-- `Equiv.piCongr` as a homeomorphism: this is the natural homeomorphism
`Π i₁, Y₁ i ≃ₜ Π i₂, Y₂ i₂` obtained from a bijection `ι₁ ≃ ι₂` and homeomorphisms
`Y₁ i₁ ≃ₜ Y₂ (e i₁)` for each `i₁ : ι₁`. -/
@[simps! apply toEquiv]
def piCongr {ι₁ ι₂ : Type*} {Y₁ : ι₁ → Type*} {Y₂ : ι₂ → Type*}
    [∀ i₁, TopologicalSpace (Y₁ i₁)] [∀ i₂, TopologicalSpace (Y₂ i₂)]
    (e : ι₁ ≃ ι₂) (F : ∀ i₁, Y₁ i₁ ≃ₜ Y₂ (e i₁)) : (∀ i₁, Y₁ i₁) ≃ₜ ∀ i₂, Y₂ i₂ 
goal: ((i₁ : ι₁) → Y₁ i₁) ≃ₜ ((i₂ : ι₂) → Y₂ i₂)

full_name: Homeomorph.piCongr_toEquiv
code: /-- `Equiv.piCongr` as a homeomorphism: this is the natural homeomorphism
`Π i₁, Y₁ i ≃ₜ Π i₂, Y₂ i₂` obtained from a bijection `ι₁ ≃ ι₂` and homeomorphisms
`Y₁ i₁ ≃ₜ Y₂ (e i₁)` for each `i₁ : ι₁`. -/
@[simps! apply toEquiv]
def piCongr {ι₁ ι₂ : Type*} {Y₁ : ι₁ → Type*} {Y₂ : ι₂ → Type*}
    [∀ i₁, TopologicalSpace (Y₁ i₁)] [∀ i₂, TopologicalSpace (Y₂ i₂)]
    (e : ι₁ ≃ ι₂) (F : ∀ i₁, Y₁ i₁ ≃ₜ Y₂ (e i₁)) : (∀ i₁, Y₁ i₁) ≃ₜ ∀ i₂, Y₂ i₂ 
goal: (Homeomorph.piCongr e F).toEquiv = (Equiv.piCongrRight fun i => (F i).toEquiv).trans (Equiv.piCongrLeft Y₂ e)

full_name: Homeomorph.ulift
code: /-- `ULift X` is homeomorphic to `X`. -/
def ulift.{u, v} {X : Type u} [TopologicalSpace X] : ULift.{v, u} X ≃ₜ X 
goal: ULift.{v, u} X ≃ₜ X

full_name: Homeomorph.sumProdDistrib
code: /-- `(X ⊕ Y) × Z` is homeomorphic to `X × Z ⊕ Y × Z`. -/
def sumProdDistrib : (X ⊕ Y) × Z ≃ₜ (X × Z) ⊕ (Y × Z) 
goal: (X ⊕ Y) × Z ≃ₜ X × Z ⊕ Y × Z

full_name: Homeomorph.prodSumDistrib
code: /-- `X × (Y ⊕ Z)` is homeomorphic to `X × Y ⊕ X × Z`. -/
def prodSumDistrib : X × (Y ⊕ Z) ≃ₜ (X × Y) ⊕ (X × Z) 
goal: X × (Y ⊕ Z) ≃ₜ X × Y ⊕ X × Z

full_name: Homeomorph.sigmaProdDistrib
code: /-- `(Σ i, X i) × Y` is homeomorphic to `Σ i, (X i × Y)`. -/
def sigmaProdDistrib : (Σ i, X i) × Y ≃ₜ Σ i, X i × Y 
goal: ((i : ι) × X i) × Y ≃ₜ (i : ι) × X i × Y

full_name: Homeomorph.funUnique
code: /-- If `ι` has a unique element, then `ι → X` is homeomorphic to `X`. -/
@[simps! (config := .asFn)]
def funUnique (ι X : Type*) [Unique ι] [TopologicalSpace X] : (ι → X) ≃ₜ X 
goal: (ι → X) ≃ₜ X

full_name: Homeomorph.funUnique_symm_apply
code: /-- If `ι` has a unique element, then `ι → X` is homeomorphic to `X`. -/
@[simps! (config := .asFn)]
def funUnique (ι X : Type*) [Unique ι] [TopologicalSpace X] : (ι → X) ≃ₜ X 
goal: ⇑(Homeomorph.funUnique ι X).symm = uniqueElim

full_name: Homeomorph.funUnique_apply
code: /-- If `ι` has a unique element, then `ι → X` is homeomorphic to `X`. -/
@[simps! (config := .asFn)]
def funUnique (ι X : Type*) [Unique ι] [TopologicalSpace X] : (ι → X) ≃ₜ X 
goal: ⇑(Homeomorph.funUnique ι X) = fun f => f default

full_name: Homeomorph.piFinTwo_apply
code: /-- Homeomorphism between dependent functions `Π i : Fin 2, X i` and `X 0 × X 1`. -/
@[simps! (config := .asFn)]
def piFinTwo.{u} (X : Fin 2 → Type u) [∀ i, TopologicalSpace (X i)] : (∀ i, X i) ≃ₜ X 0 × X 1 
goal: ⇑(Homeomorph.piFinTwo X) = fun f => (f 0, f 1)

full_name: Homeomorph.piFinTwo
code: /-- Homeomorphism between dependent functions `Π i : Fin 2, X i` and `X 0 × X 1`. -/
@[simps! (config := .asFn)]
def piFinTwo.{u} (X : Fin 2 → Type u) [∀ i, TopologicalSpace (X i)] : (∀ i, X i) ≃ₜ X 0 × X 1 
goal: ((i : Fin 2) → X i) ≃ₜ X 0 × X 1

full_name: Homeomorph.piFinTwo_symm_apply
code: /-- Homeomorphism between dependent functions `Π i : Fin 2, X i` and `X 0 × X 1`. -/
@[simps! (config := .asFn)]
def piFinTwo.{u} (X : Fin 2 → Type u) [∀ i, TopologicalSpace (X i)] : (∀ i, X i) ≃ₜ X 0 × X 1 
goal: ⇑(Homeomorph.piFinTwo X).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)

full_name: Homeomorph.finTwoArrow_apply
code: /-- Homeomorphism between `X² = Fin 2 → X` and `X × X`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → X) ≃ₜ X × X 
goal: ⇑Homeomorph.finTwoArrow = fun f => (f 0, f 1)

full_name: Homeomorph.finTwoArrow_symm_apply
code: /-- Homeomorphism between `X² = Fin 2 → X` and `X × X`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → X) ≃ₜ X × X 
goal: ⇑Homeomorph.finTwoArrow.symm = fun x => ![x.1, x.2]

full_name: Homeomorph.finTwoArrow
code: /-- Homeomorphism between `X² = Fin 2 → X` and `X × X`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → X) ≃ₜ X × X 
goal: (Fin 2 → X) ≃ₜ X × X

full_name: Homeomorph.image_apply_coe
code: /-- A subset of a topological space is homeomorphic to its image under a homeomorphism.
-/
@[simps!]
def image (e : X ≃ₜ Y) (s : Set X) : s ≃ₜ e '' s 
goal: ↑((e.image s) x) = e ↑x

full_name: Homeomorph.image
code: /-- A subset of a topological space is homeomorphic to its image under a homeomorphism.
-/
@[simps!]
def image (e : X ≃ₜ Y) (s : Set X) : s ≃ₜ e '' s 
goal: ↑s ≃ₜ ↑(⇑e '' s)

full_name: Homeomorph.image_symm_apply_coe
code: /-- A subset of a topological space is homeomorphic to its image under a homeomorphism.
-/
@[simps!]
def image (e : X ≃ₜ Y) (s : Set X) : s ≃ₜ e '' s 
goal: ↑((e.image s).symm y) = e.symm ↑y

full_name: Homeomorph.Set.univ_symm_apply_coe
code: /-- `Set.univ X` is homeomorphic to `X`. -/
@[simps! (config := .asFn)]
def Set.univ (X : Type*) [TopologicalSpace X] : (univ : Set X) ≃ₜ X 
goal: ↑((Homeomorph.Set.univ X).symm a) = a

full_name: Homeomorph.Set.univ_apply
code: /-- `Set.univ X` is homeomorphic to `X`. -/
@[simps! (config := .asFn)]
def Set.univ (X : Type*) [TopologicalSpace X] : (univ : Set X) ≃ₜ X 
goal: ⇑(Homeomorph.Set.univ X) = Subtype.val

full_name: Homeomorph.Set.univ
code: /-- `Set.univ X` is homeomorphic to `X`. -/
@[simps! (config := .asFn)]
def Set.univ (X : Type*) [TopologicalSpace X] : (univ : Set X) ≃ₜ X 
goal: ↑Set.univ ≃ₜ X

full_name: Homeomorph.Set.prod
code: /-- `s ×ˢ t` is homeomorphic to `s × t`. -/
@[simps!]
def Set.prod (s : Set X) (t : Set Y) : ↥(s ×ˢ t) ≃ₜ s × t 
goal: ↑(s ×ˢ t) ≃ₜ ↑s × ↑t

full_name: Homeomorph.Set.prod_symm_apply_coe
code: /-- `s ×ˢ t` is homeomorphic to `s × t`. -/
@[simps!]
def Set.prod (s : Set X) (t : Set Y) : ↥(s ×ˢ t) ≃ₜ s × t 
goal: ↑((Homeomorph.Set.prod s t).symm x) = (↑x.1, ↑x.2)

full_name: Homeomorph.Set.prod_apply
code: /-- `s ×ˢ t` is homeomorphic to `s × t`. -/
@[simps!]
def Set.prod (s : Set X) (t : Set Y) : ↥(s ×ˢ t) ≃ₜ s × t 
goal: (Homeomorph.Set.prod s t) x = (⟨(↑x).1, ⋯⟩, ⟨(↑x).2, ⋯⟩)

full_name: Homeomorph.piEquivPiSubtypeProd_apply
code: /-- The topological space `Π i, Y i` can be split as a product by separating the indices in ι
  depending on whether they satisfy a predicate p or not. -/
@[simps!]
def piEquivPiSubtypeProd (p : ι → Prop) (Y : ι → Type*) [∀ i, TopologicalSpace (Y i)]
    [DecidablePred p] : (∀ i, Y i) ≃ₜ (∀ i : { x // p x }, Y i) × ∀ i : { x // ¬p x }, Y i 
goal: (Homeomorph.piEquivPiSubtypeProd p Y) f = (fun x => f ↑x, fun x => f ↑x)

full_name: Homeomorph.piEquivPiSubtypeProd_symm_apply
code: /-- The topological space `Π i, Y i` can be split as a product by separating the indices in ι
  depending on whether they satisfy a predicate p or not. -/
@[simps!]
def piEquivPiSubtypeProd (p : ι → Prop) (Y : ι → Type*) [∀ i, TopologicalSpace (Y i)]
    [DecidablePred p] : (∀ i, Y i) ≃ₜ (∀ i : { x // p x }, Y i) × ∀ i : { x // ¬p x }, Y i 
goal: (Homeomorph.piEquivPiSubtypeProd p Y).symm f x = if h : p x then f.1 ⟨x, h⟩ else f.2 ⟨x, h⟩

full_name: Homeomorph.piEquivPiSubtypeProd
code: /-- The topological space `Π i, Y i` can be split as a product by separating the indices in ι
  depending on whether they satisfy a predicate p or not. -/
@[simps!]
def piEquivPiSubtypeProd (p : ι → Prop) (Y : ι → Type*) [∀ i, TopologicalSpace (Y i)]
    [DecidablePred p] : (∀ i, Y i) ≃ₜ (∀ i : { x // p x }, Y i) × ∀ i : { x // ¬p x }, Y i 
goal: ((i : ι) → Y i) ≃ₜ ((i : { x // p x }) → Y ↑i) × ((i : { x // ¬p x }) → Y ↑i)

full_name: Homeomorph.piSplitAt_symm_apply
code: /-- A product of topological spaces can be split as the binary product of one of the spaces and
  the product of all the remaining spaces. -/
@[simps!]
def piSplitAt (Y : ι → Type*) [∀ j, TopologicalSpace (Y j)] :
    (∀ j, Y j) ≃ₜ Y i × ∀ j : { j // j ≠ i }, Y j 
goal: (Homeomorph.piSplitAt i Y).symm f j = if h : j = i then ⋯ ▸ f.1 else f.2 ⟨j, h⟩

full_name: Homeomorph.piSplitAt_apply
code: /-- A product of topological spaces can be split as the binary product of one of the spaces and
  the product of all the remaining spaces. -/
@[simps!]
def piSplitAt (Y : ι → Type*) [∀ j, TopologicalSpace (Y j)] :
    (∀ j, Y j) ≃ₜ Y i × ∀ j : { j // j ≠ i }, Y j 
goal: (Homeomorph.piSplitAt i Y) f = (f i, fun j => f ↑j)

full_name: Homeomorph.piSplitAt
code: /-- A product of topological spaces can be split as the binary product of one of the spaces and
  the product of all the remaining spaces. -/
@[simps!]
def piSplitAt (Y : ι → Type*) [∀ j, TopologicalSpace (Y j)] :
    (∀ j, Y j) ≃ₜ Y i × ∀ j : { j // j ≠ i }, Y j 
goal: ((j : ι) → Y j) ≃ₜ Y i × ((j : { j // j ≠ i }) → Y ↑j)

full_name: Homeomorph.funSplitAt_apply
code: /-- A product of copies of a topological space can be split as the binary product of one copy and
  the product of all the remaining copies. -/
@[simps!]
def funSplitAt : (ι → Y) ≃ₜ Y × ({ j // j ≠ i } → Y) 
goal: (Homeomorph.funSplitAt Y i) f = (f i, fun j => f ↑j)

full_name: Homeomorph.funSplitAt_symm_apply
code: /-- A product of copies of a topological space can be split as the binary product of one copy and
  the product of all the remaining copies. -/
@[simps!]
def funSplitAt : (ι → Y) ≃ₜ Y × ({ j // j ≠ i } → Y) 
goal: (Homeomorph.funSplitAt Y i).symm f j = if h : j = i then f.1 else f.2 ⟨j, ⋯⟩

full_name: Homeomorph.funSplitAt
code: /-- A product of copies of a topological space can be split as the binary product of one copy and
  the product of all the remaining copies. -/
@[simps!]
def funSplitAt : (ι → Y) ≃ₜ Y × ({ j // j ≠ i } → Y) 
goal: (ι → Y) ≃ₜ Y × ({ j // j ≠ i } → Y)

full_name: Equiv.toHomeomorph_toEquiv
code: /-- An equiv between topological spaces respecting openness is a homeomorphism. -/
@[simps toEquiv]
def toHomeomorph (e : X ≃ Y) (he : ∀ s, IsOpen (e ⁻¹' s) ↔ IsOpen s) : X ≃ₜ Y 
goal: (e.toHomeomorph he).toEquiv = e

full_name: Equiv.toHomeomorph
code: /-- An equiv between topological spaces respecting openness is a homeomorphism. -/
@[simps toEquiv]
def toHomeomorph (e : X ≃ Y) (he : ∀ s, IsOpen (e ⁻¹' s) ↔ IsOpen s) : X ≃ₜ Y 
goal: X ≃ₜ Y

full_name: Equiv.coe_toHomeomorph
code: @[simp] lemma coe_toHomeomorph (e : X ≃ Y) (he) : ⇑(e.toHomeomorph he) = e 
goal: ⇑(e.toHomeomorph he) = ⇑e

full_name: Equiv.toHomeomorph_apply
code: lemma toHomeomorph_apply (e : X ≃ Y) (he) (x : X) : e.toHomeomorph he x = e x 
goal: (e.toHomeomorph he) x = e x

full_name: Equiv.toHomeomorph_refl
code: @[simp] lemma toHomeomorph_refl :
  (Equiv.refl X).toHomeomorph (fun _s ↦ Iff.rfl) = Homeomorph.refl _ 
goal: (Equiv.refl X).toHomeomorph ⋯ = Homeomorph.refl X

full_name: Equiv.toHomeomorph_symm
code: @[simp] lemma toHomeomorph_symm (e : X ≃ Y) (he) :
  (e.toHomeomorph he).symm = e.symm.toHomeomorph fun s ↦ by convert (he _).symm; simp 
goal: (e.toHomeomorph he).symm = e.symm.toHomeomorph ⋯

full_name: Equiv.toHomeomorph_trans
code: lemma toHomeomorph_trans (e : X ≃ Y) (f : Y ≃ Z) (he hf) :
    (e.trans f).toHomeomorph (fun _s ↦ (he _).trans (hf _)) =
    (e.toHomeomorph he).trans (f.toHomeomorph hf) 
goal: (e.trans f).toHomeomorph ⋯ = (e.toHomeomorph he).trans (f.toHomeomorph hf)

full_name: Equiv.toHomeomorphOfInducing
code: /-- An inducing equiv between topological spaces is a homeomorphism. -/
@[simps toEquiv] -- Porting note (#11215): TODO: was `@[simps]`
def toHomeomorphOfInducing (f : X ≃ Y) (hf : Inducing f) : X ≃ₜ Y 
goal: X ≃ₜ Y

full_name: Equiv.toHomeomorphOfInducing_toEquiv
code: /-- An inducing equiv between topological spaces is a homeomorphism. -/
@[simps toEquiv] -- Porting note (#11215): TODO: was `@[simps]`
def toHomeomorphOfInducing (f : X ≃ Y) (hf : Inducing f) : X ≃ₜ Y 
goal: (f.toHomeomorphOfInducing hf).toEquiv = f

full_name: Continuous.continuous_symm_of_equiv_compact_to_t2
code: theorem continuous_symm_of_equiv_compact_to_t2 [CompactSpace X] [T2Space Y] {f : X ≃ Y}
    (hf : Continuous f) : Continuous f.symm 
goal: Continuous ⇑f.symm

full_name: Continuous.homeoOfEquivCompactToT2_toEquiv
code: /-- Continuous equivalences from a compact space to a T2 space are homeomorphisms.

This is not true when T2 is weakened to T1
(see `Continuous.homeoOfEquivCompactToT2.t1_counterexample`). -/
@[simps toEquiv] -- Porting note: was `@[simps]`
def homeoOfEquivCompactToT2 [CompactSpace X] [T2Space Y] {f : X ≃ Y} (hf : Continuous f) : X ≃ₜ Y 
goal: hf.homeoOfEquivCompactToT2.toEquiv = f

full_name: Continuous.homeoOfEquivCompactToT2
code: /-- Continuous equivalences from a compact space to a T2 space are homeomorphisms.

This is not true when T2 is weakened to T1
(see `Continuous.homeoOfEquivCompactToT2.t1_counterexample`). -/
@[simps toEquiv] -- Porting note: was `@[simps]`
def homeoOfEquivCompactToT2 [CompactSpace X] [T2Space Y] {f : X ≃ Y} (hf : Continuous f) : X ≃ₜ Y 
goal: X ≃ₜ Y