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

full_name: PiLp
code: /-- A copy of a Pi type, on which we will put the `L^p` distance. Since the Pi type itself is
already endowed with the `L^∞` distance, we need the type synonym to avoid confusing typeclass
resolution. Also, we let it depend on `p`, to get a whole family of type on which we can put
different distances. -/
abbrev PiLp (p : ℝ≥0∞) {ι : Type*} (α : ι → Type*) : Type _ 
goal: Type (max u_1 u_2)

full_name: instCoeFunPiLpForall
code: instance (p : ℝ≥0∞) {ι : Type*} (α : ι → Type*) : CoeFun (PiLp p α) (fun _ ↦ (i : ι) → α i) 
goal: CoeFun (PiLp p α) fun x => (i : ι) → α i

full_name: instInhabitedPiLp
code: instance (p : ℝ≥0∞) {ι : Type*} (α : ι → Type*) [∀ i, Inhabited (α i)] : Inhabited (PiLp p α) 
goal: Inhabited (PiLp p α)

full_name: PiLp.ext
code: @[ext]
protected theorem PiLp.ext {p : ℝ≥0∞} {ι : Type*} {α : ι → Type*} {x y : PiLp p α}
    (h : ∀ i, x i = y i) : x = y 
goal: x = y

full_name: PiLp.zero_apply
code: @[simp, nolint simpNF]
theorem zero_apply : (0 : PiLp p β) i = 0 
goal: 0 i = 0

full_name: PiLp.add_apply
code: @[simp]
theorem add_apply : (x + y) i = x i + y i 
goal: (x + y) i = x i + y i

full_name: PiLp.sub_apply
code: @[simp]
theorem sub_apply : (x - y) i = x i - y i 
goal: (x - y) i = x i - y i

full_name: PiLp.smul_apply
code: @[simp]
theorem smul_apply : (c • x) i = c • x i 
goal: (c • x) i = c • x i

full_name: PiLp.neg_apply
code: @[simp]
theorem neg_apply : (-x) i = -x i 
goal: (-x) i = -x i

full_name: WithLp.equiv_pi_apply
code: @[simp]
theorem _root_.WithLp.equiv_pi_apply (x : PiLp p α) (i : ι) : WithLp.equiv p _ x i = x i 
goal: (WithLp.equiv p ((i : ι) → α i)) x i = x i

full_name: WithLp.equiv_symm_pi_apply
code: @[simp]
theorem  _root_.WithLp.equiv_symm_pi_apply (x : ∀ i, α i) (i : ι) :
    (WithLp.equiv p _).symm x i = x i 
goal: (WithLp.equiv p ((i : ι) → α i)).symm x i = x i

full_name: PiLp.instEDist
code: /-- Endowing the space `PiLp p β` with the `L^p` edistance. We register this instance
separate from `pi_Lp.pseudo_emetric` 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 `PiLp 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 : EDist (PiLp p β) 
goal: EDist (PiLp p β)

full_name: PiLp.edist_eq_card
code: theorem edist_eq_card (f g : PiLp 0 β) :
    edist f g = {i | edist (f i) (g i) ≠ 0}.toFinite.toFinset.card 
goal: edist f g = ↑⋯.toFinset.card

full_name: PiLp.edist_eq_sum
code: theorem edist_eq_sum {p : ℝ≥0∞} (hp : 0 < p.toReal) (f g : PiLp p β) :
    edist f g = (∑ i, edist (f i) (g i) ^ p.toReal) ^ (1 / p.toReal) 
goal: edist f g = (∑ i : ι, edist (f i) (g i) ^ p.toReal) ^ (1 / p.toReal)

full_name: PiLp.edist_eq_iSup
code: theorem edist_eq_iSup (f g : PiLp ∞ β) : edist f g = ⨆ i, edist (f i) (g i) 
goal: edist f g = ⨆ i, edist (f i) (g i)

full_name: PiLp.edist_self
code: /-- This holds independent of `p` and does not require `[Fact (1 ≤ p)]`. We keep it separate
from `pi_Lp.pseudo_emetric_space` so it can be used also for `p < 1`. -/
protected theorem edist_self (f : PiLp p β) : edist f f = 0 
goal: edist f f = 0

full_name: PiLp.edist_comm
code: /-- This holds independent of `p` and does not require `[Fact (1 ≤ p)]`. We keep it separate
from `pi_Lp.pseudo_emetric_space` so it can be used also for `p < 1`. -/
protected theorem edist_comm (f g : PiLp p β) : edist f g = edist g f 
goal: edist f g = edist g f

full_name: PiLp.instDist
code: /-- Endowing the space `PiLp p β` with the `L^p` distance. We register this instance
separate from `pi_Lp.pseudo_metric` 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 `PiLp 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 : Dist (PiLp p α) 
goal: Dist (PiLp p α)

full_name: PiLp.dist_eq_card
code: theorem dist_eq_card (f g : PiLp 0 α) :
    dist f g = {i | dist (f i) (g i) ≠ 0}.toFinite.toFinset.card 
goal: dist f g = ↑⋯.toFinset.card

full_name: PiLp.dist_eq_sum
code: theorem dist_eq_sum {p : ℝ≥0∞} (hp : 0 < p.toReal) (f g : PiLp p α) :
    dist f g = (∑ i, dist (f i) (g i) ^ p.toReal) ^ (1 / p.toReal) 
goal: dist f g = (∑ i : ι, dist (f i) (g i) ^ p.toReal) ^ (1 / p.toReal)

full_name: PiLp.dist_eq_iSup
code: theorem dist_eq_iSup (f g : PiLp ∞ α) : dist f g = ⨆ i, dist (f i) (g i) 
goal: dist f g = ⨆ i, dist (f i) (g i)

full_name: PiLp.instNorm
code: /-- Endowing the space `PiLp p β` with the `L^p` norm. We register this instance
separate from `PiLp.seminormedAddCommGroup` 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 `PiLp p β` for `p < 1`
satisfying a relaxed triangle inequality. These are called *quasi-norms*. -/
instance instNorm : Norm (PiLp p β) 
goal: Norm (PiLp p β)

full_name: PiLp.norm_eq_card
code: theorem norm_eq_card (f : PiLp 0 β) : ‖f‖ = {i | ‖f i‖ ≠ 0}.toFinite.toFinset.card 
goal: ‖f‖ = ↑⋯.toFinset.card

full_name: PiLp.norm_eq_ciSup
code: theorem norm_eq_ciSup (f : PiLp ∞ β) : ‖f‖ = ⨆ i, ‖f i‖ 
goal: ‖f‖ = ⨆ i, ‖f i‖

full_name: PiLp.norm_eq_sum
code: theorem norm_eq_sum (hp : 0 < p.toReal) (f : PiLp p β) :
    ‖f‖ = (∑ i, ‖f i‖ ^ p.toReal) ^ (1 / p.toReal) 
goal: ‖f‖ = (∑ i : ι, ‖f i‖ ^ p.toReal) ^ (1 / p.toReal)

full_name: PiLp.pseudoEmetricAux
code: /-- Endowing the space `PiLp 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 pseudoEmetricAux : PseudoEMetricSpace (PiLp p β) 
goal: PseudoEMetricSpace (PiLp p β)

full_name: PiLp.iSup_edist_ne_top_aux
code: /-- An auxiliary lemma used twice in the proof of `PiLp.pseudoMetricAux` below. Not intended for
use outside this file. -/
theorem iSup_edist_ne_top_aux {ι : Type*} [Finite ι] {α : ι → Type*}
    [∀ i, PseudoMetricSpace (α i)] (f g : PiLp ∞ α) : (⨆ i, edist (f i) (g i)) ≠ ⊤ 
goal: ⨆ i, edist (f i) (g i) ≠ ⊤

full_name: PiLp.pseudoMetricAux
code: /-- Endowing the space `PiLp 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 pseudoMetricAux : PseudoMetricSpace (PiLp p α) 
goal: PseudoMetricSpace (PiLp p α)

full_name: PiLp.lipschitzWith_equiv_aux
code: theorem lipschitzWith_equiv_aux : LipschitzWith 1 (WithLp.equiv p (∀ i, β i)) 
goal: LipschitzWith 1 ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.antilipschitzWith_equiv_aux
code: theorem antilipschitzWith_equiv_aux :
    AntilipschitzWith ((Fintype.card ι : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (∀ i, β i)) 
goal: AntilipschitzWith (↑(Fintype.card ι) ^ (1 / p).toReal) ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.aux_uniformity_eq
code: theorem aux_uniformity_eq : 𝓤 (PiLp p β) = 𝓤[Pi.uniformSpace _] 
goal: 𝓤 (PiLp p β) = 𝓤 ((i : ι) → β i)

full_name: PiLp.aux_cobounded_eq
code: theorem aux_cobounded_eq : cobounded (PiLp p α) = @cobounded _ Pi.instBornology 
goal: Bornology.cobounded (PiLp p α) = Bornology.cobounded ((i : ι) → α i)

full_name: PiLp.uniformSpace
code: instance uniformSpace [∀ i, UniformSpace (β i)] : UniformSpace (PiLp p β) 
goal: UniformSpace (PiLp p β)

full_name: PiLp.uniformContinuous_equiv
code: theorem uniformContinuous_equiv [∀ i, UniformSpace (β i)] :
    UniformContinuous (WithLp.equiv p (∀ i, β i)) 
goal: UniformContinuous ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.uniformContinuous_equiv_symm
code: theorem uniformContinuous_equiv_symm [∀ i, UniformSpace (β i)] :
    UniformContinuous (WithLp.equiv p (∀ i, β i)).symm 
goal: UniformContinuous ⇑(WithLp.equiv p ((i : ι) → β i)).symm

full_name: PiLp.continuous_equiv
code: @[continuity]
theorem continuous_equiv [∀ i, UniformSpace (β i)] : Continuous (WithLp.equiv p (∀ i, β i)) 
goal: Continuous ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.continuous_equiv_symm
code: @[continuity]
theorem continuous_equiv_symm [∀ i, UniformSpace (β i)] :
    Continuous (WithLp.equiv p (∀ i, β i)).symm 
goal: Continuous ⇑(WithLp.equiv p ((i : ι) → β i)).symm

full_name: PiLp.bornology
code: instance bornology [∀ i, Bornology (β i)] : Bornology (PiLp p β) 
goal: Bornology (PiLp p β)

full_name: PiLp.instPseudoEMetricSpace
code: /-- pseudoemetric space instance on the product of finitely many pseudoemetric spaces, using the
`L^p` pseudoedistance, and having as uniformity the product uniformity. -/
instance [∀ i, PseudoEMetricSpace (β i)] : PseudoEMetricSpace (PiLp p β) 
goal: PseudoEMetricSpace (PiLp p β)

full_name: PiLp.instEMetricSpace
code: /-- emetric space instance on the product of finitely many emetric spaces, using the `L^p`
edistance, and having as uniformity the product uniformity. -/
instance [∀ i, EMetricSpace (α i)] : EMetricSpace (PiLp p α) 
goal: EMetricSpace (PiLp p α)

full_name: PiLp.instPseudoMetricSpace
code: /-- pseudometric space instance on the product of finitely many pseudometric spaces, using the
`L^p` distance, and having as uniformity the product uniformity. -/
instance [∀ i, PseudoMetricSpace (β i)] : PseudoMetricSpace (PiLp p β) 
goal: PseudoMetricSpace (PiLp p β)

full_name: PiLp.instMetricSpace
code: /-- metric space instance on the product of finitely many metric spaces, using the `L^p` distance,
and having as uniformity the product uniformity. -/
instance [∀ i, MetricSpace (α i)] : MetricSpace (PiLp p α) 
goal: MetricSpace (PiLp p α)

full_name: PiLp.nndist_eq_sum
code: theorem nndist_eq_sum {p : ℝ≥0∞} [Fact (1 ≤ p)] {β : ι → Type*} [∀ i, PseudoMetricSpace (β i)]
    (hp : p ≠ ∞) (x y : PiLp p β) :
    nndist x y = (∑ i : ι, nndist (x i) (y i) ^ p.toReal) ^ (1 / p.toReal) 
goal: nndist x y = (∑ i : ι, nndist (x i) (y i) ^ p.toReal) ^ (1 / p.toReal)

full_name: PiLp.nndist_eq_iSup
code: theorem nndist_eq_iSup {β : ι → Type*} [∀ i, PseudoMetricSpace (β i)] (x y : PiLp ∞ β) :
    nndist x y = ⨆ i, nndist (x i) (y i) 
goal: nndist x y = ⨆ i, nndist (x i) (y i)

full_name: PiLp.lipschitzWith_equiv
code: theorem lipschitzWith_equiv [∀ i, PseudoEMetricSpace (β i)] :
    LipschitzWith 1 (WithLp.equiv p (∀ i, β i)) 
goal: LipschitzWith 1 ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.antilipschitzWith_equiv
code: theorem antilipschitzWith_equiv [∀ i, PseudoEMetricSpace (β i)] :
    AntilipschitzWith ((Fintype.card ι : ℝ≥0) ^ (1 / p).toReal) (WithLp.equiv p (∀ i, β i)) 
goal: AntilipschitzWith (↑(Fintype.card ι) ^ (1 / p).toReal) ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.infty_equiv_isometry
code: theorem infty_equiv_isometry [∀ i, PseudoEMetricSpace (β i)] :
    Isometry (WithLp.equiv ∞ (∀ i, β i)) 
goal: Isometry ⇑(WithLp.equiv ⊤ ((i : ι) → β i))

full_name: PiLp.seminormedAddCommGroup
code: /-- seminormed group instance on the product of finitely many normed groups, using the `L^p`
norm. -/
instance seminormedAddCommGroup [∀ i, SeminormedAddCommGroup (β i)] :
    SeminormedAddCommGroup (PiLp p β) 
goal: SeminormedAddCommGroup (PiLp p β)

full_name: PiLp.normedAddCommGroup
code: /-- normed group instance on the product of finitely many normed groups, using the `L^p` norm. -/
instance normedAddCommGroup [∀ i, NormedAddCommGroup (α i)] : NormedAddCommGroup (PiLp p α) 
goal: NormedAddCommGroup (PiLp p α)

full_name: PiLp.nnnorm_eq_sum
code: theorem nnnorm_eq_sum {p : ℝ≥0∞} [Fact (1 ≤ p)] {β : ι → Type*} (hp : p ≠ ∞)
    [∀ i, SeminormedAddCommGroup (β i)] (f : PiLp p β) :
    ‖f‖₊ = (∑ i, ‖f i‖₊ ^ p.toReal) ^ (1 / p.toReal) 
goal: ‖f‖₊ = (∑ i : ι, ‖f i‖₊ ^ p.toReal) ^ (1 / p.toReal)

full_name: PiLp.nnnorm_eq_ciSup
code: theorem nnnorm_eq_ciSup (f : PiLp ∞ β) : ‖f‖₊ = ⨆ i, ‖f i‖₊ 
goal: ‖f‖₊ = ⨆ i, ‖f i‖₊

full_name: PiLp.nnnorm_equiv
code: @[simp] theorem nnnorm_equiv (f : PiLp ∞ β) : ‖WithLp.equiv ⊤ _ f‖₊ = ‖f‖₊ 
goal: ‖(WithLp.equiv ⊤ ((i : ι) → β i)) f‖₊ = ‖f‖₊

full_name: PiLp.nnnorm_equiv_symm
code: @[simp] theorem nnnorm_equiv_symm (f : ∀ i, β i) : ‖(WithLp.equiv ⊤ _).symm f‖₊ = ‖f‖₊ 
goal: ‖(WithLp.equiv ⊤ ((i : ι) → β i)).symm f‖₊ = ‖f‖₊

full_name: PiLp.norm_equiv
code: @[simp] theorem norm_equiv (f : PiLp ∞ β) : ‖WithLp.equiv ⊤ _ f‖ = ‖f‖ 
goal: ‖(WithLp.equiv ⊤ ((i : ι) → β i)) f‖ = ‖f‖

full_name: PiLp.norm_equiv_symm
code: @[simp] theorem norm_equiv_symm (f : ∀ i, β i) : ‖(WithLp.equiv ⊤ _).symm f‖ = ‖f‖ 
goal: ‖(WithLp.equiv ⊤ ((i : ι) → β i)).symm f‖ = ‖f‖

full_name: PiLp.norm_eq_of_nat
code: theorem norm_eq_of_nat {p : ℝ≥0∞} [Fact (1 ≤ p)] {β : ι → Type*}
    [∀ i, SeminormedAddCommGroup (β i)] (n : ℕ) (h : p = n) (f : PiLp p β) :
    ‖f‖ = (∑ i, ‖f i‖ ^ n) ^ (1 / (n : ℝ)) 
goal: ‖f‖ = (∑ i : ι, ‖f i‖ ^ n) ^ (1 / ↑n)

full_name: PiLp.norm_eq_of_L2
code: theorem norm_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x : PiLp 2 β) :
    ‖x‖ = √(∑ i : ι, ‖x i‖ ^ 2) 
goal: ‖x‖ = √(∑ i : ι, ‖x i‖ ^ 2)

full_name: PiLp.nnnorm_eq_of_L2
code: theorem nnnorm_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x : PiLp 2 β) :
    ‖x‖₊ = NNReal.sqrt (∑ i : ι, ‖x i‖₊ ^ 2) 
goal: ‖x‖₊ = NNReal.sqrt (∑ i : ι, ‖x i‖₊ ^ 2)

full_name: PiLp.norm_sq_eq_of_L2
code: theorem norm_sq_eq_of_L2 (β : ι → Type*) [∀ i, SeminormedAddCommGroup (β i)] (x : PiLp 2 β) :
    ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2 
goal: ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2

full_name: PiLp.dist_eq_of_L2
code: theorem dist_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x y : PiLp 2 β) :
    dist x y = √(∑ i, dist (x i) (y i) ^ 2) 
goal: dist x y = √(∑ i : ι, dist (x i) (y i) ^ 2)

full_name: PiLp.nndist_eq_of_L2
code: theorem nndist_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x y : PiLp 2 β) :
    nndist x y = NNReal.sqrt (∑ i, nndist (x i) (y i) ^ 2) 
goal: nndist x y = NNReal.sqrt (∑ i : ι, nndist (x i) (y i) ^ 2)

full_name: PiLp.edist_eq_of_L2
code: theorem edist_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x y : PiLp 2 β) :
    edist x y = (∑ i, edist (x i) (y i) ^ 2) ^ (1 / 2 : ℝ) 
goal: edist x y = (∑ i : ι, edist (x i) (y i) ^ 2) ^ (1 / 2)

full_name: PiLp.instBoundedSMul
code: instance instBoundedSMul [SeminormedRing 𝕜] [∀ i, SeminormedAddCommGroup (β i)]
    [∀ i, Module 𝕜 (β i)] [∀ i, BoundedSMul 𝕜 (β i)] :
    BoundedSMul 𝕜 (PiLp p β) 
goal: BoundedSMul 𝕜 (PiLp p β)

full_name: PiLp.normedSpace
code: /-- The product of finitely many normed spaces is a normed space, with the `L^p` norm. -/
instance normedSpace [NormedField 𝕜] [∀ i, SeminormedAddCommGroup (β i)]
    [∀ i, NormedSpace 𝕜 (β i)] : NormedSpace 𝕜 (PiLp p β) 
goal: NormedSpace 𝕜 (PiLp p β)

full_name: PiLp.equivₗᵢ
code: /-- The canonical map `WithLp.equiv` between `PiLp ∞ β` and `Π i, β i` as a linear isometric
equivalence. -/
def equivₗᵢ : PiLp ∞ β ≃ₗᵢ[𝕜] ∀ i, β i 
goal: PiLp ⊤ β ≃ₗᵢ[𝕜] (i : ι) → β i

full_name: LinearIsometryEquiv.piLpCongrLeft
code: /-- An equivalence of finite domains induces a linearly isometric equivalence of finitely supported
functions-/
def _root_.LinearIsometryEquiv.piLpCongrLeft (e : ι ≃ ι') :
    (PiLp p fun _ : ι => E) ≃ₗᵢ[𝕜] PiLp p fun _ : ι' => E 
goal: (PiLp p fun x => E) ≃ₗᵢ[𝕜] PiLp p fun x => E

full_name: LinearIsometryEquiv.piLpCongrLeft_apply
code: @[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrLeft_apply (e : ι ≃ ι') (v : PiLp p fun _ : ι => E) :
    LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e v = Equiv.piCongrLeft' (fun _ : ι => E) e v 
goal: (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e) v = (Equiv.piCongrLeft' (fun x => E) e) v

full_name: LinearIsometryEquiv.piLpCongrLeft_symm
code: @[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrLeft_symm (e : ι ≃ ι') :
    (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e).symm =
      LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e.symm 
goal: (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e).symm = LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e.symm

full_name: LinearIsometryEquiv.piLpCongrLeft_single
code: @[simp high]
theorem _root_.LinearIsometryEquiv.piLpCongrLeft_single [DecidableEq ι] [DecidableEq ι']
    (e : ι ≃ ι') (i : ι) (v : E) :
    LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e ((WithLp.equiv p (_ → E)).symm <| Pi.single i v) =
      (WithLp.equiv p (_ → E)).symm (Pi.single (e i) v) 
goal: (LinearIsometryEquiv.piLpCongrLeft p 𝕜 E e) ((WithLp.equiv p (ι → E)).symm (Pi.single i v)) =
  (WithLp.equiv p (ι' → E)).symm (Pi.single (e i) v)

full_name: LinearIsometryEquiv.piLpCongrRight
code: /-- A family of linearly isometric equivalences in the codomain induces an isometric equivalence
between Pi types with the Lp norm.

This is the isometry version of `LinearEquiv.piCongrRight`. -/
protected def _root_.LinearIsometryEquiv.piLpCongrRight (e : ∀ i, α i ≃ₗᵢ[𝕜] β i) :
    PiLp p α ≃ₗᵢ[𝕜] PiLp p β 
goal: PiLp p α ≃ₗᵢ[𝕜] PiLp p β

full_name: LinearIsometryEquiv.piLpCongrRight_apply
code: @[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrRight_apply (e : ∀ i, α i ≃ₗᵢ[𝕜] β i) (x : PiLp p α) :
    LinearIsometryEquiv.piLpCongrRight p e x =
      (WithLp.equiv p _).symm (fun i => e i (x i)) 
goal: (LinearIsometryEquiv.piLpCongrRight p e) x = (WithLp.equiv p ((i : ι) → β i)).symm fun i => (e i) (x i)

full_name: LinearIsometryEquiv.piLpCongrRight_refl
code: @[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrRight_refl :
    LinearIsometryEquiv.piLpCongrRight p (fun i => .refl 𝕜 (α i)) = .refl _ _ 
goal: (LinearIsometryEquiv.piLpCongrRight p fun i => LinearIsometryEquiv.refl 𝕜 (α i)) = LinearIsometryEquiv.refl 𝕜 (PiLp p α)

full_name: LinearIsometryEquiv.piLpCongrRight_symm
code: @[simp]
theorem _root_.LinearIsometryEquiv.piLpCongrRight_symm (e : ∀ i, α i ≃ₗᵢ[𝕜] β i) :
    (LinearIsometryEquiv.piLpCongrRight p e).symm =
      LinearIsometryEquiv.piLpCongrRight p (fun i => (e i).symm) 
goal: (LinearIsometryEquiv.piLpCongrRight p e).symm = LinearIsometryEquiv.piLpCongrRight p fun i => (e i).symm

full_name: LinearIsometryEquiv.piLpCongrRight_single
code: @[simp high]
theorem _root_.LinearIsometryEquiv.piLpCongrRight_single (e : ∀ i, α i ≃ₗᵢ[𝕜] β i) [DecidableEq ι]
    (i : ι) (v : α i) :
    LinearIsometryEquiv.piLpCongrRight p e ((WithLp.equiv p (∀ i, α i)).symm <| Pi.single i v) =
      (WithLp.equiv p (∀ i, β i)).symm (Pi.single i (e _ v)) 
goal: (LinearIsometryEquiv.piLpCongrRight p e) ((WithLp.equiv p ((i : ι) → α i)).symm (Pi.single i v)) =
  (WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i ((e i) v))

full_name: LinearIsometryEquiv.piLpCurry
code: /-- `LinearEquiv.piCurry` for `PiLp`, as an isometry. -/
def _root_.LinearIsometryEquiv.piLpCurry  :
    PiLp p (fun i : Sigma _ => α i.1 i.2) ≃ₗᵢ[𝕜] PiLp p (fun i => PiLp p (α i)) 
goal: (PiLp p fun i => α i.fst i.snd) ≃ₗᵢ[𝕜] PiLp p fun i => PiLp p (α i)

full_name: LinearIsometryEquiv.piLpCurry_apply
code: @[simp] theorem _root_.LinearIsometryEquiv.piLpCurry_apply
    (f : PiLp p (fun i : Sigma κ => α i.1 i.2)) :
    _root_.LinearIsometryEquiv.piLpCurry 𝕜 p α f =
      (WithLp.equiv _ _).symm (fun i => (WithLp.equiv _ _).symm <|
        Sigma.curry (WithLp.equiv _ _ f) i) 
goal: (LinearIsometryEquiv.piLpCurry 𝕜 p α) f =
  (WithLp.equiv p ((i : ι) → WithLp p ((y : κ i) → α i y))).symm fun i =>
    (WithLp.equiv p ((y : κ i) → α i y)).symm (Sigma.curry ((WithLp.equiv p ((x : Sigma κ) → α x.fst x.snd)) f) i)

full_name: LinearIsometryEquiv.piLpCurry_symm_apply
code: @[simp] theorem _root_.LinearIsometryEquiv.piLpCurry_symm_apply
    (f : PiLp p (fun i => PiLp p (α i))) :
    (_root_.LinearIsometryEquiv.piLpCurry 𝕜 p α).symm f =
      (WithLp.equiv _ _).symm (Sigma.uncurry fun i j => f i j) 
goal: (LinearIsometryEquiv.piLpCurry 𝕜 p α).symm f =
  (WithLp.equiv p ((x : Sigma κ) → α x.fst x.snd)).symm (Sigma.uncurry fun i j => f i j)

full_name: PiLp.nnnorm_equiv_symm_single
code: @[simp]
theorem nnnorm_equiv_symm_single [hp : Fact (1 ≤ p)] (i : ι) (b : β i) :
    ‖(WithLp.equiv p (∀ i, β i)).symm (Pi.single i b)‖₊ = ‖b‖₊ 
goal: ‖(WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b)‖₊ = ‖b‖₊

full_name: PiLp.norm_equiv_symm_single
code: @[simp]
theorem norm_equiv_symm_single (i : ι) (b : β i) :
    ‖(WithLp.equiv p (∀ i, β i)).symm (Pi.single i b)‖ = ‖b‖ 
goal: ‖(WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b)‖ = ‖b‖

full_name: PiLp.nndist_equiv_symm_single_same
code: @[simp]
theorem nndist_equiv_symm_single_same (i : ι) (b₁ b₂ : β i) :
    nndist
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₁))
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₂)) =
      nndist b₁ b₂ 
goal: nndist ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₁))
    ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₂)) =
  nndist b₁ b₂

full_name: PiLp.dist_equiv_symm_single_same
code: @[simp]
theorem dist_equiv_symm_single_same (i : ι) (b₁ b₂ : β i) :
    dist
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₁))
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₂)) =
      dist b₁ b₂ 
goal: dist ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₁)) ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₂)) =
  dist b₁ b₂

full_name: PiLp.edist_equiv_symm_single_same
code: @[simp]
theorem edist_equiv_symm_single_same (i : ι) (b₁ b₂ : β i) :
    edist
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₁))
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₂)) =
      edist b₁ b₂ 
goal: edist ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₁))
    ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₂)) =
  edist b₁ b₂

full_name: PiLp.nnnorm_equiv_symm_const
code: /-- When `p = ∞`, this lemma does not hold without the additional assumption `Nonempty ι` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.nnnorm_equiv_symm_const'` for a version which exchanges the hypothesis `p ≠ ∞` for
`Nonempty ι`. -/
theorem nnnorm_equiv_symm_const {β} [SeminormedAddCommGroup β] (hp : p ≠ ∞) (b : β) :
    ‖(WithLp.equiv p (ι → β)).symm (Function.const _ b)‖₊ =
      (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖b‖₊ 
goal: ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊

full_name: PiLp.nnnorm_equiv_symm_const'
code: /-- When `IsEmpty ι`, this lemma does not hold without the additional assumption `p ≠ ∞` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.nnnorm_equiv_symm_const` for a version which exchanges the hypothesis `Nonempty ι`.
for `p ≠ ∞`. -/
theorem nnnorm_equiv_symm_const' {β} [SeminormedAddCommGroup β] [Nonempty ι] (b : β) :
    ‖(WithLp.equiv p (ι → β)).symm (Function.const _ b)‖₊ =
      (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖b‖₊ 
goal: ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊

full_name: PiLp.norm_equiv_symm_const
code: /-- When `p = ∞`, this lemma does not hold without the additional assumption `Nonempty ι` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.norm_equiv_symm_const'` for a version which exchanges the hypothesis `p ≠ ∞` for
`Nonempty ι`. -/
theorem norm_equiv_symm_const {β} [SeminormedAddCommGroup β] (hp : p ≠ ∞) (b : β) :
    ‖(WithLp.equiv p (ι → β)).symm (Function.const _ b)‖ =
      (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖b‖ 
goal: ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖

full_name: PiLp.norm_equiv_symm_const'
code: /-- When `IsEmpty ι`, this lemma does not hold without the additional assumption `p ≠ ∞` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.norm_equiv_symm_const` for a version which exchanges the hypothesis `Nonempty ι`.
for `p ≠ ∞`. -/
theorem norm_equiv_symm_const' {β} [SeminormedAddCommGroup β] [Nonempty ι] (b : β) :
    ‖(WithLp.equiv p (ι → β)).symm (Function.const _ b)‖ =
      (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖b‖ 
goal: ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖

full_name: PiLp.nnnorm_equiv_symm_one
code: theorem nnnorm_equiv_symm_one {β} [SeminormedAddCommGroup β] (hp : p ≠ ∞) [One β] :
    ‖(WithLp.equiv p (ι → β)).symm 1‖₊ =
      (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖(1 : β)‖₊ 
goal: ‖(WithLp.equiv p (ι → β)).symm 1‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖1‖₊

full_name: PiLp.norm_equiv_symm_one
code: theorem norm_equiv_symm_one {β} [SeminormedAddCommGroup β] (hp : p ≠ ∞) [One β] :
    ‖(WithLp.equiv p (ι → β)).symm 1‖ = (Fintype.card ι : ℝ≥0) ^ (1 / p).toReal * ‖(1 : β)‖ 
goal: ‖(WithLp.equiv p (ι → β)).symm 1‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖1‖

full_name: PiLp.continuousLinearEquiv_symm_apply
code: /-- `WithLp.equiv` as a continuous linear equivalence. -/
@[simps! (config := .asFn) apply symm_apply]
protected def continuousLinearEquiv : PiLp p β ≃L[𝕜] ∀ i, β i 
goal: ⇑(PiLp.continuousLinearEquiv p 𝕜 β).symm = ⇑(WithLp.equiv p ((i : ι) → β i)).symm

full_name: PiLp.continuousLinearEquiv
code: /-- `WithLp.equiv` as a continuous linear equivalence. -/
@[simps! (config := .asFn) apply symm_apply]
protected def continuousLinearEquiv : PiLp p β ≃L[𝕜] ∀ i, β i 
goal: PiLp p β ≃L[𝕜] (i : ι) → β i

full_name: PiLp.continuousLinearEquiv_apply
code: /-- `WithLp.equiv` as a continuous linear equivalence. -/
@[simps! (config := .asFn) apply symm_apply]
protected def continuousLinearEquiv : PiLp p β ≃L[𝕜] ∀ i, β i 
goal: ⇑(PiLp.continuousLinearEquiv p 𝕜 β) = ⇑(WithLp.equiv p ((i : ι) → β i))

full_name: PiLp.basisFun
code: /-- A version of `Pi.basisFun` for `PiLp`. -/
def basisFun : Basis ι 𝕜 (PiLp p fun _ : ι => 𝕜) 
goal: Basis ι 𝕜 (PiLp p fun x => 𝕜)

full_name: PiLp.basisFun_apply
code: @[simp]
theorem basisFun_apply [DecidableEq ι] (i) :
    basisFun p 𝕜 ι i = (WithLp.equiv p _).symm (Pi.single i 1) 
goal: (PiLp.basisFun p 𝕜 ι) i = (WithLp.equiv p (ι → 𝕜)).symm (Pi.single i 1)

full_name: PiLp.basisFun_repr
code: @[simp]
theorem basisFun_repr (x : PiLp p fun _ : ι => 𝕜) (i : ι) : (basisFun p 𝕜 ι).repr x i = x i 
goal: ((PiLp.basisFun p 𝕜 ι).repr x) i = x i

full_name: PiLp.basisFun_equivFun
code: @[simp]
theorem basisFun_equivFun : (basisFun p 𝕜 ι).equivFun = WithLp.linearEquiv p 𝕜 (ι → 𝕜) 
goal: (PiLp.basisFun p 𝕜 ι).equivFun = WithLp.linearEquiv p 𝕜 (ι → 𝕜)

full_name: PiLp.basisFun_eq_pi_basisFun
code: theorem basisFun_eq_pi_basisFun :
    basisFun p 𝕜 ι = (Pi.basisFun 𝕜 ι).map (WithLp.linearEquiv p 𝕜 (ι → 𝕜)).symm 
goal: PiLp.basisFun p 𝕜 ι = (Pi.basisFun 𝕜 ι).map (WithLp.linearEquiv p 𝕜 (ι → 𝕜)).symm

full_name: PiLp.basisFun_map
code: @[simp]
theorem basisFun_map :
    (basisFun p 𝕜 ι).map (WithLp.linearEquiv p 𝕜 (ι → 𝕜)) = Pi.basisFun 𝕜 ι 
goal: (PiLp.basisFun p 𝕜 ι).map (WithLp.linearEquiv p 𝕜 (ι → 𝕜)) = Pi.basisFun 𝕜 ι

full_name: PiLp.basis_toMatrix_basisFun_mul
code: nonrec theorem basis_toMatrix_basisFun_mul [Fintype ι]
    {𝕜} [SeminormedCommRing 𝕜] (b : Basis ι 𝕜 (PiLp p fun _ : ι => 𝕜))
    (A : Matrix ι ι 𝕜) :
    b.toMatrix (PiLp.basisFun _ _ _) * A =
      Matrix.of fun i j => b.repr ((WithLp.equiv _ _).symm (Aᵀ j)) i 
goal: b.toMatrix ⇑(PiLp.basisFun p 𝕜 ι) * A =
  Matrix.of fun i j => (b.repr ((WithLp.equiv p ((i : ι) → (fun x => 𝕜) i)).symm (A.transpose j))) i