Documentation

Mathlib.Topology.UniformSpace.Equiv

Uniform isomorphisms #

This file defines uniform isomorphisms between two uniform spaces. They are bijections with both directions uniformly continuous. We denote uniform isomorphisms with the notation ≃ᵤ.

Main definitions #

structure UniformEquiv (α : Type u_4) (β : Type u_5) [UniformSpace α] [UniformSpace β] extends α β :
Type (max u_4 u_5)

Uniform isomorphism between α and β

Instances For

    Uniform isomorphism between α and β

    Equations
      Instances For
        instance UniformEquiv.instEquivLike {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] :
        EquivLike (α ≃ᵤ β) α β
        Equations
          @[simp]
          theorem UniformEquiv.uniformEquiv_mk_coe {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (a : α β) (b : UniformContinuous a.toFun) (c : UniformContinuous a.invFun) :
          { toEquiv := a, uniformContinuous_toFun := b, uniformContinuous_invFun := c } = a
          def UniformEquiv.symm {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
          β ≃ᵤ α

          Inverse of a uniform isomorphism.

          Equations
            Instances For
              def UniformEquiv.Simps.apply {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
              αβ

              See Note [custom simps projection]. We need to specify this projection explicitly in this case, because it is a composition of multiple projections.

              Equations
                Instances For
                  def UniformEquiv.Simps.symm_apply {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                  βα

                  See Note [custom simps projection]

                  Equations
                    Instances For
                      @[simp]
                      theorem UniformEquiv.coe_toEquiv {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                      h.toEquiv = h
                      @[simp]
                      theorem UniformEquiv.coe_symm_toEquiv {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                      h.symm = h.symm
                      theorem UniformEquiv.ext {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] {h h' : α ≃ᵤ β} (H : ∀ (x : α), h x = h' x) :
                      h = h'
                      theorem UniformEquiv.ext_iff {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] {h h' : α ≃ᵤ β} :
                      h = h' ∀ (x : α), h x = h' x
                      def UniformEquiv.refl (α : Type u_4) [UniformSpace α] :
                      α ≃ᵤ α

                      Identity map as a uniform isomorphism.

                      Equations
                        Instances For
                          @[simp]
                          def UniformEquiv.trans {α : Type u} {β : Type u_1} {γ : Type u_2} [UniformSpace α] [UniformSpace β] [UniformSpace γ] (h₁ : α ≃ᵤ β) (h₂ : β ≃ᵤ γ) :
                          α ≃ᵤ γ

                          Composition of two uniform isomorphisms.

                          Equations
                            Instances For
                              @[simp]
                              theorem UniformEquiv.trans_apply {α : Type u} {β : Type u_1} {γ : Type u_2} [UniformSpace α] [UniformSpace β] [UniformSpace γ] (h₁ : α ≃ᵤ β) (h₂ : β ≃ᵤ γ) (a : α) :
                              (h₁.trans h₂) a = h₂ (h₁ a)
                              @[simp]
                              theorem UniformEquiv.uniformEquiv_mk_coe_symm {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (a : α β) (b : UniformContinuous a.toFun) (c : UniformContinuous a.invFun) :
                              { toEquiv := a, uniformContinuous_toFun := b, uniformContinuous_invFun := c }.symm = a.symm
                              theorem UniformEquiv.uniformContinuous {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                              theorem UniformEquiv.continuous {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                              theorem UniformEquiv.continuous_symm {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                              def UniformEquiv.toHomeomorph {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (e : α ≃ᵤ β) :
                              α ≃ₜ β

                              A uniform isomorphism as a homeomorphism.

                              Equations
                                Instances For
                                  theorem UniformEquiv.toHomeomorph_apply {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (e : α ≃ᵤ β) :
                                  e.toHomeomorph = e
                                  theorem UniformEquiv.toHomeomorph_symm_apply {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (e : α ≃ᵤ β) :
                                  @[simp]
                                  theorem UniformEquiv.apply_symm_apply {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) (x : β) :
                                  h (h.symm x) = x
                                  @[simp]
                                  theorem UniformEquiv.symm_apply_apply {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) (x : α) :
                                  h.symm (h x) = x
                                  theorem UniformEquiv.bijective {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                  theorem UniformEquiv.injective {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                  theorem UniformEquiv.surjective {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                  def UniformEquiv.changeInv {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (f : α ≃ᵤ β) (g : βα) (hg : Function.RightInverse g f) :
                                  α ≃ᵤ β

                                  Change the uniform equiv f to make the inverse function definitionally equal to g.

                                  Equations
                                    Instances For
                                      @[simp]
                                      theorem UniformEquiv.symm_comp_self {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      h.symm h = id
                                      @[simp]
                                      theorem UniformEquiv.self_comp_symm {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      h h.symm = id
                                      theorem UniformEquiv.range_coe {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      theorem UniformEquiv.image_symm {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      theorem UniformEquiv.preimage_symm {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      @[simp]
                                      theorem UniformEquiv.image_preimage {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) (s : Set β) :
                                      h '' (h ⁻¹' s) = s
                                      @[simp]
                                      theorem UniformEquiv.preimage_image {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) (s : Set α) :
                                      h ⁻¹' (h '' s) = s
                                      theorem UniformEquiv.isUniformInducing {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      theorem UniformEquiv.comap_eq {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      UniformSpace.comap (⇑h) inst✝ = inst✝¹
                                      theorem UniformEquiv.isUniformEmbedding {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β) :
                                      noncomputable def UniformEquiv.ofIsUniformEmbedding {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (f : αβ) (hf : IsUniformEmbedding f) :
                                      α ≃ᵤ (Set.range f)

                                      Uniform equiv given a uniform embedding.

                                      Equations
                                        Instances For
                                          def UniformEquiv.setCongr {α : Type u} [UniformSpace α] {s t : Set α} (h : s = t) :
                                          s ≃ᵤ t

                                          If two sets are equal, then they are uniformly equivalent.

                                          Equations
                                            Instances For
                                              def UniformEquiv.prodCongr {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ) :
                                              α × γ ≃ᵤ β × δ

                                              Product of two uniform isomorphisms.

                                              Equations
                                                Instances For
                                                  @[simp]
                                                  theorem UniformEquiv.prodCongr_symm {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ) :
                                                  (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm
                                                  @[simp]
                                                  theorem UniformEquiv.coe_prodCongr {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ) :
                                                  (h₁.prodCongr h₂) = Prod.map h₁ h₂
                                                  def UniformEquiv.prodComm (α : Type u) (β : Type u_1) [UniformSpace α] [UniformSpace β] :
                                                  α × β ≃ᵤ β × α

                                                  α × β is uniformly isomorphic to β × α.

                                                  Equations
                                                    Instances For
                                                      @[simp]
                                                      theorem UniformEquiv.prodComm_symm (α : Type u) (β : Type u_1) [UniformSpace α] [UniformSpace β] :
                                                      (prodComm α β).symm = prodComm β α
                                                      @[simp]
                                                      theorem UniformEquiv.coe_prodComm (α : Type u) (β : Type u_1) [UniformSpace α] [UniformSpace β] :
                                                      (prodComm α β) = Prod.swap
                                                      def UniformEquiv.prodAssoc (α : Type u) (β : Type u_1) (γ : Type u_2) [UniformSpace α] [UniformSpace β] [UniformSpace γ] :
                                                      (α × β) × γ ≃ᵤ α × β × γ

                                                      (α × β) × γ is uniformly isomorphic to α × (β × γ).

                                                      Equations
                                                        Instances For

                                                          α × {*} is uniformly isomorphic to α.

                                                          Equations
                                                            Instances For
                                                              @[simp]
                                                              theorem UniformEquiv.prodPunit_apply (α : Type u) [UniformSpace α] :
                                                              (prodPunit α) = fun (p : α × PUnit.{u_4 + 1}) => p.1

                                                              {*} × α is uniformly isomorphic to α.

                                                              Equations
                                                                Instances For
                                                                  @[simp]
                                                                  def UniformEquiv.piCongrLeft {ι : Type u_4} {ι' : Type u_5} {β : ι'Type u_6} [(j : ι') → UniformSpace (β j)] (e : ι ι') :
                                                                  ((i : ι) → β (e i)) ≃ᵤ ((j : ι') → β j)

                                                                  Equiv.piCongrLeft as a uniform isomorphism: this is the natural isomorphism Π i, β (e i) ≃ᵤ Π j, β j obtained from a bijection ι ≃ ι'.

                                                                  Equations
                                                                    Instances For
                                                                      @[simp]
                                                                      theorem UniformEquiv.piCongrLeft_toEquiv {ι : Type u_4} {ι' : Type u_5} {β : ι'Type u_6} [(j : ι') → UniformSpace (β j)] (e : ι ι') :
                                                                      theorem UniformEquiv.piCongrLeft_apply {ι : Type u_4} {ι' : Type u_5} {β : ι'Type u_6} [(j : ι') → UniformSpace (β j)] (e : ι ι') (a✝ : (b : ι) → β (e.symm.symm b)) (a : ι') :
                                                                      (piCongrLeft e) a✝ a = (Equiv.piCongrLeft' β e.symm).symm a✝ a
                                                                      @[simp]
                                                                      theorem UniformEquiv.piCongrLeft_refl {ι : Type u_4} {X : ιType u_5} [(i : ι) → UniformSpace (X i)] :
                                                                      piCongrLeft (Equiv.refl ι) = UniformEquiv.refl ((i : ι) → X i)
                                                                      @[simp]
                                                                      theorem UniformEquiv.piCongrLeft_symm_apply {ι : Type u_4} {ι' : Type u_5} {X : ι'Type u_6} [(j : ι') → UniformSpace (X j)] (e : ι ι') :
                                                                      (piCongrLeft e).symm = fun (x1 : (j : ι') → X j) (x2 : ι) => x1 (e x2)
                                                                      @[simp]
                                                                      theorem UniformEquiv.piCongrLeft_apply_apply {ι : Type u_4} {ι' : Type u_5} {X : ι'Type u_6} [(j : ι') → UniformSpace (X j)] (e : ι ι') (x : (i : ι) → X (e i)) (i : ι) :
                                                                      (piCongrLeft e) x (e i) = x i
                                                                      def UniformEquiv.piCongrRight {ι : Type u_4} {β₁ : ιType u_5} {β₂ : ιType u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i) :
                                                                      ((i : ι) → β₁ i) ≃ᵤ ((i : ι) → β₂ i)

                                                                      Equiv.piCongrRight as a uniform isomorphism: this is the natural isomorphism Π i, β₁ i ≃ᵤ Π j, β₂ i obtained from uniform isomorphisms β₁ i ≃ᵤ β₂ i for each i.

                                                                      Equations
                                                                        Instances For
                                                                          @[simp]
                                                                          theorem UniformEquiv.piCongrRight_apply {ι : Type u_4} {β₁ : ιType u_5} {β₂ : ιType u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i) (a✝ : (i : ι) → β₁ i) (i : ι) :
                                                                          (piCongrRight F) a✝ i = (F i) (a✝ i)
                                                                          @[simp]
                                                                          theorem UniformEquiv.piCongrRight_toEquiv {ι : Type u_4} {β₁ : ιType u_5} {β₂ : ιType u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i) :
                                                                          (piCongrRight F).toEquiv = Equiv.piCongrRight fun (i : ι) => (F i).toEquiv
                                                                          @[simp]
                                                                          theorem UniformEquiv.piCongrRight_symm {ι : Type u_4} {β₁ : ιType u_5} {β₂ : ιType u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i) :
                                                                          (piCongrRight F).symm = piCongrRight fun (i : ι) => (F i).symm
                                                                          @[simp]
                                                                          theorem UniformEquiv.piCongrRight_refl {ι : Type u_4} {X : ιType u_5} [(i : ι) → UniformSpace (X i)] :
                                                                          (piCongrRight fun (i : ι) => UniformEquiv.refl (X i)) = UniformEquiv.refl ((i : ι) → X i)
                                                                          def UniformEquiv.piCongr {ι₁ : Type u_4} {ι₂ : Type u_5} {β₁ : ι₁Type u_6} {β₂ : ι₂Type u_7} [(i₁ : ι₁) → UniformSpace (β₁ i₁)] [(i₂ : ι₂) → UniformSpace (β₂ i₂)] (e : ι₁ ι₂) (F : (i₁ : ι₁) → β₁ i₁ ≃ᵤ β₂ (e i₁)) :
                                                                          ((i₁ : ι₁) → β₁ i₁) ≃ᵤ ((i₂ : ι₂) → β₂ i₂)

                                                                          Equiv.piCongr as a uniform isomorphism: this is the natural isomorphism Π i₁, β₁ i ≃ᵤ Π i₂, β₂ i₂ obtained from a bijection ι₁ ≃ ι₂ and isomorphisms β₁ i₁ ≃ᵤ β₂ (e i₁) for each i₁ : ι₁.

                                                                          Equations
                                                                            Instances For
                                                                              @[simp]
                                                                              theorem UniformEquiv.piCongr_toEquiv {ι₁ : Type u_4} {ι₂ : Type u_5} {β₁ : ι₁Type u_6} {β₂ : ι₂Type u_7} [(i₁ : ι₁) → UniformSpace (β₁ i₁)] [(i₂ : ι₂) → UniformSpace (β₂ i₂)] (e : ι₁ ι₂) (F : (i₁ : ι₁) → β₁ i₁ ≃ᵤ β₂ (e i₁)) :
                                                                              (piCongr e F).toEquiv = (Equiv.piCongrRight fun (i : ι₁) => (F i).toEquiv).trans (Equiv.piCongrLeft β₂ e)
                                                                              @[simp]
                                                                              theorem UniformEquiv.piCongr_apply {ι₁ : Type u_4} {ι₂ : Type u_5} {β₁ : ι₁Type u_6} {β₂ : ι₂Type u_7} [(i₁ : ι₁) → UniformSpace (β₁ i₁)] [(i₂ : ι₂) → UniformSpace (β₂ i₂)] (e : ι₁ ι₂) (F : (i₁ : ι₁) → β₁ i₁ ≃ᵤ β₂ (e i₁)) (a✝ : (i : ι₁) → β₁ i) (i₂ : ι₂) :
                                                                              (piCongr e F) a✝ i₂ = (Equiv.piCongrLeft β₂ e) ((Equiv.piCongrRight fun (i : ι₁) => (F i).toEquiv) a✝) i₂

                                                                              Uniform equivalence between ULift α and α.

                                                                              Equations
                                                                                Instances For
                                                                                  def UniformEquiv.funUnique (ι : Type u_4) (α : Type u_5) [Unique ι] [UniformSpace α] :
                                                                                  (ια) ≃ᵤ α

                                                                                  If ι has a unique element, then ι → α is uniformly isomorphic to α.

                                                                                  Equations
                                                                                    Instances For
                                                                                      @[simp]
                                                                                      theorem UniformEquiv.funUnique_symm_apply (ι : Type u_4) (α : Type u_5) [Unique ι] [UniformSpace α] :
                                                                                      @[simp]
                                                                                      theorem UniformEquiv.funUnique_apply (ι : Type u_4) (α : Type u_5) [Unique ι] [UniformSpace α] :
                                                                                      (funUnique ι α) = fun (f : ια) => f default
                                                                                      def UniformEquiv.piFinTwo (α : Fin 2Type u) [(i : Fin 2) → UniformSpace (α i)] :
                                                                                      ((i : Fin 2) → α i) ≃ᵤ α 0 × α 1

                                                                                      Uniform isomorphism between dependent functions Π i : Fin 2, α i and α 0 × α 1.

                                                                                      Equations
                                                                                        Instances For
                                                                                          @[simp]
                                                                                          theorem UniformEquiv.piFinTwo_symm_apply (α : Fin 2Type u) [(i : Fin 2) → UniformSpace (α i)] :
                                                                                          (piFinTwo α).symm = fun (p : α 0 × α 1) => Fin.cons p.1 (Fin.cons p.2 finZeroElim)
                                                                                          @[simp]
                                                                                          theorem UniformEquiv.piFinTwo_apply (α : Fin 2Type u) [(i : Fin 2) → UniformSpace (α i)] :
                                                                                          (piFinTwo α) = fun (f : (i : Fin 2) → α i) => (f 0, f 1)
                                                                                          def UniformEquiv.finTwoArrow (α : Type u_4) [UniformSpace α] :
                                                                                          (Fin 2α) ≃ᵤ α × α

                                                                                          Uniform isomorphism between α² = Fin 2 → α and α × α.

                                                                                          Equations
                                                                                            Instances For
                                                                                              @[simp]
                                                                                              theorem UniformEquiv.finTwoArrow_apply (α : Type u_4) [UniformSpace α] :
                                                                                              (finTwoArrow α) = fun (f : Fin 2α) => (f 0, f 1)
                                                                                              @[simp]
                                                                                              theorem UniformEquiv.finTwoArrow_symm_apply (α : Type u_4) [UniformSpace α] :
                                                                                              (finTwoArrow α).symm = fun (x : α × α) => ![x.1, x.2]
                                                                                              def UniformEquiv.image {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (e : α ≃ᵤ β) (s : Set α) :
                                                                                              s ≃ᵤ ↑(e '' s)

                                                                                              A subset of a uniform space is uniformly isomorphic to its image under a uniform isomorphism.

                                                                                              Equations
                                                                                                Instances For
                                                                                                  def Equiv.toUniformEquivOfIsUniformInducing {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (f : α β) (hf : IsUniformInducing f) :
                                                                                                  α ≃ᵤ β

                                                                                                  A uniform inducing equiv between uniform spaces is a uniform isomorphism.

                                                                                                  Equations
                                                                                                    Instances For