File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

full_name: PseudoMetricSpace.induced
code: /-- Pseudometric space structure pulled back by a function. -/
abbrev PseudoMetricSpace.induced {α β} (f : α → β) (m : PseudoMetricSpace β) :
    PseudoMetricSpace α 
goal: PseudoMetricSpace α

full_name: Inducing.comapPseudoMetricSpace
code: /-- Pull back a pseudometric space structure by an inducing map. This is a version of
`PseudoMetricSpace.induced` useful in case if the domain already has a `TopologicalSpace`
structure. -/
def Inducing.comapPseudoMetricSpace {α β} [TopologicalSpace α] [m : PseudoMetricSpace β] {f : α → β}
    (hf : Inducing f) : PseudoMetricSpace α 
goal: PseudoMetricSpace α

full_name: UniformInducing.comapPseudoMetricSpace
code: /-- Pull back a pseudometric space structure by a uniform inducing map. This is a version of
`PseudoMetricSpace.induced` useful in case if the domain already has a `UniformSpace`
structure. -/
def UniformInducing.comapPseudoMetricSpace {α β} [UniformSpace α] [m : PseudoMetricSpace β]
    (f : α → β) (h : UniformInducing f) : PseudoMetricSpace α 
goal: PseudoMetricSpace α

full_name: Subtype.pseudoMetricSpace
code: instance Subtype.pseudoMetricSpace {p : α → Prop} : PseudoMetricSpace (Subtype p) 
goal: PseudoMetricSpace (Subtype p)

full_name: Subtype.dist_eq
code: lemma Subtype.dist_eq {p : α → Prop} (x y : Subtype p) : dist x y = dist (x : α) y 
goal: dist x y = dist ↑x ↑y

full_name: Subtype.nndist_eq
code: lemma Subtype.nndist_eq {p : α → Prop} (x y : Subtype p) : nndist x y = nndist (x : α) y 
goal: nndist x y = nndist ↑x ↑y

full_name: MulOpposite.instPseudoMetricSpace
code: @[to_additive]
instance instPseudoMetricSpace : PseudoMetricSpace αᵐᵒᵖ 
goal: PseudoMetricSpace αᵐᵒᵖ

full_name: AddOpposite.instPseudoMetricSpace
code: @[to_additive]
instance instPseudoMetricSpace : PseudoMetricSpace αᵐᵒᵖ 
goal: PseudoMetricSpace αᵃᵒᵖ

full_name: AddOpposite.dist_unop
code: @[to_additive (attr := simp)]
lemma dist_unop (x y : αᵐᵒᵖ) : dist (unop x) (unop y) = dist x y 
goal: dist (AddOpposite.unop x) (AddOpposite.unop y) = dist x y

full_name: MulOpposite.dist_unop
code: @[to_additive (attr := simp)]
lemma dist_unop (x y : αᵐᵒᵖ) : dist (unop x) (unop y) = dist x y 
goal: dist (MulOpposite.unop x) (MulOpposite.unop y) = dist x y

full_name: AddOpposite.dist_op
code: @[to_additive (attr := simp)]
lemma dist_op (x y : α) : dist (op x) (op y) = dist x y 
goal: dist (AddOpposite.op x) (AddOpposite.op y) = dist x y

full_name: MulOpposite.dist_op
code: @[to_additive (attr := simp)]
lemma dist_op (x y : α) : dist (op x) (op y) = dist x y 
goal: dist (MulOpposite.op x) (MulOpposite.op y) = dist x y

full_name: AddOpposite.nndist_unop
code: @[to_additive (attr := simp)]
lemma nndist_unop (x y : αᵐᵒᵖ) : nndist (unop x) (unop y) = nndist x y 
goal: nndist (AddOpposite.unop x) (AddOpposite.unop y) = nndist x y

full_name: MulOpposite.nndist_unop
code: @[to_additive (attr := simp)]
lemma nndist_unop (x y : αᵐᵒᵖ) : nndist (unop x) (unop y) = nndist x y 
goal: nndist (MulOpposite.unop x) (MulOpposite.unop y) = nndist x y

full_name: AddOpposite.nndist_op
code: @[to_additive (attr := simp)]
lemma nndist_op (x y : α) : nndist (op x) (op y) = nndist x y 
goal: nndist (AddOpposite.op x) (AddOpposite.op y) = nndist x y

full_name: MulOpposite.nndist_op
code: @[to_additive (attr := simp)]
lemma nndist_op (x y : α) : nndist (op x) (op y) = nndist x y 
goal: nndist (MulOpposite.op x) (MulOpposite.op y) = nndist x y

full_name: instPseudoMetricSpaceNNReal
code: instance : PseudoMetricSpace ℝ≥0 
goal: PseudoMetricSpace ℝ≥0

full_name: NNReal.dist_eq
code: lemma NNReal.dist_eq (a b : ℝ≥0) : dist a b = |(a : ℝ) - b| 
goal: dist a b = |↑a - ↑b|

full_name: NNReal.nndist_eq
code: lemma NNReal.nndist_eq (a b : ℝ≥0) : nndist a b = max (a - b) (b - a) 
goal: nndist a b = max (a - b) (b - a)

full_name: NNReal.nndist_zero_eq_val
code: @[simp]
lemma NNReal.nndist_zero_eq_val (z : ℝ≥0) : nndist 0 z = z 
goal: nndist 0 z = z

full_name: NNReal.nndist_zero_eq_val'
code: @[simp]
lemma NNReal.nndist_zero_eq_val' (z : ℝ≥0) : nndist z 0 = z 
goal: nndist z 0 = z

full_name: NNReal.le_add_nndist
code: lemma NNReal.le_add_nndist (a b : ℝ≥0) : a ≤ b + nndist a b 
goal: a ≤ b + nndist a b

full_name: NNReal.ball_zero_eq_Ico'
code: lemma NNReal.ball_zero_eq_Ico' (c : ℝ≥0) :
    Metric.ball (0 : ℝ≥0) c.toReal = Set.Ico 0 c 
goal: Metric.ball 0 ↑c = Set.Ico 0 c

full_name: NNReal.ball_zero_eq_Ico
code: lemma NNReal.ball_zero_eq_Ico (c : ℝ) :
    Metric.ball (0 : ℝ≥0) c = Set.Ico 0 c.toNNReal 
goal: Metric.ball 0 c = Set.Ico 0 c.toNNReal

full_name: NNReal.closedBall_zero_eq_Icc'
code: lemma NNReal.closedBall_zero_eq_Icc' (c : ℝ≥0) :
    Metric.closedBall (0 : ℝ≥0) c.toReal = Set.Icc 0 c 
goal: Metric.closedBall 0 ↑c = Set.Icc 0 c

full_name: NNReal.closedBall_zero_eq_Icc
code: lemma NNReal.closedBall_zero_eq_Icc {c : ℝ} (c_nn : 0 ≤ c) :
    Metric.closedBall (0 : ℝ≥0) c = Set.Icc 0 c.toNNReal 
goal: Metric.closedBall 0 c = Set.Icc 0 c.toNNReal

full_name: ULift.instPseudoMetricSpace
code: instance : PseudoMetricSpace (ULift β) 
goal: PseudoMetricSpace (ULift.{u_3, u_2} β)

full_name: ULift.dist_eq
code: lemma dist_eq (x y : ULift β) : dist x y = dist x.down y.down 
goal: dist x y = dist x.down y.down

full_name: ULift.nndist_eq
code: lemma nndist_eq (x y : ULift β) : nndist x y = nndist x.down y.down 
goal: nndist x y = nndist x.down y.down

full_name: ULift.dist_up_up
code: @[simp] lemma dist_up_up (x y : β) : dist (ULift.up x) (ULift.up y) = dist x y 
goal: dist { down := x } { down := y } = dist x y

full_name: ULift.nndist_up_up
code: @[simp] lemma nndist_up_up (x y : β) : nndist (ULift.up x) (ULift.up y) = nndist x y 
goal: nndist { down := x } { down := y } = nndist x y

full_name: Prod.pseudoMetricSpaceMax
code: instance Prod.pseudoMetricSpaceMax : PseudoMetricSpace (α × β) 
goal: PseudoMetricSpace (α × β)

full_name: Prod.dist_eq
code: lemma Prod.dist_eq {x y : α × β} : dist x y = max (dist x.1 y.1) (dist x.2 y.2) 
goal: dist x y = max (dist x.1 y.1) (dist x.2 y.2)

full_name: dist_prod_same_left
code: @[simp]
lemma dist_prod_same_left {x : α} {y₁ y₂ : β} : dist (x, y₁) (x, y₂) = dist y₁ y₂ 
goal: dist (x, y₁) (x, y₂) = dist y₁ y₂

full_name: dist_prod_same_right
code: @[simp]
lemma dist_prod_same_right {x₁ x₂ : α} {y : β} : dist (x₁, y) (x₂, y) = dist x₁ x₂ 
goal: dist (x₁, y) (x₂, y) = dist x₁ x₂

full_name: ball_prod_same
code: lemma ball_prod_same (x : α) (y : β) (r : ℝ) : ball x r ×ˢ ball y r = ball (x, y) r 
goal: Metric.ball x r ×ˢ Metric.ball y r = Metric.ball (x, y) r

full_name: closedBall_prod_same
code: lemma closedBall_prod_same (x : α) (y : β) (r : ℝ) :
    closedBall x r ×ˢ closedBall y r = closedBall (x, y) r 
goal: Metric.closedBall x r ×ˢ Metric.closedBall y r = Metric.closedBall (x, y) r

full_name: sphere_prod
code: lemma sphere_prod (x : α × β) (r : ℝ) :
    sphere x r = sphere x.1 r ×ˢ closedBall x.2 r ∪ closedBall x.1 r ×ˢ sphere x.2 r 
goal: Metric.sphere x r = Metric.sphere x.1 r ×ˢ Metric.closedBall x.2 r ∪ Metric.closedBall x.1 r ×ˢ Metric.sphere x.2 r

full_name: uniformContinuous_dist
code: lemma uniformContinuous_dist : UniformContinuous fun p : α × α => dist p.1 p.2 
goal: UniformContinuous fun p => dist p.1 p.2

full_name: UniformContinuous.dist
code: protected lemma UniformContinuous.dist [UniformSpace β] {f g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun b => dist (f b) (g b) 
goal: UniformContinuous fun b => dist (f b) (g b)

full_name: continuous_dist
code: @[continuity]
lemma continuous_dist : Continuous fun p : α × α ↦ dist p.1 p.2 
goal: Continuous fun p => dist p.1 p.2

full_name: Continuous.dist
code: @[continuity, fun_prop]
protected lemma Continuous.dist [TopologicalSpace β] {f g : β → α} (hf : Continuous f)
    (hg : Continuous g) : Continuous fun b => dist (f b) (g b) 
goal: Continuous fun b => dist (f b) (g b)

full_name: Filter.Tendsto.dist
code: protected lemma Filter.Tendsto.dist {f g : β → α} {x : Filter β} {a b : α}
    (hf : Tendsto f x (𝓝 a)) (hg : Tendsto g x (𝓝 b)) :
    Tendsto (fun x => dist (f x) (g x)) x (𝓝 (dist a b)) 
goal: Filter.Tendsto (fun x => dist (f x) (g x)) x (𝓝 (dist a b))

full_name: continuous_iff_continuous_dist
code: lemma continuous_iff_continuous_dist [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ Continuous fun x : β × β => dist (f x.1) (f x.2) 
goal: Continuous f ↔ Continuous fun x => dist (f x.1) (f x.2)

full_name: uniformContinuous_nndist
code: lemma uniformContinuous_nndist : UniformContinuous fun p : α × α => nndist p.1 p.2 
goal: UniformContinuous fun p => nndist p.1 p.2

full_name: UniformContinuous.nndist
code: protected lemma UniformContinuous.nndist [UniformSpace β] {f g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun b => nndist (f b) (g b) 
goal: UniformContinuous fun b => nndist (f b) (g b)

full_name: continuous_nndist
code: lemma continuous_nndist : Continuous fun p : α × α => nndist p.1 p.2 
goal: Continuous fun p => nndist p.1 p.2

full_name: Continuous.nndist
code: @[fun_prop]
protected lemma Continuous.nndist [TopologicalSpace β] {f g : β → α} (hf : Continuous f)
    (hg : Continuous g) : Continuous fun b => nndist (f b) (g b) 
goal: Continuous fun b => nndist (f b) (g b)

full_name: Filter.Tendsto.nndist
code: protected lemma Filter.Tendsto.nndist {f g : β → α} {x : Filter β} {a b : α}
    (hf : Tendsto f x (𝓝 a)) (hg : Tendsto g x (𝓝 b)) :
    Tendsto (fun x => nndist (f x) (g x)) x (𝓝 (nndist a b)) 
goal: Filter.Tendsto (fun x => nndist (f x) (g x)) x (𝓝 (nndist a b))

full_name: pseudoMetricSpacePi
code: /-- A finite product of pseudometric spaces is a pseudometric space, with the sup distance. -/
instance pseudoMetricSpacePi : PseudoMetricSpace (∀ b, π b) 
goal: PseudoMetricSpace ((b : β) → π b)

full_name: nndist_pi_def
code: lemma nndist_pi_def (f g : ∀ b, π b) : nndist f g = sup univ fun b => nndist (f b) (g b) 
goal: nndist f g = Finset.univ.sup fun b => nndist (f b) (g b)

full_name: dist_pi_def
code: lemma dist_pi_def (f g : ∀ b, π b) : dist f g = (sup univ fun b => nndist (f b) (g b) : ℝ≥0) 
goal: dist f g = ↑(Finset.univ.sup fun b => nndist (f b) (g b))

full_name: nndist_pi_le_iff
code: lemma nndist_pi_le_iff {f g : ∀ b, π b} {r : ℝ≥0} :
    nndist f g ≤ r ↔ ∀ b, nndist (f b) (g b) ≤ r 
goal: nndist f g ≤ r ↔ ∀ (b : β), nndist (f b) (g b) ≤ r

full_name: nndist_pi_lt_iff
code: lemma nndist_pi_lt_iff {f g : ∀ b, π b} {r : ℝ≥0} (hr : 0 < r) :
    nndist f g < r ↔ ∀ b, nndist (f b) (g b) < r 
goal: nndist f g < r ↔ ∀ (b : β), nndist (f b) (g b) < r

full_name: nndist_pi_eq_iff
code: lemma nndist_pi_eq_iff {f g : ∀ b, π b} {r : ℝ≥0} (hr : 0 < r) :
    nndist f g = r ↔ (∃ i, nndist (f i) (g i) = r) ∧ ∀ b, nndist (f b) (g b) ≤ r 
goal: nndist f g = r ↔ (∃ i, nndist (f i) (g i) = r) ∧ ∀ (b : β), nndist (f b) (g b) ≤ r

full_name: dist_pi_lt_iff
code: lemma dist_pi_lt_iff {f g : ∀ b, π b} {r : ℝ} (hr : 0 < r) :
    dist f g < r ↔ ∀ b, dist (f b) (g b) < r 
goal: dist f g < r ↔ ∀ (b : β), dist (f b) (g b) < r

full_name: dist_pi_le_iff
code: lemma dist_pi_le_iff {f g : ∀ b, π b} {r : ℝ} (hr : 0 ≤ r) :
    dist f g ≤ r ↔ ∀ b, dist (f b) (g b) ≤ r 
goal: dist f g ≤ r ↔ ∀ (b : β), dist (f b) (g b) ≤ r

full_name: dist_pi_eq_iff
code: lemma dist_pi_eq_iff {f g : ∀ b, π b} {r : ℝ} (hr : 0 < r) :
    dist f g = r ↔ (∃ i, dist (f i) (g i) = r) ∧ ∀ b, dist (f b) (g b) ≤ r 
goal: dist f g = r ↔ (∃ i, dist (f i) (g i) = r) ∧ ∀ (b : β), dist (f b) (g b) ≤ r

full_name: dist_pi_le_iff'
code: lemma dist_pi_le_iff' [Nonempty β] {f g : ∀ b, π b} {r : ℝ} :
    dist f g ≤ r ↔ ∀ b, dist (f b) (g b) ≤ r 
goal: dist f g ≤ r ↔ ∀ (b : β), dist (f b) (g b) ≤ r

full_name: dist_pi_const_le
code: lemma dist_pi_const_le (a b : α) : (dist (fun _ : β => a) fun _ => b) ≤ dist a b 
goal: (dist (fun x => a) fun x => b) ≤ dist a b

full_name: nndist_pi_const_le
code: lemma nndist_pi_const_le (a b : α) : (nndist (fun _ : β => a) fun _ => b) ≤ nndist a b 
goal: (nndist (fun x => a) fun x => b) ≤ nndist a b

full_name: dist_pi_const
code: @[simp]
lemma dist_pi_const [Nonempty β] (a b : α) : (dist (fun _ : β => a) fun _ => b) = dist a b 
goal: (dist (fun x => a) fun x => b) = dist a b

full_name: nndist_pi_const
code: @[simp]
lemma nndist_pi_const [Nonempty β] (a b : α) : (nndist (fun _ : β => a) fun _ => b) = nndist a b 
goal: (nndist (fun x => a) fun x => b) = nndist a b

full_name: nndist_le_pi_nndist
code: lemma nndist_le_pi_nndist (f g : ∀ b, π b) (b : β) : nndist (f b) (g b) ≤ nndist f g 
goal: nndist (f b) (g b) ≤ nndist f g

full_name: dist_le_pi_dist
code: lemma dist_le_pi_dist (f g : ∀ b, π b) (b : β) : dist (f b) (g b) ≤ dist f g 
goal: dist (f b) (g b) ≤ dist f g

full_name: ball_pi
code: /-- An open ball in a product space is a product of open balls. See also `ball_pi'`
for a version assuming `Nonempty β` instead of `0 < r`. -/
lemma ball_pi (x : ∀ b, π b) {r : ℝ} (hr : 0 < r) :
    ball x r = Set.pi univ fun b => ball (x b) r 
goal: Metric.ball x r = Set.univ.pi fun b => Metric.ball (x b) r

full_name: ball_pi'
code: /-- An open ball in a product space is a product of open balls. See also `ball_pi`
for a version assuming `0 < r` instead of `Nonempty β`. -/
lemma ball_pi' [Nonempty β] (x : ∀ b, π b) (r : ℝ) :
    ball x r = Set.pi univ fun b => ball (x b) r 
goal: Metric.ball x r = Set.univ.pi fun b => Metric.ball (x b) r

full_name: closedBall_pi
code: /-- A closed ball in a product space is a product of closed balls. See also `closedBall_pi'`
for a version assuming `Nonempty β` instead of `0 ≤ r`. -/
lemma closedBall_pi (x : ∀ b, π b) {r : ℝ} (hr : 0 ≤ r) :
    closedBall x r = Set.pi univ fun b => closedBall (x b) r 
goal: Metric.closedBall x r = Set.univ.pi fun b => Metric.closedBall (x b) r

full_name: closedBall_pi'
code: /-- A closed ball in a product space is a product of closed balls. See also `closedBall_pi`
for a version assuming `0 ≤ r` instead of `Nonempty β`. -/
lemma closedBall_pi' [Nonempty β] (x : ∀ b, π b) (r : ℝ) :
    closedBall x r = Set.pi univ fun b => closedBall (x b) r 
goal: Metric.closedBall x r = Set.univ.pi fun b => Metric.closedBall (x b) r

full_name: sphere_pi
code: /-- A sphere in a product space is a union of spheres on each component restricted to the closed
ball. -/
lemma sphere_pi (x : ∀ b, π b) {r : ℝ} (h : 0 < r ∨ Nonempty β) :
    sphere x r = (⋃ i : β, Function.eval i ⁻¹' sphere (x i) r) ∩ closedBall x r 
goal: Metric.sphere x r = (⋃ i, Function.eval i ⁻¹' Metric.sphere (x i) r) ∩ Metric.closedBall x r

full_name: Fin.nndist_insertNth_insertNth
code: @[simp]
lemma Fin.nndist_insertNth_insertNth {n : ℕ} {α : Fin (n + 1) → Type*}
    [∀ i, PseudoMetricSpace (α i)] (i : Fin (n + 1)) (x y : α i) (f g : ∀ j, α (i.succAbove j)) :
    nndist (i.insertNth x f) (i.insertNth y g) = max (nndist x y) (nndist f g) 
goal: nndist (i.insertNth x f) (i.insertNth y g) = max (nndist x y) (nndist f g)

full_name: Fin.dist_insertNth_insertNth
code: @[simp]
lemma Fin.dist_insertNth_insertNth {n : ℕ} {α : Fin (n + 1) → Type*}
    [∀ i, PseudoMetricSpace (α i)] (i : Fin (n + 1)) (x y : α i) (f g : ∀ j, α (i.succAbove j)) :
    dist (i.insertNth x f) (i.insertNth y g) = max (dist x y) (dist f g) 
goal: dist (i.insertNth x f) (i.insertNth y g) = max (dist x y) (dist f g)

full_name: instPseudoMetricSpaceAdditive
code: instance : PseudoMetricSpace (Additive α) 
goal: PseudoMetricSpace (Additive α)

full_name: instPseudoMetricSpaceMultiplicative
code: instance : PseudoMetricSpace (Multiplicative α) 
goal: PseudoMetricSpace (Multiplicative α)

full_name: instPseudoMetricSpaceOrderDual
code: instance : PseudoMetricSpace αᵒᵈ 
goal: PseudoMetricSpace αᵒᵈ