File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

full_name: WithLp.zero_fst
code: @[simp]
theorem zero_fst : (0 : WithLp p (α × β)).fst = 0 
goal: 0.1 = 0

full_name: WithLp.zero_snd
code: @[simp]
theorem zero_snd : (0 : WithLp p (α × β)).snd = 0 
goal: 0.2 = 0

full_name: WithLp.add_fst
code: @[simp]
theorem add_fst : (x + y).fst = x.fst + y.fst 
goal: (x + y).1 = x.1 + y.1

full_name: WithLp.add_snd
code: @[simp]
theorem add_snd : (x + y).snd = x.snd + y.snd 
goal: (x + y).2 = x.2 + y.2

full_name: WithLp.sub_fst
code: @[simp]
theorem sub_fst : (x - y).fst = x.fst - y.fst 
goal: (x - y).1 = x.1 - y.1

full_name: WithLp.sub_snd
code: @[simp]
theorem sub_snd : (x - y).snd = x.snd - y.snd 
goal: (x - y).2 = x.2 - y.2

full_name: WithLp.neg_fst
code: @[simp]
theorem neg_fst : (-x).fst = -x.fst 
goal: (-x).1 = -x.1

full_name: WithLp.neg_snd
code: @[simp]
theorem neg_snd : (-x).snd = -x.snd 
goal: (-x).2 = -x.2

full_name: WithLp.smul_fst
code: @[simp]
theorem smul_fst : (c • x).fst = c • x.fst 
goal: (c • x).1 = c • x.1

full_name: WithLp.smul_snd
code: @[simp]
theorem smul_snd : (c • x).snd = c • x.snd 
goal: (c • x).2 = c • x.2

full_name: WithLp.equiv_fst
code: @[simp]
theorem equiv_fst (x : WithLp p (α × β)) : (WithLp.equiv p (α × β) x).fst = x.fst 
goal: ((WithLp.equiv p (α × β)) x).1 = x.1

full_name: WithLp.equiv_snd
code: @[simp]
theorem equiv_snd (x : WithLp p (α × β)) : (WithLp.equiv p (α × β) x).snd = x.snd 
goal: ((WithLp.equiv p (α × β)) x).2 = x.2

full_name: WithLp.equiv_symm_fst
code: @[simp]
theorem equiv_symm_fst (x : α × β) : ((WithLp.equiv p (α × β)).symm x).fst = x.fst 
goal: ((WithLp.equiv p (α × β)).symm x).1 = x.1

full_name: WithLp.equiv_symm_snd
code: @[simp]
theorem equiv_symm_snd (x : α × β) : ((WithLp.equiv p (α × β)).symm x).snd = x.snd 
goal: ((WithLp.equiv p (α × β)).symm x).2 = x.2

full_name: WithLp.instProdEDist
code: /-- Endowing the space `WithLp p (α × β)` with the `L^p` edistance. We register this instance
separate from `WithLp.instProdPseudoEMetric` since the latter requires the type class hypothesis
`[Fact (1 ≤ p)]` in order to prove the triangle inequality.

Registering this separately allows for a future emetric-like structure on `WithLp p (α × β)` for
`p < 1` satisfying a relaxed triangle inequality. The terminology for this varies throughout the
literature, but it is sometimes called a *quasi-metric* or *semi-metric*. -/
instance instProdEDist : EDist (WithLp p (α × β)) 
goal: EDist (WithLp p (α × β))

full_name: WithLp.prod_edist_eq_card
code: @[simp]
theorem prod_edist_eq_card (f g : WithLp 0 (α × β)) :
    edist f g =
      (if edist f.fst g.fst = 0 then 0 else 1) + (if edist f.snd g.snd = 0 then 0 else 1) 
goal: edist f g = (if edist f.1 g.1 = 0 then 0 else 1) + if edist f.2 g.2 = 0 then 0 else 1

full_name: WithLp.prod_edist_eq_add
code: theorem prod_edist_eq_add (hp : 0 < p.toReal) (f g : WithLp p (α × β)) :
    edist f g = (edist f.fst g.fst ^ p.toReal + edist f.snd g.snd ^ p.toReal) ^ (1 / p.toReal) 
goal: edist f g = (edist f.1 g.1 ^ p.toReal + edist f.2 g.2 ^ p.toReal) ^ (1 / p.toReal)

full_name: WithLp.prod_edist_eq_sup
code: theorem prod_edist_eq_sup (f g : WithLp ∞ (α × β)) :
    edist f g = edist f.fst g.fst ⊔ edist f.snd g.snd 
goal: edist f g = edist f.1 g.1 ⊔ edist f.2 g.2

full_name: WithLp.prod_edist_self
code: /-- The distance from one point to itself is always zero.

This holds independent of `p` and does not require `[Fact (1 ≤ p)]`. We keep it separate
from `WithLp.instProdPseudoEMetricSpace` so it can be used also for `p < 1`. -/
theorem prod_edist_self (f : WithLp p (α × β)) : edist f f = 0 
goal: edist f f = 0

full_name: WithLp.prod_edist_comm
code: /-- The distance is symmetric.

This holds independent of `p` and does not require `[Fact (1 ≤ p)]`. We keep it separate
from `WithLp.instProdPseudoEMetricSpace` so it can be used also for `p < 1`. -/
theorem prod_edist_comm (f g : WithLp p (α × β)) : edist f g = edist g f 
goal: edist f g = edist g f

full_name: WithLp.instProdDist
code: /-- Endowing the space `WithLp p (α × β)` with the `L^p` distance. We register this instance
separate from `WithLp.instProdPseudoMetricSpace` since the latter requires the type class hypothesis
`[Fact (1 ≤ p)]` in order to prove the triangle inequality.

Registering this separately allows for a future metric-like structure on `WithLp p (α × β)` for
`p < 1` satisfying a relaxed triangle inequality. The terminology for this varies throughout the
literature, but it is sometimes called a *quasi-metric* or *semi-metric*. -/
instance instProdDist : Dist (WithLp p (α × β)) 
goal: Dist (WithLp p (α × β))

full_name: WithLp.prod_dist_eq_card
code: theorem prod_dist_eq_card (f g : WithLp 0 (α × β)) : dist f g =
    (if dist f.fst g.fst = 0 then 0 else 1) + (if dist f.snd g.snd = 0 then 0 else 1) 
goal: dist f g = (if dist f.1 g.1 = 0 then 0 else 1) + if dist f.2 g.2 = 0 then 0 else 1

full_name: WithLp.prod_dist_eq_add
code: theorem prod_dist_eq_add (hp : 0 < p.toReal) (f g : WithLp p (α × β)) :
    dist f g = (dist f.fst g.fst ^ p.toReal + dist f.snd g.snd ^ p.toReal) ^ (1 / p.toReal) 
goal: dist f g = (dist f.1 g.1 ^ p.toReal + dist f.2 g.2 ^ p.toReal) ^ (1 / p.toReal)

full_name: WithLp.prod_dist_eq_sup
code: theorem prod_dist_eq_sup (f g : WithLp ∞ (α × β)) :
    dist f g = dist f.fst g.fst ⊔ dist f.snd g.snd 
goal: dist f g = dist f.1 g.1 ⊔ dist f.2 g.2

full_name: WithLp.instProdNorm
code: /-- Endowing the space `WithLp p (α × β)` with the `L^p` norm. We register this instance
separate from `WithLp.instProdSeminormedAddCommGroup` since the latter requires the type class
hypothesis `[Fact (1 ≤ p)]` in order to prove the triangle inequality.

Registering this separately allows for a future norm-like structure on `WithLp p (α × β)` for
`p < 1` satisfying a relaxed triangle inequality. These are called *quasi-norms*. -/
instance instProdNorm : Norm (WithLp p (α × β)) 
goal: Norm (WithLp p (α × β))

full_name: WithLp.prod_norm_eq_card
code: @[simp]
theorem prod_norm_eq_card (f : WithLp 0 (α × β)) :
    ‖f‖ = (if ‖f.fst‖ = 0 then 0 else 1) + (if ‖f.snd‖ = 0 then 0 else 1) 
goal: ‖f‖ = (if ‖f.1‖ = 0 then 0 else 1) + if ‖f.2‖ = 0 then 0 else 1

full_name: WithLp.prod_norm_eq_sup
code: theorem prod_norm_eq_sup (f : WithLp ∞ (α × β)) : ‖f‖ = ‖f.fst‖ ⊔ ‖f.snd‖ 
goal: ‖f‖ = ‖f.1‖ ⊔ ‖f.2‖

full_name: WithLp.prod_norm_eq_add
code: theorem prod_norm_eq_add (hp : 0 < p.toReal) (f : WithLp p (α × β)) :
    ‖f‖ = (‖f.fst‖ ^ p.toReal + ‖f.snd‖ ^ p.toReal) ^ (1 / p.toReal) 
goal: ‖f‖ = (‖f.1‖ ^ p.toReal + ‖f.2‖ ^ p.toReal) ^ (1 / p.toReal)

full_name: WithLp.prodPseudoEMetricAux
code: /-- Endowing the space `WithLp p (α × β)` with the `L^p` pseudoemetric structure. This definition is
not satisfactory, as it does not register the fact that the topology and the uniform structure
coincide with the product one. Therefore, we do not register it as an instance. Using this as a
temporary pseudoemetric space instance, we will show that the uniform structure is equal (but not
defeq) to the product one, and then register an instance in which we replace the uniform structure
by the product one using this pseudoemetric space and `PseudoEMetricSpace.replaceUniformity`. -/
def prodPseudoEMetricAux [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    PseudoEMetricSpace (WithLp p (α × β)) 
goal: PseudoEMetricSpace (WithLp p (α × β))

full_name: WithLp.prod_sup_edist_ne_top_aux
code: /-- An auxiliary lemma used twice in the proof of `WithLp.prodPseudoMetricAux` below. Not intended
for use outside this file. -/
theorem prod_sup_edist_ne_top_aux [PseudoMetricSpace α] [PseudoMetricSpace β]
    (f g : WithLp ∞ (α × β)) :
    edist f.fst g.fst ⊔ edist f.snd g.snd ≠ ⊤ 
goal: edist f.1 g.1 ⊔ edist f.2 g.2 ≠ ⊤

full_name: WithLp.prodPseudoMetricAux
code: /-- Endowing the space `WithLp p (α × β)` with the `L^p` pseudometric structure. This definition is
not satisfactory, as it does not register the fact that the topology, the uniform structure, and the
bornology coincide with the product ones. Therefore, we do not register it as an instance. Using
this as a temporary pseudoemetric space instance, we will show that the uniform structure is equal
(but not defeq) to the product one, and then register an instance in which we replace the uniform
structure and the bornology by the product ones using this pseudometric space,
`PseudoMetricSpace.replaceUniformity`, and `PseudoMetricSpace.replaceBornology`.

See note [reducible non-instances] -/
abbrev prodPseudoMetricAux [PseudoMetricSpace α] [PseudoMetricSpace β] :
    PseudoMetricSpace (WithLp p (α × β)) 
goal: PseudoMetricSpace (WithLp p (α × β))

full_name: WithLp.prod_lipschitzWith_equiv_aux
code: theorem prod_lipschitzWith_equiv_aux [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    LipschitzWith 1 (WithLp.equiv p (α × β)) 
goal: LipschitzWith 1 ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prod_antilipschitzWith_equiv_aux
code: theorem prod_antilipschitzWith_equiv_aux [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    AntilipschitzWith ((2 : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (α × β)) 
goal: AntilipschitzWith (2 ^ (1 / p).toReal) ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prod_aux_uniformity_eq
code: theorem prod_aux_uniformity_eq [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    𝓤 (WithLp p (α × β)) = 𝓤[instUniformSpaceProd] 
goal: 𝓤 (WithLp p (α × β)) = 𝓤 (α × β)

full_name: WithLp.prod_aux_cobounded_eq
code: theorem prod_aux_cobounded_eq [PseudoMetricSpace α] [PseudoMetricSpace β] :
    cobounded (WithLp p (α × β)) = @cobounded _ Prod.instBornology 
goal: Bornology.cobounded (WithLp p (α × β)) = Bornology.cobounded (α × β)

full_name: WithLp.instProdTopologicalSpace
code: instance instProdTopologicalSpace : TopologicalSpace (WithLp p (α × β)) 
goal: TopologicalSpace (WithLp p (α × β))

full_name: WithLp.prod_continuous_equiv
code: @[continuity]
theorem prod_continuous_equiv : Continuous (WithLp.equiv p (α × β)) 
goal: Continuous ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prod_continuous_equiv_symm
code: @[continuity]
theorem prod_continuous_equiv_symm : Continuous (WithLp.equiv p (α × β)).symm 
goal: Continuous ⇑(WithLp.equiv p (α × β)).symm

full_name: WithLp.instProdT0Space
code: instance instProdT0Space : T0Space (WithLp p (α × β)) 
goal: T0Space (WithLp p (α × β))

full_name: WithLp.instProdUniformSpace
code: instance instProdUniformSpace : UniformSpace (WithLp p (α × β)) 
goal: UniformSpace (WithLp p (α × β))

full_name: WithLp.prod_uniformContinuous_equiv
code: theorem prod_uniformContinuous_equiv : UniformContinuous (WithLp.equiv p (α × β)) 
goal: UniformContinuous ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prod_uniformContinuous_equiv_symm
code: theorem prod_uniformContinuous_equiv_symm : UniformContinuous (WithLp.equiv p (α × β)).symm 
goal: UniformContinuous ⇑(WithLp.equiv p (α × β)).symm

full_name: WithLp.instProdCompleteSpace
code: instance instProdCompleteSpace : CompleteSpace (WithLp p (α × β)) 
goal: CompleteSpace (WithLp p (α × β))

full_name: WithLp.instProdBornology
code: instance instProdBornology [Bornology α] [Bornology β] : Bornology (WithLp p (α × β)) 
goal: Bornology (WithLp p (α × β))

full_name: WithLp.prodContinuousLinearEquiv_symm_apply
code: /-- `WithLp.equiv` as a continuous linear equivalence. -/
@[simps! (config := .asFn) apply symm_apply]
protected def prodContinuousLinearEquiv : WithLp p (α × β) ≃L[𝕜] α × β 
goal: ⇑(WithLp.prodContinuousLinearEquiv p 𝕜 α β).symm = ⇑(WithLp.equiv p (α × β)).symm

full_name: WithLp.prodContinuousLinearEquiv_apply
code: /-- `WithLp.equiv` as a continuous linear equivalence. -/
@[simps! (config := .asFn) apply symm_apply]
protected def prodContinuousLinearEquiv : WithLp p (α × β) ≃L[𝕜] α × β 
goal: ⇑(WithLp.prodContinuousLinearEquiv p 𝕜 α β) = ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prodContinuousLinearEquiv
code: /-- `WithLp.equiv` as a continuous linear equivalence. -/
@[simps! (config := .asFn) apply symm_apply]
protected def prodContinuousLinearEquiv : WithLp p (α × β) ≃L[𝕜] α × β 
goal: WithLp p (α × β) ≃L[𝕜] α × β

full_name: WithLp.instProdPseudoEMetricSpace
code: /-- `PseudoEMetricSpace` instance on the product of two pseudoemetric spaces, using the
`L^p` pseudoedistance, and having as uniformity the product uniformity. -/
instance instProdPseudoEMetricSpace [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    PseudoEMetricSpace (WithLp p (α × β)) 
goal: PseudoEMetricSpace (WithLp p (α × β))

full_name: WithLp.instProdEMetricSpace
code: /-- `EMetricSpace` instance on the product of two emetric spaces, using the `L^p`
edistance, and having as uniformity the product uniformity. -/
instance instProdEMetricSpace [EMetricSpace α] [EMetricSpace β] : EMetricSpace (WithLp p (α × β)) 
goal: EMetricSpace (WithLp p (α × β))

full_name: WithLp.instProdPseudoMetricSpace
code: /-- `PseudoMetricSpace` instance on the product of two pseudometric spaces, using the
`L^p` distance, and having as uniformity the product uniformity. -/
instance instProdPseudoMetricSpace [PseudoMetricSpace α] [PseudoMetricSpace β] :
    PseudoMetricSpace (WithLp p (α × β)) 
goal: PseudoMetricSpace (WithLp p (α × β))

full_name: WithLp.instProdMetricSpace
code: /-- `MetricSpace` instance on the product of two metric spaces, using the `L^p` distance,
and having as uniformity the product uniformity. -/
instance instProdMetricSpace [MetricSpace α] [MetricSpace β] : MetricSpace (WithLp p (α × β)) 
goal: MetricSpace (WithLp p (α × β))

full_name: WithLp.prod_nndist_eq_add
code: theorem prod_nndist_eq_add [PseudoMetricSpace α] [PseudoMetricSpace β]
    (hp : p ≠ ∞) (x y : WithLp p (α × β)) :
    nndist x y = (nndist x.fst y.fst ^ p.toReal + nndist x.snd y.snd ^ p.toReal) ^ (1 / p.toReal) 
goal: p ≠ ⊤ →
  ∀ (x y : WithLp p (α × β)), nndist x y = (nndist x.1 y.1 ^ p.toReal + nndist x.2 y.2 ^ p.toReal) ^ (1 / p.toReal)

full_name: WithLp.prod_nndist_eq_sup
code: theorem prod_nndist_eq_sup [PseudoMetricSpace α] [PseudoMetricSpace β] (x y : WithLp ∞ (α × β)) :
    nndist x y = nndist x.fst y.fst ⊔ nndist x.snd y.snd 
goal: nndist x y = nndist x.1 y.1 ⊔ nndist x.2 y.2

full_name: WithLp.prod_lipschitzWith_equiv
code: theorem prod_lipschitzWith_equiv [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    LipschitzWith 1 (WithLp.equiv p (α × β)) 
goal: LipschitzWith 1 ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prod_antilipschitzWith_equiv
code: theorem prod_antilipschitzWith_equiv [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    AntilipschitzWith ((2 : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (α × β)) 
goal: AntilipschitzWith (2 ^ (1 / p).toReal) ⇑(WithLp.equiv p (α × β))

full_name: WithLp.prod_infty_equiv_isometry
code: theorem prod_infty_equiv_isometry [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    Isometry (WithLp.equiv ∞ (α × β)) 
goal: Isometry ⇑(WithLp.equiv ⊤ (α × β))

full_name: WithLp.instProdSeminormedAddCommGroup
code: /-- Seminormed group instance on the product of two normed groups, using the `L^p`
norm. -/
instance instProdSeminormedAddCommGroup [SeminormedAddCommGroup α] [SeminormedAddCommGroup β] :
    SeminormedAddCommGroup (WithLp p (α × β)) 
goal: SeminormedAddCommGroup (WithLp p (α × β))

full_name: WithLp.instProdNormedAddCommGroup
code: /-- normed group instance on the product of two normed groups, using the `L^p` norm. -/
instance instProdNormedAddCommGroup [NormedAddCommGroup α] [NormedAddCommGroup β] :
    NormedAddCommGroup (WithLp p (α × β)) 
goal: NormedAddCommGroup (WithLp p (α × β))

full_name: WithLp.prod_norm_eq_of_nat
code: theorem prod_norm_eq_of_nat [Norm α] [Norm β] (n : ℕ) (h : p = n) (f : WithLp p (α × β)) :
    ‖f‖ = (‖f.fst‖ ^ n + ‖f.snd‖ ^ n) ^ (1 / (n : ℝ)) 
goal: ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)

full_name: WithLp.prod_nnnorm_eq_add
code: theorem prod_nnnorm_eq_add (hp : p ≠ ∞) (f : WithLp p (α × β)) :
    ‖f‖₊ = (‖f.fst‖₊ ^ p.toReal + ‖f.snd‖₊ ^ p.toReal) ^ (1 / p.toReal) 
goal: p ≠ ⊤ → ∀ (f : WithLp p (α × β)), ‖f‖₊ = (‖f.1‖₊ ^ p.toReal + ‖f.2‖₊ ^ p.toReal) ^ (1 / p.toReal)

full_name: WithLp.prod_nnnorm_eq_sup
code: theorem prod_nnnorm_eq_sup (f : WithLp ∞ (α × β)) : ‖f‖₊ = ‖f.fst‖₊ ⊔  ‖f.snd‖₊ 
goal: ‖f‖₊ = ‖f.1‖₊ ⊔ ‖f.2‖₊

full_name: WithLp.prod_nnnorm_equiv
code: @[simp] theorem prod_nnnorm_equiv (f : WithLp ∞ (α × β)) : ‖WithLp.equiv ⊤ _ f‖₊ = ‖f‖₊ 
goal: ‖(WithLp.equiv ⊤ (α × β)) f‖₊ = ‖f‖₊

full_name: WithLp.prod_nnnorm_equiv_symm
code: @[simp] theorem prod_nnnorm_equiv_symm (f : α × β) : ‖(WithLp.equiv ⊤ _).symm f‖₊ = ‖f‖₊ 
goal: ‖(WithLp.equiv ⊤ (α × β)).symm f‖₊ = ‖f‖₊

full_name: WithLp.prod_norm_equiv
code: @[simp] theorem prod_norm_equiv (f : WithLp ∞ (α × β)) : ‖WithLp.equiv ⊤ _ f‖ = ‖f‖ 
goal: ‖(WithLp.equiv ⊤ (α × β)) f‖ = ‖f‖

full_name: WithLp.prod_norm_equiv_symm
code: @[simp] theorem prod_norm_equiv_symm (f : α × β) : ‖(WithLp.equiv ⊤ _).symm f‖ = ‖f‖ 
goal: ‖(WithLp.equiv ⊤ (α × β)).symm f‖ = ‖f‖

full_name: WithLp.prod_norm_eq_of_L2
code: theorem prod_norm_eq_of_L2 (x : WithLp 2 (α × β)) :
    ‖x‖ = √(‖x.fst‖ ^ 2 + ‖x.snd‖ ^ 2) 
goal: ‖x‖ = √(‖x.1‖ ^ 2 + ‖x.2‖ ^ 2)

full_name: WithLp.prod_nnnorm_eq_of_L2
code: theorem prod_nnnorm_eq_of_L2 (x : WithLp 2 (α × β)) :
    ‖x‖₊ = NNReal.sqrt (‖x.fst‖₊ ^ 2 + ‖x.snd‖₊ ^ 2) 
goal: ‖x‖₊ = NNReal.sqrt (‖x.1‖₊ ^ 2 + ‖x.2‖₊ ^ 2)

full_name: WithLp.prod_norm_sq_eq_of_L2
code: theorem prod_norm_sq_eq_of_L2 (x : WithLp 2 (α × β)) : ‖x‖ ^ 2 = ‖x.fst‖ ^ 2 + ‖x.snd‖ ^ 2 
goal: ‖x‖ ^ 2 = ‖x.1‖ ^ 2 + ‖x.2‖ ^ 2

full_name: WithLp.prod_dist_eq_of_L2
code: theorem prod_dist_eq_of_L2 (x y : WithLp 2 (α × β)) :
    dist x y = √(dist x.fst y.fst ^ 2 + dist x.snd y.snd ^ 2) 
goal: dist x y = √(dist x.1 y.1 ^ 2 + dist x.2 y.2 ^ 2)

full_name: WithLp.prod_nndist_eq_of_L2
code: theorem prod_nndist_eq_of_L2 (x y : WithLp 2 (α × β)) :
    nndist x y = NNReal.sqrt (nndist x.fst y.fst ^ 2 + nndist x.snd y.snd ^ 2) 
goal: nndist x y = NNReal.sqrt (nndist x.1 y.1 ^ 2 + nndist x.2 y.2 ^ 2)

full_name: WithLp.prod_edist_eq_of_L2
code: theorem prod_edist_eq_of_L2 (x y : WithLp 2 (α × β)) :
    edist x y = (edist x.fst y.fst ^ 2 + edist x.snd y.snd ^ 2) ^ (1 / 2 : ℝ) 
goal: edist x y = (edist x.1 y.1 ^ 2 + edist x.2 y.2 ^ 2) ^ (1 / 2)

full_name: WithLp.nnnorm_equiv_symm_fst
code: @[simp]
theorem nnnorm_equiv_symm_fst (x : α) :
    ‖(WithLp.equiv p (α × β)).symm (x, 0)‖₊ = ‖x‖₊ 
goal: ‖(WithLp.equiv p (α × β)).symm (x, 0)‖₊ = ‖x‖₊

full_name: WithLp.nnnorm_equiv_symm_snd
code: @[simp]
theorem nnnorm_equiv_symm_snd (y : β) :
    ‖(WithLp.equiv p (α × β)).symm (0, y)‖₊ = ‖y‖₊ 
goal: ‖(WithLp.equiv p (α × β)).symm (0, y)‖₊ = ‖y‖₊

full_name: WithLp.norm_equiv_symm_fst
code: @[simp]
theorem norm_equiv_symm_fst (x : α) : ‖(WithLp.equiv p (α × β)).symm (x, 0)‖ = ‖x‖ 
goal: ‖(WithLp.equiv p (α × β)).symm (x, 0)‖ = ‖x‖

full_name: WithLp.norm_equiv_symm_snd
code: @[simp]
theorem norm_equiv_symm_snd (y : β) : ‖(WithLp.equiv p (α × β)).symm (0, y)‖ = ‖y‖ 
goal: ‖(WithLp.equiv p (α × β)).symm (0, y)‖ = ‖y‖

full_name: WithLp.nndist_equiv_symm_fst
code: @[simp]
theorem nndist_equiv_symm_fst (x₁ x₂ : α) :
    nndist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) =
      nndist x₁ x₂ 
goal: nndist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) = nndist x₁ x₂

full_name: WithLp.nndist_equiv_symm_snd
code: @[simp]
theorem nndist_equiv_symm_snd (y₁ y₂ : β) :
    nndist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) =
      nndist y₁ y₂ 
goal: nndist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) = nndist y₁ y₂

full_name: WithLp.dist_equiv_symm_fst
code: @[simp]
theorem dist_equiv_symm_fst (x₁ x₂ : α) :
    dist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) =
      dist x₁ x₂ 
goal: dist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) = dist x₁ x₂

full_name: WithLp.dist_equiv_symm_snd
code: @[simp]
theorem dist_equiv_symm_snd (y₁ y₂ : β) :
    dist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) =
      dist y₁ y₂ 
goal: dist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) = dist y₁ y₂

full_name: WithLp.edist_equiv_symm_fst
code: @[simp]
theorem edist_equiv_symm_fst (x₁ x₂ : α) :
    edist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) =
      edist x₁ x₂ 
goal: edist ((WithLp.equiv p (α × β)).symm (x₁, 0)) ((WithLp.equiv p (α × β)).symm (x₂, 0)) = edist x₁ x₂

full_name: WithLp.edist_equiv_symm_snd
code: @[simp]
theorem edist_equiv_symm_snd (y₁ y₂ : β) :
    edist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) =
      edist y₁ y₂ 
goal: edist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) = edist y₁ y₂

full_name: WithLp.instProdBoundedSMul
code: instance instProdBoundedSMul : BoundedSMul 𝕜 (WithLp p (α × β)) 
goal: BoundedSMul 𝕜 (WithLp p (α × β))

full_name: WithLp.prodEquivₗᵢ
code: /-- The canonical map `WithLp.equiv` between `WithLp ∞ (α × β)` and `α × β` as a linear isometric
equivalence. -/
def prodEquivₗᵢ : WithLp ∞ (α × β) ≃ₗᵢ[𝕜] α × β 
goal: WithLp ⊤ (α × β) ≃ₗᵢ[𝕜] α × β

full_name: WithLp.instProdNormedSpace
code: /-- The product of two normed spaces is a normed space, with the `L^p` norm. -/
instance instProdNormedSpace [NormedField 𝕜] [NormedSpace 𝕜 α] [NormedSpace 𝕜 β] :
    NormedSpace 𝕜 (WithLp p (α × β)) 
goal: NormedSpace 𝕜 (WithLp p (α × β))