File: Mathlib/Topology/MetricSpace/DilationEquiv.lean

full_name: DilationEquivClass
code: /-- Typeclass saying that `F` is a type of bundled equivalences such that all `e : F` are
dilations. -/
class DilationEquivClass [EquivLike F X Y] : Prop where
  edist_eq' : ∀ f : F, ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : X, edist (f x) (f y) = r * edist x y
goal: Prop

full_name: DilationEquivClass.edist_eq'
code: /-- Typeclass saying that `F` is a type of bundled equivalences such that all `e : F` are
dilations. -/
class DilationEquivClass [EquivLike F X Y] : Prop where
  edist_eq' : ∀ f : F, ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : X, edist (f x) (f y) = r * edist x y
goal: ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (f x) (f y) = ↑r * edist x y

full_name: instDilationClassOfDilationEquivClass
code: instance (priority := 100) [EquivLike F X Y] [DilationEquivClass F X Y] : DilationClass F X Y 
goal: DilationClass F X Y

full_name: DilationEquiv
code: /-- Type of equivalences `X ≃ Y` such that `∀ x y, edist (f x) (f y) = r * edist x y` for some
`r : ℝ≥0`, `r ≠ 0`. -/
structure DilationEquiv (X Y : Type*) [PseudoEMetricSpace X] [PseudoEMetricSpace Y]
    extends X ≃ Y, Dilation X Y
goal: Type (max u_1 u_2)

full_name: _aux_Mathlib_Topology_MetricSpace_DilationEquiv___unexpand_DilationEquiv_1
code: infixl:25 " ≃ᵈ " => DilationEquiv
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_MetricSpace_DilationEquiv___macroRules_term_≃ᵈ__1»
code: infixl:25 " ≃ᵈ " => DilationEquiv
goal: Lean.Macro

full_name: DilationEquiv.instEquivLike
code: instance : EquivLike (X ≃ᵈ Y) X Y 
goal: EquivLike (X ≃ᵈ Y) X Y

full_name: DilationEquiv.instDilationEquivClass
code: instance : DilationEquivClass (X ≃ᵈ Y) X Y 
goal: DilationEquivClass (X ≃ᵈ Y) X Y

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

full_name: DilationEquiv.coe_toEquiv
code: @[simp] theorem coe_toEquiv (e : X ≃ᵈ Y) : ⇑e.toEquiv = e 
goal: ⇑e.toEquiv = ⇑e

full_name: DilationEquiv.ext
code: @[ext]
protected theorem ext {e e' : X ≃ᵈ Y} (h : ∀ x, e x = e' x) : e = e' 
goal: e = e'

full_name: DilationEquiv.symm
code: /-- Inverse `DilationEquiv`. -/
def symm (e : X ≃ᵈ Y) : Y ≃ᵈ X 
goal: Y ≃ᵈ X

full_name: DilationEquiv.symm_symm
code: @[simp] theorem symm_symm (e : X ≃ᵈ Y) : e.symm.symm = e 
goal: e.symm.symm = e

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

full_name: DilationEquiv.apply_symm_apply
code: @[simp] theorem apply_symm_apply (e : X ≃ᵈ Y) (x : Y) : e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: DilationEquiv.symm_apply_apply
code: @[simp] theorem symm_apply_apply (e : X ≃ᵈ Y) (x : X) : e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: DilationEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection]. -/
def Simps.symm_apply (e : X ≃ᵈ Y) : Y → X 
goal: Y → X

full_name: DilationEquiv.ratio_toDilation
code: lemma ratio_toDilation (e : X ≃ᵈ Y) : ratio e.toDilation = ratio e 
goal: Dilation.ratio e.toDilation = Dilation.ratio e

full_name: DilationEquiv.refl_apply
code: /-- Identity map as a `DilationEquiv`. -/
@[simps! (config := .asFn) apply]
def refl (X : Type*) [PseudoEMetricSpace X] : X ≃ᵈ X 
goal: ⇑(DilationEquiv.refl X) = id

full_name: DilationEquiv.refl
code: /-- Identity map as a `DilationEquiv`. -/
@[simps! (config := .asFn) apply]
def refl (X : Type*) [PseudoEMetricSpace X] : X ≃ᵈ X 
goal: X ≃ᵈ X

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

full_name: DilationEquiv.ratio_refl
code: @[simp] theorem ratio_refl : ratio (refl X) = 1 
goal: Dilation.ratio (DilationEquiv.refl X) = 1

full_name: DilationEquiv.trans_apply
code: /-- Composition of `DilationEquiv`s. -/
@[simps! (config := .asFn) apply]
def trans (e₁ : X ≃ᵈ Y) (e₂ : Y ≃ᵈ Z) : X ≃ᵈ Z 
goal: ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁

full_name: DilationEquiv.trans
code: /-- Composition of `DilationEquiv`s. -/
@[simps! (config := .asFn) apply]
def trans (e₁ : X ≃ᵈ Y) (e₂ : Y ≃ᵈ Z) : X ≃ᵈ Z 
goal: X ≃ᵈ Z

full_name: DilationEquiv.refl_trans
code: @[simp] theorem refl_trans (e : X ≃ᵈ Y) : (refl X).trans e = e 
goal: (DilationEquiv.refl X).trans e = e

full_name: DilationEquiv.trans_refl
code: @[simp] theorem trans_refl (e : X ≃ᵈ Y) : e.trans (refl Y) = e 
goal: e.trans (DilationEquiv.refl Y) = e

full_name: DilationEquiv.symm_trans_self
code: @[simp] theorem symm_trans_self (e : X ≃ᵈ Y) : e.symm.trans e = refl Y 
goal: e.symm.trans e = DilationEquiv.refl Y

full_name: DilationEquiv.self_trans_symm
code: @[simp] theorem self_trans_symm (e : X ≃ᵈ Y) : e.trans e.symm = refl X 
goal: e.trans e.symm = DilationEquiv.refl X

full_name: DilationEquiv.surjective
code: protected theorem surjective (e : X ≃ᵈ Y) : Surjective e 
goal: Function.Surjective ⇑e

full_name: DilationEquiv.bijective
code: protected theorem bijective (e : X ≃ᵈ Y) : Bijective e 
goal: Function.Bijective ⇑e

full_name: DilationEquiv.injective
code: protected theorem injective (e : X ≃ᵈ Y) : Injective e 
goal: Function.Injective ⇑e

full_name: DilationEquiv.ratio_trans
code: @[simp]
theorem ratio_trans (e : X ≃ᵈ Y) (e' : Y ≃ᵈ Z) : ratio (e.trans e') = ratio e * ratio e' 
goal: Dilation.ratio (e.trans e') = Dilation.ratio e * Dilation.ratio e'

full_name: DilationEquiv.ratio_symm
code: @[simp]
theorem ratio_symm (e : X ≃ᵈ Y) : ratio e.symm = (ratio e)⁻¹ 
goal: Dilation.ratio e.symm = (Dilation.ratio e)⁻¹

full_name: DilationEquiv.instGroup
code: instance : Group (X ≃ᵈ X) 
goal: Group (X ≃ᵈ X)

full_name: DilationEquiv.mul_def
code: theorem mul_def (e e' : X ≃ᵈ X) : e * e' = e'.trans e 
goal: e * e' = e'.trans e

full_name: DilationEquiv.one_def
code: theorem one_def : (1 : X ≃ᵈ X) = refl X 
goal: 1 = DilationEquiv.refl X

full_name: DilationEquiv.inv_def
code: theorem inv_def (e : X ≃ᵈ X) : e⁻¹ = e.symm 
goal: e⁻¹ = e.symm

full_name: DilationEquiv.coe_mul
code: @[simp] theorem coe_mul (e e' : X ≃ᵈ X) : ⇑(e * e') = e ∘ e' 
goal: ⇑(e * e') = ⇑e ∘ ⇑e'

full_name: DilationEquiv.coe_one
code: @[simp] theorem coe_one : ⇑(1 : X ≃ᵈ X) = id 
goal: ⇑1 = id

full_name: DilationEquiv.coe_inv
code: theorem coe_inv (e : X ≃ᵈ X) : ⇑(e⁻¹) = e.symm 
goal: ⇑e⁻¹ = ⇑e.symm

full_name: DilationEquiv.ratioHom
code: /-- `Dilation.ratio` as a monoid homomorphism. -/
noncomputable def ratioHom : (X ≃ᵈ X) →* ℝ≥0 
goal: (X ≃ᵈ X) →* ℝ≥0

full_name: DilationEquiv.ratio_inv
code: @[simp]
theorem ratio_inv (e : X ≃ᵈ X) : ratio (e⁻¹) = (ratio e)⁻¹ 
goal: Dilation.ratio e⁻¹ = (Dilation.ratio e)⁻¹

full_name: DilationEquiv.ratio_pow
code: @[simp]
theorem ratio_pow (e : X ≃ᵈ X) (n : ℕ) : ratio (e ^ n) = ratio e ^ n 
goal: Dilation.ratio (e ^ n) = Dilation.ratio e ^ n

full_name: DilationEquiv.ratio_zpow
code: @[simp]
theorem ratio_zpow (e : X ≃ᵈ X) (n : ℤ) : ratio (e ^ n) = ratio e ^ n 
goal: Dilation.ratio (e ^ n) = Dilation.ratio e ^ n

full_name: DilationEquiv.toPerm
code: /-- `DilationEquiv.toEquiv` as a monoid homomorphism. -/
@[simps]
def toPerm : (X ≃ᵈ X) →* Equiv.Perm X 
goal: (X ≃ᵈ X) →* Equiv.Perm X

full_name: DilationEquiv.toPerm_apply
code: /-- `DilationEquiv.toEquiv` as a monoid homomorphism. -/
@[simps]
def toPerm : (X ≃ᵈ X) →* Equiv.Perm X 
goal: DilationEquiv.toPerm e = e.toEquiv

full_name: DilationEquiv.coe_pow
code: @[norm_cast]
theorem coe_pow (e : X ≃ᵈ X) (n : ℕ) : ⇑(e ^ n) = e^[n] 
goal: ⇑(e ^ n) = (⇑e)^[n]

full_name: IsometryEquiv.toDilationEquiv
code: /-- Every isometry equivalence is a dilation equivalence of ratio `1`. -/
def _root_.IsometryEquiv.toDilationEquiv (e : X ≃ᵢ Y) : X ≃ᵈ Y 
goal: X ≃ᵈ Y

full_name: IsometryEquiv.toDilationEquiv_apply
code: @[simp]
lemma _root_.IsometryEquiv.toDilationEquiv_apply (e : X ≃ᵢ Y) (x : X) :
    e.toDilationEquiv x = e x 
goal: e.toDilationEquiv x = e x

full_name: IsometryEquiv.toDilationEquiv_symm
code: @[simp]
lemma _root_.IsometryEquiv.toDilationEquiv_symm (e : X ≃ᵢ Y) :
    e.toDilationEquiv.symm = e.symm.toDilationEquiv 
goal: e.toDilationEquiv.symm = e.symm.toDilationEquiv

full_name: IsometryEquiv.toDilationEquiv_toDilation
code: @[simp]
lemma _root_.IsometryEquiv.toDilationEquiv_toDilation (e : X ≃ᵢ Y) :
    (e.toDilationEquiv.toDilation : X →ᵈ Y) = e.isometry.toDilation 
goal: e.toDilationEquiv.toDilation = Isometry.toDilation ⇑e ⋯

full_name: IsometryEquiv.toDilationEquiv_ratio
code: @[simp]
lemma _root_.IsometryEquiv.toDilationEquiv_ratio (e : X ≃ᵢ Y) : ratio e.toDilationEquiv = 1 
goal: Dilation.ratio e.toDilationEquiv = 1

full_name: DilationEquiv.toHomeomorph
code: /-- Reinterpret a `DilationEquiv` as a homeomorphism. -/
def toHomeomorph (e : X ≃ᵈ Y) : X ≃ₜ Y 
goal: X ≃ₜ Y

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

full_name: DilationEquiv.toHomeomorph_symm
code: @[simp]
lemma toHomeomorph_symm (e : X ≃ᵈ Y) : e.toHomeomorph.symm = e.symm.toHomeomorph 
goal: e.toHomeomorph.symm = e.symm.toHomeomorph

full_name: DilationEquiv.map_cobounded
code: @[simp]
lemma map_cobounded (e : F) : map e (cobounded X) = cobounded Y 
goal: Filter.map (⇑e) (Bornology.cobounded X) = Bornology.cobounded Y