File: Mathlib/Topology/MetricSpace/Dilation.lean

full_name: Dilation.toFun
code: /-- A dilation is a map that uniformly scales the edistance between any two points. -/
structure Dilation where
  toFun : α → β
  edist_eq' : ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, edist (toFun x) (toFun y) = r * edist x y
goal: α → β

full_name: Dilation.edist_eq'
code: /-- A dilation is a map that uniformly scales the edistance between any two points. -/
structure Dilation where
  toFun : α → β
  edist_eq' : ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, edist (toFun x) (toFun y) = r * edist x y
goal: ∃ r, r ≠ 0 ∧ ∀ (x y : α), edist (self.toFun x) (self.toFun y) = ↑r * edist x y

full_name: Dilation
code: /-- A dilation is a map that uniformly scales the edistance between any two points. -/
structure Dilation where
  toFun : α → β
  edist_eq' : ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, edist (toFun x) (toFun y) = r * edist x y
goal: Type (max u_1 u_2)

full_name: «_aux_Mathlib_Topology_MetricSpace_Dilation___macroRules_term_→ᵈ__1»
code: infixl:25 " →ᵈ " => Dilation
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_MetricSpace_Dilation___unexpand_Dilation_1
code: infixl:25 " →ᵈ " => Dilation
goal: Lean.PrettyPrinter.Unexpander

full_name: DilationClass.edist_eq'
code: /-- `DilationClass F α β r` states that `F` is a type of `r`-dilations.
You should extend this typeclass when you extend `Dilation`. -/
class DilationClass (F α β : Type*) [PseudoEMetricSpace α] [PseudoEMetricSpace β]
    [FunLike F α β] : Prop where
  edist_eq' : ∀ f : F, ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, edist (f x) (f y) = r * edist x y
goal: ∃ r, r ≠ 0 ∧ ∀ (x y : α), edist (f x) (f y) = ↑r * edist x y

full_name: DilationClass
code: /-- `DilationClass F α β r` states that `F` is a type of `r`-dilations.
You should extend this typeclass when you extend `Dilation`. -/
class DilationClass (F α β : Type*) [PseudoEMetricSpace α] [PseudoEMetricSpace β]
    [FunLike F α β] : Prop where
  edist_eq' : ∀ f : F, ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, edist (f x) (f y) = r * edist x y
goal: Prop

full_name: Dilation.funLike
code: instance funLike : FunLike (α →ᵈ β) α β 
goal: FunLike (α →ᵈ β) α β

full_name: Dilation.toDilationClass
code: instance toDilationClass : DilationClass (α →ᵈ β) α β 
goal: DilationClass (α →ᵈ β) α β

full_name: Dilation.instCoeFunForall
code: instance : CoeFun (α →ᵈ β) fun _ => α → β 
goal: CoeFun (α →ᵈ β) fun x => α → β

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

full_name: Dilation.coe_mk
code: @[simp]
theorem coe_mk (f : α → β) (h) : ⇑(⟨f, h⟩ : α →ᵈ β) = f 
goal: ⇑{ toFun := f, edist_eq' := h } = f

full_name: Dilation.congr_fun
code: protected theorem congr_fun {f g : α →ᵈ β} (h : f = g) (x : α) : f x = g x 
goal: f x = g x

full_name: Dilation.congr_arg
code: protected theorem congr_arg (f : α →ᵈ β) {x y : α} (h : x = y) : f x = f y 
goal: f x = f y

full_name: Dilation.ext
code: @[ext]
theorem ext {f g : α →ᵈ β} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: Dilation.ext_iff
code: theorem ext_iff {f g : α →ᵈ β} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : α), f x = g x

full_name: Dilation.mk_coe
code: @[simp]
theorem mk_coe (f : α →ᵈ β) (h) : Dilation.mk f h = f 
goal: { toFun := ⇑f, edist_eq' := h } = f

full_name: Dilation.copy
code: /-- Copy of a `Dilation` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
@[simps (config := .asFn)]
protected def copy (f : α →ᵈ β) (f' : α → β) (h : f' = ⇑f) : α →ᵈ β 
goal: α →ᵈ β

full_name: Dilation.copy_toFun
code: /-- Copy of a `Dilation` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
@[simps (config := .asFn)]
protected def copy (f : α →ᵈ β) (f' : α → β) (h : f' = ⇑f) : α →ᵈ β 
goal: ⇑(f.copy f' h) = f'

full_name: Dilation.copy_eq_self
code: theorem copy_eq_self (f : α →ᵈ β) {f' : α → β} (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: Dilation.ratio
code: /-- The ratio of a dilation `f`. If the ratio is undefined (i.e., the distance between any two
points in `α` is either zero or infinity), then we choose one as the ratio. -/
def ratio [DilationClass F α β] (f : F) : ℝ≥0 
goal: ℝ≥0

full_name: Dilation.ratio_of_trivial
code: theorem ratio_of_trivial [DilationClass F α β] (f : F)
    (h : ∀ x y : α, edist x y = 0 ∨ edist x y = ∞) : ratio f = 1 
goal: Dilation.ratio f = 1

full_name: Dilation.ratio_of_subsingleton
code: @[nontriviality]
theorem ratio_of_subsingleton [Subsingleton α] [DilationClass F α β] (f : F) : ratio f = 1 
goal: Dilation.ratio f = 1

full_name: Dilation.ratio_ne_zero
code: theorem ratio_ne_zero [DilationClass F α β] (f : F) : ratio f ≠ 0 
goal: Dilation.ratio f ≠ 0

full_name: Dilation.ratio_pos
code: theorem ratio_pos [DilationClass F α β] (f : F) : 0 < ratio f 
goal: 0 < Dilation.ratio f

full_name: Dilation.edist_eq
code: @[simp]
theorem edist_eq [DilationClass F α β] (f : F) (x y : α) :
    edist (f x) (f y) = ratio f * edist x y 
goal: edist (f x) (f y) = ↑(Dilation.ratio f) * edist x y

full_name: Dilation.nndist_eq
code: @[simp]
theorem nndist_eq {α β F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β] [FunLike F α β]
    [DilationClass F α β] (f : F) (x y : α) :
    nndist (f x) (f y) = ratio f * nndist x y 
goal: nndist (f x) (f y) = Dilation.ratio f * nndist x y

full_name: Dilation.dist_eq
code: @[simp]
theorem dist_eq {α β F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β] [FunLike F α β]
    [DilationClass F α β] (f : F) (x y : α) :
    dist (f x) (f y) = ratio f * dist x y 
goal: dist (f x) (f y) = ↑(Dilation.ratio f) * dist x y

full_name: Dilation.ratio_unique
code: /-- The `ratio` is equal to the distance ratio for any two points with nonzero finite distance.
`dist` and `nndist` versions below -/
theorem ratio_unique [DilationClass F α β] {f : F} {x y : α} {r : ℝ≥0} (h₀ : edist x y ≠ 0)
    (htop : edist x y ≠ ⊤) (hr : edist (f x) (f y) = r * edist x y) : r = ratio f 
goal: r = Dilation.ratio f

full_name: Dilation.ratio_unique_of_nndist_ne_zero
code: /-- The `ratio` is equal to the distance ratio for any two points
with nonzero finite distance; `nndist` version -/
theorem ratio_unique_of_nndist_ne_zero {α β F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β]
    [FunLike F α β] [DilationClass F α β] {f : F} {x y : α} {r : ℝ≥0} (hxy : nndist x y ≠ 0)
    (hr : nndist (f x) (f y) = r * nndist x y) : r = ratio f 
goal: r = Dilation.ratio f

full_name: Dilation.ratio_unique_of_dist_ne_zero
code: /-- The `ratio` is equal to the distance ratio for any two points
with nonzero finite distance; `dist` version -/
theorem ratio_unique_of_dist_ne_zero {α β} {F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β]
    [FunLike F α β] [DilationClass F α β] {f : F} {x y : α} {r : ℝ≥0} (hxy : dist x y ≠ 0)
    (hr : dist (f x) (f y) = r * dist x y) : r = ratio f 
goal: r = Dilation.ratio f

full_name: Dilation.mkOfNNDistEq
code: /-- Alternative `Dilation` constructor when the distance hypothesis is over `nndist` -/
def mkOfNNDistEq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α → β)
    (h : ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, nndist (f x) (f y) = r * nndist x y) : α →ᵈ β 
goal: α →ᵈ β

full_name: Dilation.coe_mkOfNNDistEq
code: @[simp]
theorem coe_mkOfNNDistEq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α → β) (h) :
    ⇑(mkOfNNDistEq f h : α →ᵈ β) = f 
goal: ⇑(Dilation.mkOfNNDistEq f h) = f

full_name: Dilation.mk_coe_of_nndist_eq
code: @[simp]
theorem mk_coe_of_nndist_eq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α →ᵈ β)
    (h) : Dilation.mkOfNNDistEq f h = f 
goal: Dilation.mkOfNNDistEq (⇑f) h = f

full_name: Dilation.mkOfDistEq
code: /-- Alternative `Dilation` constructor when the distance hypothesis is over `dist` -/
def mkOfDistEq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α → β)
    (h : ∃ r : ℝ≥0, r ≠ 0 ∧ ∀ x y : α, dist (f x) (f y) = r * dist x y) : α →ᵈ β 
goal: α →ᵈ β

full_name: Dilation.coe_mkOfDistEq
code: @[simp]
theorem coe_mkOfDistEq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α → β) (h) :
    ⇑(mkOfDistEq f h : α →ᵈ β) = f 
goal: ⇑(Dilation.mkOfDistEq f h) = f

full_name: Dilation.mk_coe_of_dist_eq
code: @[simp]
theorem mk_coe_of_dist_eq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α →ᵈ β) (h) :
    Dilation.mkOfDistEq f h = f 
goal: Dilation.mkOfDistEq (⇑f) h = f

full_name: Isometry.toDilation_toFun
code: /-- Every isometry is a dilation of ratio `1`. -/
@[simps]
def _root_.Isometry.toDilation (f : α → β) (hf : Isometry f) : α →ᵈ β 
goal: ∀ (a : α), (Isometry.toDilation f hf) a = f a

full_name: Isometry.toDilation
code: /-- Every isometry is a dilation of ratio `1`. -/
@[simps]
def _root_.Isometry.toDilation (f : α → β) (hf : Isometry f) : α →ᵈ β 
goal: α →ᵈ β

full_name: Isometry.toDilation_ratio
code: @[simp]
lemma _root_.Isometry.toDilation_ratio {f : α → β} {hf : Isometry f} : ratio hf.toDilation = 1 
goal: Dilation.ratio (Isometry.toDilation f hf) = 1

full_name: Dilation.lipschitz
code: theorem lipschitz : LipschitzWith (ratio f) (f : α → β) 
goal: LipschitzWith (Dilation.ratio f) ⇑f

full_name: Dilation.antilipschitz
code: theorem antilipschitz : AntilipschitzWith (ratio f)⁻¹ (f : α → β) 
goal: AntilipschitzWith (Dilation.ratio f)⁻¹ ⇑f

full_name: Dilation.injective
code: /-- A dilation from an emetric space is injective -/
protected theorem injective {α : Type*} [EMetricSpace α] [FunLike F α β]  [DilationClass F α β]
    (f : F) :
    Injective f 
goal: Function.Injective ⇑f

full_name: Dilation.id
code: /-- The identity is a dilation -/
protected def id (α) [PseudoEMetricSpace α] : α →ᵈ α 
goal: α →ᵈ α

full_name: Dilation.instInhabited
code: instance : Inhabited (α →ᵈ α) 
goal: Inhabited (α →ᵈ α)

full_name: Dilation.coe_id
code: @[simp] -- Porting note: Removed `@[protected]`
theorem coe_id : ⇑(Dilation.id α) = id 
goal: ⇑(Dilation.id α) = id

full_name: Dilation.ratio_id
code: theorem ratio_id : ratio (Dilation.id α) = 1 
goal: Dilation.ratio (Dilation.id α) = 1

full_name: Dilation.comp
code: /-- The composition of dilations is a dilation -/
def comp (g : β →ᵈ γ) (f : α →ᵈ β) : α →ᵈ γ 
goal: α →ᵈ γ

full_name: Dilation.comp_assoc
code: theorem comp_assoc {δ : Type*} [PseudoEMetricSpace δ] (f : α →ᵈ β) (g : β →ᵈ γ)
    (h : γ →ᵈ δ) : (h.comp g).comp f = h.comp (g.comp f) 
goal: (h.comp g).comp f = h.comp (g.comp f)

full_name: Dilation.coe_comp
code: @[simp]
theorem coe_comp (g : β →ᵈ γ) (f : α →ᵈ β) : (g.comp f : α → γ) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: Dilation.comp_apply
code: theorem comp_apply (g : β →ᵈ γ) (f : α →ᵈ β) (x : α) : (g.comp f : α → γ) x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: Dilation.ratio_comp'
code: /-- Ratio of the composition `g.comp f` of two dilations is the product of their ratios. We assume
that there exist two points in `α` at extended distance neither `0` nor `∞` because otherwise
`Dilation.ratio (g.comp f) = Dilation.ratio f = 1` while `Dilation.ratio g` can be any number. This
version works for most general spaces, see also `Dilation.ratio_comp` for a version assuming that
`α` is a nontrivial metric space. -/
theorem ratio_comp' {g : β →ᵈ γ} {f : α →ᵈ β}
    (hne : ∃ x y : α, edist x y ≠ 0 ∧ edist x y ≠ ⊤) : ratio (g.comp f) = ratio g * ratio f 
goal: Dilation.ratio (g.comp f) = Dilation.ratio g * Dilation.ratio f

full_name: Dilation.comp_id
code: @[simp]
theorem comp_id (f : α →ᵈ β) : f.comp (Dilation.id α) = f 
goal: f.comp (Dilation.id α) = f

full_name: Dilation.id_comp
code: @[simp]
theorem id_comp (f : α →ᵈ β) : (Dilation.id β).comp f = f 
goal: (Dilation.id β).comp f = f

full_name: Dilation.instMonoid
code: instance : Monoid (α →ᵈ α) 
goal: Monoid (α →ᵈ α)

full_name: Dilation.one_def
code: theorem one_def : (1 : α →ᵈ α) = Dilation.id α 
goal: 1 = Dilation.id α

full_name: Dilation.mul_def
code: theorem mul_def (f g : α →ᵈ α) : f * g = f.comp g 
goal: f * g = f.comp g

full_name: Dilation.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : α →ᵈ α) = id 
goal: ⇑1 = id

full_name: Dilation.coe_mul
code: @[simp]
theorem coe_mul (f g : α →ᵈ α) : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: Dilation.ratio_one
code: @[simp] theorem ratio_one : ratio (1 : α →ᵈ α) = 1 
goal: Dilation.ratio 1 = 1

full_name: Dilation.ratio_mul
code: @[simp]
theorem ratio_mul (f g : α →ᵈ α) : ratio (f * g) = ratio f * ratio g 
goal: Dilation.ratio (f * g) = Dilation.ratio f * Dilation.ratio g

full_name: Dilation.ratioHom
code: /-- `Dilation.ratio` as a monoid homomorphism from `α →ᵈ α` to `ℝ≥0`. -/
@[simps]
def ratioHom : (α →ᵈ α) →* ℝ≥0 
goal: (α →ᵈ α) →* ℝ≥0

full_name: Dilation.ratioHom_apply
code: /-- `Dilation.ratio` as a monoid homomorphism from `α →ᵈ α` to `ℝ≥0`. -/
@[simps]
def ratioHom : (α →ᵈ α) →* ℝ≥0 
goal: Dilation.ratioHom f = Dilation.ratio f

full_name: Dilation.ratio_pow
code: @[simp]
theorem ratio_pow (f : α →ᵈ α) (n : ℕ) : ratio (f ^ n) = ratio f ^ n 
goal: Dilation.ratio (f ^ n) = Dilation.ratio f ^ n

full_name: Dilation.cancel_right
code: @[simp]
theorem cancel_right {g₁ g₂ : β →ᵈ γ} {f : α →ᵈ β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: Dilation.cancel_left
code: @[simp]
theorem cancel_left {g : β →ᵈ γ} {f₁ f₂ : α →ᵈ β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: Dilation.uniformInducing
code: /-- A dilation from a metric space is a uniform inducing map -/
protected theorem uniformInducing : UniformInducing (f : α → β) 
goal: UniformInducing ⇑f

full_name: Dilation.tendsto_nhds_iff
code: theorem tendsto_nhds_iff {ι : Type*} {g : ι → α} {a : Filter ι} {b : α} :
    Filter.Tendsto g a (𝓝 b) ↔ Filter.Tendsto ((f : α → β) ∘ g) a (𝓝 (f b)) 
goal: Filter.Tendsto g a (𝓝 b) ↔ Filter.Tendsto (⇑f ∘ g) a (𝓝 (f b))

full_name: Dilation.toContinuous
code: /-- A dilation is continuous. -/
theorem toContinuous : Continuous (f : α → β) 
goal: Continuous ⇑f

full_name: Dilation.ediam_image
code: /-- Dilations scale the diameter by `ratio f` in pseudoemetric spaces. -/
theorem ediam_image (s : Set α) : EMetric.diam ((f : α → β) '' s) = ratio f * EMetric.diam s 
goal: EMetric.diam (⇑f '' s) = ↑(Dilation.ratio f) * EMetric.diam s

full_name: Dilation.ediam_range
code: /-- A dilation scales the diameter of the range by `ratio f`. -/
theorem ediam_range : EMetric.diam (range (f : α → β)) = ratio f * EMetric.diam (univ : Set α) 
goal: EMetric.diam (Set.range ⇑f) = ↑(Dilation.ratio f) * EMetric.diam Set.univ

full_name: Dilation.mapsTo_emetric_ball
code: /-- A dilation maps balls to balls and scales the radius by `ratio f`. -/
theorem mapsTo_emetric_ball (x : α) (r : ℝ≥0∞) :
    MapsTo (f : α → β) (EMetric.ball x r) (EMetric.ball (f x) (ratio f * r)) 
goal: Set.MapsTo (⇑f) (EMetric.ball x r) (EMetric.ball (f x) (↑(Dilation.ratio f) * r))

full_name: Dilation.mapsTo_emetric_closedBall
code: /-- A dilation maps closed balls to closed balls and scales the radius by `ratio f`. -/
theorem mapsTo_emetric_closedBall (x : α) (r' : ℝ≥0∞) :
    MapsTo (f : α → β) (EMetric.closedBall x r') (EMetric.closedBall (f x) (ratio f * r')) 
goal: Set.MapsTo (⇑f) (EMetric.closedBall x r') (EMetric.closedBall (f x) (↑(Dilation.ratio f) * r'))

full_name: Dilation.comp_continuousOn_iff
code: theorem comp_continuousOn_iff {γ} [TopologicalSpace γ] {g : γ → α} {s : Set γ} :
    ContinuousOn ((f : α → β) ∘ g) s ↔ ContinuousOn g s 
goal: ContinuousOn (⇑f ∘ g) s ↔ ContinuousOn g s

full_name: Dilation.comp_continuous_iff
code: theorem comp_continuous_iff {γ} [TopologicalSpace γ] {g : γ → α} :
    Continuous ((f : α → β) ∘ g) ↔ Continuous g 
goal: Continuous (⇑f ∘ g) ↔ Continuous g

full_name: Dilation.uniformEmbedding
code: /-- A dilation from a metric space is a uniform embedding -/
protected theorem uniformEmbedding [PseudoEMetricSpace β] [DilationClass F α β] (f : F) :
    UniformEmbedding f 
goal: UniformEmbedding ⇑f

full_name: Dilation.embedding
code: /-- A dilation from a metric space is an embedding -/
protected theorem embedding [PseudoEMetricSpace β] [DilationClass F α β] (f : F) :
    Embedding (f : α → β) 
goal: Embedding ⇑f

full_name: Dilation.closedEmbedding
code: /-- A dilation from a complete emetric space is a closed embedding -/
protected theorem closedEmbedding [CompleteSpace α] [EMetricSpace β] [DilationClass F α β] (f : F) :
    ClosedEmbedding f 
goal: ClosedEmbedding ⇑f

full_name: Dilation.ratio_comp
code: /-- Ratio of the composition `g.comp f` of two dilations is the product of their ratios. We assume
that the domain `α` of `f` is a nontrivial metric space, otherwise
`Dilation.ratio f = Dilation.ratio (g.comp f) = 1` but `Dilation.ratio g` may have any value.

See also `Dilation.ratio_comp'` for a version that works for more general spaces. -/
@[simp]
theorem ratio_comp [MetricSpace α] [Nontrivial α] [PseudoEMetricSpace β]
    [PseudoEMetricSpace γ] {g : β →ᵈ γ} {f : α →ᵈ β} : ratio (g.comp f) = ratio g * ratio f 
goal: Dilation.ratio (g.comp f) = Dilation.ratio g * Dilation.ratio f

full_name: Dilation.diam_image
code: /-- A dilation scales the diameter by `ratio f` in pseudometric spaces. -/
theorem diam_image (s : Set α) : Metric.diam ((f : α → β) '' s) = ratio f * Metric.diam s 
goal: Metric.diam (⇑f '' s) = ↑(Dilation.ratio f) * Metric.diam s

full_name: Dilation.diam_range
code: theorem diam_range : Metric.diam (range (f : α → β)) = ratio f * Metric.diam (univ : Set α) 
goal: Metric.diam (Set.range ⇑f) = ↑(Dilation.ratio f) * Metric.diam Set.univ

full_name: Dilation.mapsTo_ball
code: /-- A dilation maps balls to balls and scales the radius by `ratio f`. -/
theorem mapsTo_ball (x : α) (r' : ℝ) :
    MapsTo (f : α → β) (Metric.ball x r') (Metric.ball (f x) (ratio f * r')) 
goal: Set.MapsTo (⇑f) (Metric.ball x r') (Metric.ball (f x) (↑(Dilation.ratio f) * r'))

full_name: Dilation.mapsTo_sphere
code: /-- A dilation maps spheres to spheres and scales the radius by `ratio f`. -/
theorem mapsTo_sphere (x : α) (r' : ℝ) :
    MapsTo (f : α → β) (Metric.sphere x r') (Metric.sphere (f x) (ratio f * r')) 
goal: Set.MapsTo (⇑f) (Metric.sphere x r') (Metric.sphere (f x) (↑(Dilation.ratio f) * r'))

full_name: Dilation.mapsTo_closedBall
code: /-- A dilation maps closed balls to closed balls and scales the radius by `ratio f`. -/
theorem mapsTo_closedBall (x : α) (r' : ℝ) :
    MapsTo (f : α → β) (Metric.closedBall x r') (Metric.closedBall (f x) (ratio f * r')) 
goal: Set.MapsTo (⇑f) (Metric.closedBall x r') (Metric.closedBall (f x) (↑(Dilation.ratio f) * r'))

full_name: Dilation.tendsto_cobounded
code: lemma tendsto_cobounded : Filter.Tendsto f (cobounded α) (cobounded β) 
goal: Filter.Tendsto (⇑f) (Bornology.cobounded α) (Bornology.cobounded β)

full_name: Dilation.comap_cobounded
code: @[simp]
lemma comap_cobounded : Filter.comap f (cobounded β) = cobounded α 
goal: Filter.comap (⇑f) (Bornology.cobounded β) = Bornology.cobounded α