File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

full_name: AntilipschitzWith
code: /-- We say that `f : α → β` is `AntilipschitzWith K` if for any two points `x`, `y` we have
`edist x y ≤ K * edist (f x) (f y)`. -/
def AntilipschitzWith [PseudoEMetricSpace α] [PseudoEMetricSpace β] (K : ℝ≥0) (f : α → β) 
goal: Prop

full_name: AntilipschitzWith.edist_lt_top
code: theorem AntilipschitzWith.edist_lt_top [PseudoEMetricSpace α] [PseudoMetricSpace β] {K : ℝ≥0}
    {f : α → β} (h : AntilipschitzWith K f) (x y : α) : edist x y < ⊤ 
goal: edist x y < ⊤

full_name: AntilipschitzWith.edist_ne_top
code: theorem AntilipschitzWith.edist_ne_top [PseudoEMetricSpace α] [PseudoMetricSpace β] {K : ℝ≥0}
    {f : α → β} (h : AntilipschitzWith K f) (x y : α) : edist x y ≠ ⊤ 
goal: edist x y ≠ ⊤

full_name: antilipschitzWith_iff_le_mul_nndist
code: theorem antilipschitzWith_iff_le_mul_nndist :
    AntilipschitzWith K f ↔ ∀ x y, nndist x y ≤ K * nndist (f x) (f y) 
goal: AntilipschitzWith K f ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)

full_name: antilipschitzWith_iff_le_mul_dist
code: theorem antilipschitzWith_iff_le_mul_dist :
    AntilipschitzWith K f ↔ ∀ x y, dist x y ≤ K * dist (f x) (f y) 
goal: AntilipschitzWith K f ↔ ∀ (x y : α), dist x y ≤ ↑K * dist (f x) (f y)

full_name: AntilipschitzWith.mul_le_nndist
code: theorem mul_le_nndist (hf : AntilipschitzWith K f) (x y : α) :
    K⁻¹ * nndist x y ≤ nndist (f x) (f y) 
goal: K⁻¹ * nndist x y ≤ nndist (f x) (f y)

full_name: AntilipschitzWith.mul_le_dist
code: theorem mul_le_dist (hf : AntilipschitzWith K f) (x y : α) :
    (K⁻¹ * dist x y : ℝ) ≤ dist (f x) (f y) 
goal: ↑K⁻¹ * dist x y ≤ dist (f x) (f y)

full_name: AntilipschitzWith.k
code: /-- Extract the constant from `hf : AntilipschitzWith K f`. This is useful, e.g.,
if `K` is given by a long formula, and we want to reuse this value. -/
@[nolint unusedArguments]
protected def k (_hf : AntilipschitzWith K f) : ℝ≥0 
goal: ℝ≥0

full_name: AntilipschitzWith.injective
code: protected theorem injective {α : Type*} {β : Type*} [EMetricSpace α] [PseudoEMetricSpace β]
    {K : ℝ≥0} {f : α → β} (hf : AntilipschitzWith K f) : Function.Injective f 
goal: Function.Injective f

full_name: AntilipschitzWith.mul_le_edist
code: theorem mul_le_edist (hf : AntilipschitzWith K f) (x y : α) :
    (K : ℝ≥0∞)⁻¹ * edist x y ≤ edist (f x) (f y) 
goal: (↑K)⁻¹ * edist x y ≤ edist (f x) (f y)

full_name: AntilipschitzWith.ediam_preimage_le
code: theorem ediam_preimage_le (hf : AntilipschitzWith K f) (s : Set β) : diam (f ⁻¹' s) ≤ K * diam s 
goal: EMetric.diam (f ⁻¹' s) ≤ ↑K * EMetric.diam s

full_name: AntilipschitzWith.le_mul_ediam_image
code: theorem le_mul_ediam_image (hf : AntilipschitzWith K f) (s : Set α) : diam s ≤ K * diam (f '' s) 
goal: EMetric.diam s ≤ ↑K * EMetric.diam (f '' s)

full_name: AntilipschitzWith.id
code: protected theorem id : AntilipschitzWith 1 (id : α → α) 
goal: AntilipschitzWith 1 id

full_name: AntilipschitzWith.comp
code: theorem comp {Kg : ℝ≥0} {g : β → γ} (hg : AntilipschitzWith Kg g) {Kf : ℝ≥0} {f : α → β}
    (hf : AntilipschitzWith Kf f) : AntilipschitzWith (Kf * Kg) (g ∘ f) 
goal: AntilipschitzWith (Kf * Kg) (g ∘ f)

full_name: AntilipschitzWith.restrict
code: theorem restrict (hf : AntilipschitzWith K f) (s : Set α) : AntilipschitzWith K (s.restrict f) 
goal: AntilipschitzWith K (s.restrict f)

full_name: AntilipschitzWith.codRestrict
code: theorem codRestrict (hf : AntilipschitzWith K f) {s : Set β} (hs : ∀ x, f x ∈ s) :
    AntilipschitzWith K (s.codRestrict f hs) 
goal: AntilipschitzWith K (Set.codRestrict f s hs)

full_name: AntilipschitzWith.to_rightInvOn'
code: theorem to_rightInvOn' {s : Set α} (hf : AntilipschitzWith K (s.restrict f)) {g : β → α}
    {t : Set β} (g_maps : MapsTo g t s) (g_inv : RightInvOn g f t) :
    LipschitzWith K (t.restrict g) 
goal: LipschitzWith K (t.restrict g)

full_name: AntilipschitzWith.to_rightInvOn
code: theorem to_rightInvOn (hf : AntilipschitzWith K f) {g : β → α} {t : Set β} (h : RightInvOn g f t) :
    LipschitzWith K (t.restrict g) 
goal: LipschitzWith K (t.restrict g)

full_name: AntilipschitzWith.to_rightInverse
code: theorem to_rightInverse (hf : AntilipschitzWith K f) {g : β → α} (hg : Function.RightInverse g f) :
    LipschitzWith K g 
goal: LipschitzWith K g

full_name: AntilipschitzWith.comap_uniformity_le
code: theorem comap_uniformity_le (hf : AntilipschitzWith K f) : (𝓤 β).comap (Prod.map f f) ≤ 𝓤 α 
goal: Filter.comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α

full_name: AntilipschitzWith.uniformInducing
code: protected theorem uniformInducing (hf : AntilipschitzWith K f) (hfc : UniformContinuous f) :
    UniformInducing f 
goal: UniformInducing f

full_name: AntilipschitzWith.uniformEmbedding
code: protected theorem uniformEmbedding {α : Type*} {β : Type*} [EMetricSpace α] [PseudoEMetricSpace β]
    {K : ℝ≥0} {f : α → β} (hf : AntilipschitzWith K f) (hfc : UniformContinuous f) :
    UniformEmbedding f 
goal: UniformEmbedding f

full_name: AntilipschitzWith.isComplete_range
code: theorem isComplete_range [CompleteSpace α] (hf : AntilipschitzWith K f)
    (hfc : UniformContinuous f) : IsComplete (range f) 
goal: IsComplete (Set.range f)

full_name: AntilipschitzWith.isClosed_range
code: theorem isClosed_range {α β : Type*} [PseudoEMetricSpace α] [EMetricSpace β] [CompleteSpace α]
    {f : α → β} {K : ℝ≥0} (hf : AntilipschitzWith K f) (hfc : UniformContinuous f) :
    IsClosed (range f) 
goal: IsClosed (Set.range f)

full_name: AntilipschitzWith.closedEmbedding
code: theorem closedEmbedding {α : Type*} {β : Type*} [EMetricSpace α] [EMetricSpace β] {K : ℝ≥0}
    {f : α → β} [CompleteSpace α] (hf : AntilipschitzWith K f) (hfc : UniformContinuous f) :
    ClosedEmbedding f 
goal: ClosedEmbedding f

full_name: AntilipschitzWith.subtype_coe
code: theorem subtype_coe (s : Set α) : AntilipschitzWith 1 ((↑) : s → α) 
goal: AntilipschitzWith 1 Subtype.val

full_name: AntilipschitzWith.of_subsingleton
code: @[nontriviality] -- Porting note: added `nontriviality`
theorem of_subsingleton [Subsingleton α] {K : ℝ≥0} : AntilipschitzWith K f 
goal: AntilipschitzWith K f

full_name: AntilipschitzWith.subsingleton
code: /-- If `f : α → β` is `0`-antilipschitz, then `α` is a `subsingleton`. -/
protected theorem subsingleton {α β} [EMetricSpace α] [PseudoEMetricSpace β] {f : α → β}
    (h : AntilipschitzWith 0 f) : Subsingleton α 
goal: Subsingleton α

full_name: AntilipschitzWith.isBounded_preimage
code: theorem isBounded_preimage (hf : AntilipschitzWith K f) {s : Set β} (hs : IsBounded s) :
    IsBounded (f ⁻¹' s) 
goal: Bornology.IsBounded (f ⁻¹' s)

full_name: AntilipschitzWith.tendsto_cobounded
code: theorem tendsto_cobounded (hf : AntilipschitzWith K f) : Tendsto f (cobounded α) (cobounded β) 
goal: Filter.Tendsto f (Bornology.cobounded α) (Bornology.cobounded β)

full_name: AntilipschitzWith.properSpace
code: /-- The image of a proper space under an expanding onto map is proper. -/
protected theorem properSpace {α : Type*} [MetricSpace α] {K : ℝ≥0} {f : α → β} [ProperSpace α]
    (hK : AntilipschitzWith K f) (f_cont : Continuous f) (hf : Function.Surjective f) :
    ProperSpace β 
goal: ProperSpace β

full_name: AntilipschitzWith.isBounded_of_image2_left
code: theorem isBounded_of_image2_left (f : α → β → γ) {K₁ : ℝ≥0}
    (hf : ∀ b, AntilipschitzWith K₁ fun a => f a b) {s : Set α} {t : Set β}
    (hst : IsBounded (Set.image2 f s t)) : IsBounded s ∨ IsBounded t 
goal: Bornology.IsBounded s ∨ Bornology.IsBounded t

full_name: AntilipschitzWith.isBounded_of_image2_right
code: theorem isBounded_of_image2_right {f : α → β → γ} {K₂ : ℝ≥0} (hf : ∀ a, AntilipschitzWith K₂ (f a))
    {s : Set α} {t : Set β} (hst : IsBounded (Set.image2 f s t)) : IsBounded s ∨ IsBounded t 
goal: Bornology.IsBounded s ∨ Bornology.IsBounded t

full_name: LipschitzWith.to_rightInverse
code: theorem LipschitzWith.to_rightInverse [PseudoEMetricSpace α] [PseudoEMetricSpace β] {K : ℝ≥0}
    {f : α → β} (hf : LipschitzWith K f) {g : β → α} (hg : Function.RightInverse g f) :
    AntilipschitzWith K g 
goal: AntilipschitzWith K g

full_name: LipschitzWith.properSpace
code: /-- The preimage of a proper space under a Lipschitz homeomorphism is proper. -/
protected theorem LipschitzWith.properSpace [PseudoMetricSpace α] [MetricSpace β] [ProperSpace β]
    {K : ℝ≥0} {f : α ≃ₜ β} (hK : LipschitzWith K f) : ProperSpace α 
goal: ProperSpace α