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

full_name: Memℓp
code: /-- The property that `f : ∀ i : α, E i`
* is finitely supported, if `p = 0`, or
* admits an upper bound for `Set.range (fun i ↦ ‖f i‖)`, if `p = ∞`, or
* has the series `∑' i, ‖f i‖ ^ p` be summable, if `0 < p < ∞`. -/
def Memℓp (f : ∀ i, E i) (p : ℝ≥0∞) : Prop 
goal: Prop

full_name: memℓp_zero_iff
code: theorem memℓp_zero_iff {f : ∀ i, E i} : Memℓp f 0 ↔ Set.Finite { i | f i ≠ 0 } 
goal: Memℓp f 0 ↔ {i | f i ≠ 0}.Finite

full_name: memℓp_zero
code: theorem memℓp_zero {f : ∀ i, E i} (hf : Set.Finite { i | f i ≠ 0 }) : Memℓp f 0 
goal: Memℓp f 0

full_name: memℓp_infty_iff
code: theorem memℓp_infty_iff {f : ∀ i, E i} : Memℓp f ∞ ↔ BddAbove (Set.range fun i => ‖f i‖) 
goal: Memℓp f ⊤ ↔ BddAbove (Set.range fun i => ‖f i‖)

full_name: memℓp_infty
code: theorem memℓp_infty {f : ∀ i, E i} (hf : BddAbove (Set.range fun i => ‖f i‖)) : Memℓp f ∞ 
goal: Memℓp f ⊤

full_name: memℓp_gen_iff
code: theorem memℓp_gen_iff (hp : 0 < p.toReal) {f : ∀ i, E i} :
    Memℓp f p ↔ Summable fun i => ‖f i‖ ^ p.toReal 
goal: Memℓp f p ↔ Summable fun i => ‖f i‖ ^ p.toReal

full_name: memℓp_gen
code: theorem memℓp_gen {f : ∀ i, E i} (hf : Summable fun i => ‖f i‖ ^ p.toReal) : Memℓp f p 
goal: Memℓp f p

full_name: memℓp_gen'
code: theorem memℓp_gen' {C : ℝ} {f : ∀ i, E i} (hf : ∀ s : Finset α, ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ C) :
    Memℓp f p 
goal: Memℓp f p

full_name: zero_memℓp
code: theorem zero_memℓp : Memℓp (0 : ∀ i, E i) p 
goal: Memℓp 0 p

full_name: zero_mem_ℓp'
code: theorem zero_mem_ℓp' : Memℓp (fun i : α => (0 : E i)) p 
goal: Memℓp (fun i => 0) p

full_name: Memℓp.finite_dsupport
code: theorem finite_dsupport {f : ∀ i, E i} (hf : Memℓp f 0) : Set.Finite { i | f i ≠ 0 } 
goal: {i | f i ≠ 0}.Finite

full_name: Memℓp.bddAbove
code: theorem bddAbove {f : ∀ i, E i} (hf : Memℓp f ∞) : BddAbove (Set.range fun i => ‖f i‖) 
goal: BddAbove (Set.range fun i => ‖f i‖)

full_name: Memℓp.summable
code: theorem summable (hp : 0 < p.toReal) {f : ∀ i, E i} (hf : Memℓp f p) :
    Summable fun i => ‖f i‖ ^ p.toReal 
goal: Summable fun i => ‖f i‖ ^ p.toReal

full_name: Memℓp.neg
code: theorem neg {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (-f) p 
goal: Memℓp (-f) p

full_name: Memℓp.neg_iff
code: @[simp]
theorem neg_iff {f : ∀ i, E i} : Memℓp (-f) p ↔ Memℓp f p 
goal: Memℓp (-f) p ↔ Memℓp f p

full_name: Memℓp.of_exponent_ge
code: theorem of_exponent_ge {p q : ℝ≥0∞} {f : ∀ i, E i} (hfq : Memℓp f q) (hpq : q ≤ p) : Memℓp f p 
goal: Memℓp f p

full_name: Memℓp.add
code: theorem add {f g : ∀ i, E i} (hf : Memℓp f p) (hg : Memℓp g p) : Memℓp (f + g) p 
goal: Memℓp (f + g) p

full_name: Memℓp.sub
code: theorem sub {f g : ∀ i, E i} (hf : Memℓp f p) (hg : Memℓp g p) : Memℓp (f - g) p 
goal: Memℓp (f - g) p

full_name: Memℓp.finset_sum
code: theorem finset_sum {ι} (s : Finset ι) {f : ι → ∀ i, E i} (hf : ∀ i ∈ s, Memℓp (f i) p) :
    Memℓp (fun a => ∑ i ∈ s, f i a) p 
goal: Memℓp (fun a => ∑ i ∈ s, f i a) p

full_name: Memℓp.const_smul
code: theorem const_smul {f : ∀ i, E i} (hf : Memℓp f p) (c : 𝕜) : Memℓp (c • f) p 
goal: Memℓp (c • f) p

full_name: Memℓp.const_mul
code: theorem const_mul {f : α → 𝕜} (hf : Memℓp f p) (c : 𝕜) : Memℓp (fun x => c * f x) p 
goal: Memℓp (fun x => c * f x) p

full_name: PreLp
code: /-- We define `PreLp E` to be a type synonym for `∀ i, E i` which, importantly, does not inherit
the `pi` topology on `∀ i, E i` (otherwise this topology would descend to `lp E p` and conflict
with the normed group topology we will later equip it with.)

We choose to deal with this issue by making a type synonym for `∀ i, E i` rather than for the `lp`
subgroup itself, because this allows all the spaces `lp E p` (for varying `p`) to be subgroups of
the same ambient group, which permits lemma statements like `lp.monotone` (below). -/
@[nolint unusedArguments]
def PreLp (E : α → Type*) [∀ i, NormedAddCommGroup (E i)] : Type _ 
goal: Type (max u_1 u_3)

full_name: instAddCommGroupPreLp
code: instance : AddCommGroup (PreLp E) 
goal: AddCommGroup (PreLp E)

full_name: PreLp.unique
code: instance PreLp.unique [IsEmpty α] : Unique (PreLp E) 
goal: Unique (PreLp E)

full_name: lp
code: /-- lp space -/
def lp (E : α → Type*) [∀ i, NormedAddCommGroup (E i)] (p : ℝ≥0∞) : AddSubgroup (PreLp E) 
goal: AddSubgroup (PreLp E)

full_name: lp.«_aux_Mathlib_Analysis_Normed_Lp_lpSpace___macroRules_lp_termℓ^∞(_,_)_1»
code: @[inherit_doc] scoped[lp] notation "ℓ^∞(" ι ", " E ")" => lp (fun i : ι => E) ∞
goal: Lean.Macro

full_name: lp._aux_Mathlib_Analysis_Normed_Lp_lpSpace___unexpand_lp_1
code: @[inherit_doc] scoped[lp] notation "ℓ^∞(" ι ", " E ")" => lp (fun i : ι => E) ∞
goal: Lean.PrettyPrinter.Unexpander

full_name: lp.«_aux_Mathlib_Analysis_Normed_Lp_lpSpace___macroRules_lp_termℓ^∞(_)_1»
code: @[inherit_doc] scoped[lp] notation "ℓ^∞(" ι ")" => lp (fun i : ι => ℝ) ∞
goal: Lean.Macro

full_name: lp._aux_Mathlib_Analysis_Normed_Lp_lpSpace___unexpand_lp_2
code: @[inherit_doc] scoped[lp] notation "ℓ^∞(" ι ")" => lp (fun i : ι => ℝ) ∞
goal: Lean.PrettyPrinter.Unexpander

full_name: lp.instCoeOutSubtypePreLpMemAddSubgroupForall
code: instance : CoeOut (lp E p) (∀ i, E i) 
goal: CoeOut (↥(lp E p)) ((i : α) → E i)

full_name: lp.coeFun
code: instance coeFun : CoeFun (lp E p) fun _ => ∀ i, E i 
goal: CoeFun ↥(lp E p) fun x => (i : α) → E i

full_name: lp.ext
code: @[ext]
theorem ext {f g : lp E p} (h : (f : ∀ i, E i) = g) : f = g 
goal: f = g

full_name: lp.ext_iff
code: protected theorem ext_iff {f g : lp E p} : f = g ↔ (f : ∀ i, E i) = g 
goal: f = g ↔ ↑f = ↑g

full_name: lp.eq_zero'
code: theorem eq_zero' [IsEmpty α] (f : lp E p) : f = 0 
goal: f = 0

full_name: lp.monotone
code: protected theorem monotone {p q : ℝ≥0∞} (hpq : q ≤ p) : lp E q ≤ lp E p 
goal: lp E q ≤ lp E p

full_name: lp.memℓp
code: protected theorem memℓp (f : lp E p) : Memℓp f p 
goal: Memℓp (↑f) p

full_name: lp.coeFn_zero
code: @[simp]
theorem coeFn_zero : ⇑(0 : lp E p) = 0 
goal: ↑0 = 0

full_name: lp.coeFn_neg
code: @[simp]
theorem coeFn_neg (f : lp E p) : ⇑(-f) = -f 
goal: ↑(-f) = -↑f

full_name: lp.coeFn_add
code: @[simp]
theorem coeFn_add (f g : lp E p) : ⇑(f + g) = f + g 
goal: ↑(f + g) = ↑f + ↑g

full_name: lp.coeFn_sum
code: theorem coeFn_sum {ι : Type*} (f : ι → lp E p) (s : Finset ι) :
    ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, ⇑(f i) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: lp.coeFn_sub
code: @[simp]
theorem coeFn_sub (f g : lp E p) : ⇑(f - g) = f - g 
goal: ↑(f - g) = ↑f - ↑g

full_name: lp.instNormSubtypePreLpMemAddSubgroup
code: instance : Norm (lp E p) 
goal: Norm ↥(lp E p)

full_name: lp.norm_eq_card_dsupport
code: theorem norm_eq_card_dsupport (f : lp E 0) : ‖f‖ = (lp.memℓp f).finite_dsupport.toFinset.card 
goal: ‖f‖ = ↑⋯.toFinset.card

full_name: lp.norm_eq_ciSup
code: theorem norm_eq_ciSup (f : lp E ∞) : ‖f‖ = ⨆ i, ‖f i‖ 
goal: ‖f‖ = ⨆ i, ‖↑f i‖

full_name: lp.isLUB_norm
code: theorem isLUB_norm [Nonempty α] (f : lp E ∞) : IsLUB (Set.range fun i => ‖f i‖) ‖f‖ 
goal: IsLUB (Set.range fun i => ‖↑f i‖) ‖f‖

full_name: lp.norm_eq_tsum_rpow
code: theorem norm_eq_tsum_rpow (hp : 0 < p.toReal) (f : lp E p) :
    ‖f‖ = (∑' i, ‖f i‖ ^ p.toReal) ^ (1 / p.toReal) 
goal: ‖f‖ = (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)

full_name: lp.norm_rpow_eq_tsum
code: theorem norm_rpow_eq_tsum (hp : 0 < p.toReal) (f : lp E p) :
    ‖f‖ ^ p.toReal = ∑' i, ‖f i‖ ^ p.toReal 
goal: ‖f‖ ^ p.toReal = ∑' (i : α), ‖↑f i‖ ^ p.toReal

full_name: lp.hasSum_norm
code: theorem hasSum_norm (hp : 0 < p.toReal) (f : lp E p) :
    HasSum (fun i => ‖f i‖ ^ p.toReal) (‖f‖ ^ p.toReal) 
goal: HasSum (fun i => ‖↑f i‖ ^ p.toReal) (‖f‖ ^ p.toReal)

full_name: lp.norm_nonneg'
code: theorem norm_nonneg' (f : lp E p) : 0 ≤ ‖f‖ 
goal: 0 ≤ ‖f‖

full_name: lp.norm_zero
code: @[simp]
theorem norm_zero : ‖(0 : lp E p)‖ = 0 
goal: ‖0‖ = 0

full_name: lp.norm_eq_zero_iff
code: theorem norm_eq_zero_iff {f : lp E p} : ‖f‖ = 0 ↔ f = 0 
goal: ‖f‖ = 0 ↔ f = 0

full_name: lp.eq_zero_iff_coeFn_eq_zero
code: theorem eq_zero_iff_coeFn_eq_zero {f : lp E p} : f = 0 ↔ ⇑f = 0 
goal: f = 0 ↔ ↑f = 0

full_name: lp.norm_neg
code: @[simp]
theorem norm_neg ⦃f : lp E p⦄ : ‖-f‖ = ‖f‖ 
goal: ‖-f‖ = ‖f‖

full_name: lp.normedAddCommGroup
code: instance normedAddCommGroup [hp : Fact (1 ≤ p)] : NormedAddCommGroup (lp E p) 
goal: NormedAddCommGroup ↥(lp E p)

full_name: lp.tsum_mul_le_mul_norm
code: /-- Hölder inequality -/
protected theorem tsum_mul_le_mul_norm {p q : ℝ≥0∞} (hpq : p.toReal.IsConjExponent q.toReal)
    (f : lp E p) (g : lp E q) :
    (Summable fun i => ‖f i‖ * ‖g i‖) ∧ ∑' i, ‖f i‖ * ‖g i‖ ≤ ‖f‖ * ‖g‖ 
goal: (Summable fun i => ‖↑f i‖ * ‖↑g i‖) ∧ ∑' (i : α), ‖↑f i‖ * ‖↑g i‖ ≤ ‖f‖ * ‖g‖

full_name: lp.summable_mul
code: protected theorem summable_mul {p q : ℝ≥0∞} (hpq : p.toReal.IsConjExponent q.toReal)
    (f : lp E p) (g : lp E q) : Summable fun i => ‖f i‖ * ‖g i‖ 
goal: Summable fun i => ‖↑f i‖ * ‖↑g i‖

full_name: lp.tsum_mul_le_mul_norm'
code: protected theorem tsum_mul_le_mul_norm' {p q : ℝ≥0∞} (hpq : p.toReal.IsConjExponent q.toReal)
    (f : lp E p) (g : lp E q) : ∑' i, ‖f i‖ * ‖g i‖ ≤ ‖f‖ * ‖g‖ 
goal: ∑' (i : α), ‖↑f i‖ * ‖↑g i‖ ≤ ‖f‖ * ‖g‖

full_name: lp.norm_apply_le_norm
code: theorem norm_apply_le_norm (hp : p ≠ 0) (f : lp E p) (i : α) : ‖f i‖ ≤ ‖f‖ 
goal: ‖↑f i‖ ≤ ‖f‖

full_name: lp.sum_rpow_le_norm_rpow
code: theorem sum_rpow_le_norm_rpow (hp : 0 < p.toReal) (f : lp E p) (s : Finset α) :
    ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ ‖f‖ ^ p.toReal 
goal: ∑ i ∈ s, ‖↑f i‖ ^ p.toReal ≤ ‖f‖ ^ p.toReal

full_name: lp.norm_le_of_forall_le'
code: theorem norm_le_of_forall_le' [Nonempty α] {f : lp E ∞} (C : ℝ) (hCf : ∀ i, ‖f i‖ ≤ C) :
    ‖f‖ ≤ C 
goal: ‖f‖ ≤ C

full_name: lp.norm_le_of_forall_le
code: theorem norm_le_of_forall_le {f : lp E ∞} {C : ℝ} (hC : 0 ≤ C) (hCf : ∀ i, ‖f i‖ ≤ C) :
    ‖f‖ ≤ C 
goal: ‖f‖ ≤ C

full_name: lp.norm_le_of_tsum_le
code: theorem norm_le_of_tsum_le (hp : 0 < p.toReal) {C : ℝ} (hC : 0 ≤ C) {f : lp E p}
    (hf : ∑' i, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal) : ‖f‖ ≤ C 
goal: ‖f‖ ≤ C

full_name: lp.norm_le_of_forall_sum_le
code: theorem norm_le_of_forall_sum_le (hp : 0 < p.toReal) {C : ℝ} (hC : 0 ≤ C) {f : lp E p}
    (hf : ∀ s : Finset α, ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal) : ‖f‖ ≤ C 
goal: ‖f‖ ≤ C

full_name: lp.instModulePreLp
code: instance : Module 𝕜 (PreLp E) 
goal: Module 𝕜 (PreLp E)

full_name: lp.instSMulCommClassPreLp
code: instance [∀ i, SMulCommClass 𝕜' 𝕜 (E i)] : SMulCommClass 𝕜' 𝕜 (PreLp E) 
goal: SMulCommClass 𝕜' 𝕜 (PreLp E)

full_name: lp.instIsScalarTowerPreLp
code: instance [SMul 𝕜' 𝕜] [∀ i, IsScalarTower 𝕜' 𝕜 (E i)] : IsScalarTower 𝕜' 𝕜 (PreLp E) 
goal: IsScalarTower 𝕜' 𝕜 (PreLp E)

full_name: lp.instIsCentralScalarPreLp
code: instance [∀ i, Module 𝕜ᵐᵒᵖ (E i)] [∀ i, IsCentralScalar 𝕜 (E i)] : IsCentralScalar 𝕜 (PreLp E) 
goal: IsCentralScalar 𝕜 (PreLp E)

full_name: lp.mem_lp_const_smul
code: theorem mem_lp_const_smul (c : 𝕜) (f : lp E p) : c • (f : PreLp E) ∈ lp E p 
goal: c • ↑f ∈ lp E p

full_name: lpSubmodule
code: /-- The `𝕜`-submodule of elements of `∀ i : α, E i` whose `lp` norm is finite. This is `lp E p`,
with extra structure. -/
def _root_.lpSubmodule : Submodule 𝕜 (PreLp E) 
goal: Submodule 𝕜 (PreLp E)

full_name: lp.coe_lpSubmodule
code: theorem coe_lpSubmodule : (lpSubmodule E p 𝕜).toAddSubgroup = lp E p 
goal: (lpSubmodule E p 𝕜).toAddSubgroup = lp E p

full_name: lp.instModuleSubtypePreLpMemAddSubgroup
code: instance : Module 𝕜 (lp E p) 
goal: Module 𝕜 ↥(lp E p)

full_name: lp.coeFn_smul
code: @[simp]
theorem coeFn_smul (c : 𝕜) (f : lp E p) : ⇑(c • f) = c • ⇑f 
goal: ↑(c • f) = c • ↑f

full_name: lp.instSMulCommClassSubtypePreLpMemAddSubgroup
code: instance [∀ i, SMulCommClass 𝕜' 𝕜 (E i)] : SMulCommClass 𝕜' 𝕜 (lp E p) 
goal: SMulCommClass 𝕜' 𝕜 ↥(lp E p)

full_name: lp.instIsScalarTowerSubtypePreLpMemAddSubgroup
code: instance [SMul 𝕜' 𝕜] [∀ i, IsScalarTower 𝕜' 𝕜 (E i)] : IsScalarTower 𝕜' 𝕜 (lp E p) 
goal: IsScalarTower 𝕜' 𝕜 ↥(lp E p)

full_name: lp.instIsCentralScalarSubtypePreLpMemAddSubgroup
code: instance [∀ i, Module 𝕜ᵐᵒᵖ (E i)] [∀ i, IsCentralScalar 𝕜 (E i)] : IsCentralScalar 𝕜 (lp E p) 
goal: IsCentralScalar 𝕜 ↥(lp E p)

full_name: lp.norm_const_smul_le
code: theorem norm_const_smul_le (hp : p ≠ 0) (c : 𝕜) (f : lp E p) : ‖c • f‖ ≤ ‖c‖ * ‖f‖ 
goal: ‖c • f‖ ≤ ‖c‖ * ‖f‖

full_name: lp.instBoundedSMulSubtypePreLpMemAddSubgroup
code: instance [Fact (1 ≤ p)] : BoundedSMul 𝕜 (lp E p) 
goal: BoundedSMul 𝕜 ↥(lp E p)

full_name: lp.norm_const_smul
code: theorem norm_const_smul (hp : p ≠ 0) {c : 𝕜} (f : lp E p) : ‖c • f‖ = ‖c‖ * ‖f‖ 
goal: ‖c • f‖ = ‖c‖ * ‖f‖

full_name: lp.instNormedSpace
code: instance instNormedSpace [Fact (1 ≤ p)] : NormedSpace 𝕜 (lp E p) 
goal: NormedSpace 𝕜 ↥(lp E p)

full_name: Memℓp.star_mem
code: theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p 
goal: Memℓp (star f) p

full_name: Memℓp.star_iff
code: @[simp]
theorem _root_.Memℓp.star_iff {f : ∀ i, E i} : Memℓp (star f) p ↔ Memℓp f p 
goal: Memℓp (star f) p ↔ Memℓp f p

full_name: lp.instStarSubtypePreLpMemAddSubgroup
code: instance : Star (lp E p) 
goal: Star ↥(lp E p)

full_name: lp.coeFn_star
code: @[simp]
theorem coeFn_star (f : lp E p) : ⇑(star f) = star (⇑f) 
goal: ↑(star f) = star ↑f

full_name: lp.star_apply
code: @[simp]
protected theorem star_apply (f : lp E p) (i : α) : star f i = star (f i) 
goal: ↑(star f) i = star (↑f i)

full_name: lp.instInvolutiveStar
code: instance instInvolutiveStar : InvolutiveStar (lp E p) 
goal: InvolutiveStar ↥(lp E p)

full_name: lp.instStarAddMonoid
code: instance instStarAddMonoid : StarAddMonoid (lp E p) 
goal: StarAddMonoid ↥(lp E p)

full_name: lp.instNormedStarGroupSubtypePreLpMemAddSubgroup
code: instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) 
goal: NormedStarGroup ↥(lp E p)

full_name: lp.instStarModuleSubtypePreLpMemAddSubgroup
code: instance : StarModule 𝕜 (lp E p) 
goal: StarModule 𝕜 ↥(lp E p)

full_name: Memℓp.infty_mul
code: theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞ 
goal: Memℓp (f * g) ⊤

full_name: lp.instMulSubtypePreLpMemAddSubgroupTopENNReal
code: instance : Mul (lp B ∞) 
goal: Mul ↥(lp B ⊤)

full_name: lp.infty_coeFn_mul
code: @[simp]
theorem infty_coeFn_mul (f g : lp B ∞) : ⇑(f * g) = ⇑f * ⇑g 
goal: ↑(f * g) = ↑f * ↑g

full_name: lp.nonUnitalRing
code: instance nonUnitalRing : NonUnitalRing (lp B ∞) 
goal: NonUnitalRing ↥(lp B ⊤)

full_name: lp.nonUnitalNormedRing
code: instance nonUnitalNormedRing : NonUnitalNormedRing (lp B ∞) 
goal: NonUnitalNormedRing ↥(lp B ⊤)

full_name: lp.infty_isScalarTower
code: instance infty_isScalarTower {𝕜} [NormedRing 𝕜] [∀ i, Module 𝕜 (B i)] [∀ i, BoundedSMul 𝕜 (B i)]
    [∀ i, IsScalarTower 𝕜 (B i) (B i)] : IsScalarTower 𝕜 (lp B ∞) (lp B ∞) 
goal: IsScalarTower 𝕜 ↥(lp B ⊤) ↥(lp B ⊤)

full_name: lp.infty_smulCommClass
code: instance infty_smulCommClass {𝕜} [NormedRing 𝕜] [∀ i, Module 𝕜 (B i)] [∀ i, BoundedSMul 𝕜 (B i)]
    [∀ i, SMulCommClass 𝕜 (B i) (B i)] : SMulCommClass 𝕜 (lp B ∞) (lp B ∞) 
goal: SMulCommClass 𝕜 ↥(lp B ⊤) ↥(lp B ⊤)

full_name: lp.inftyStarRing
code: instance inftyStarRing : StarRing (lp B ∞) 
goal: StarRing ↥(lp B ⊤)

full_name: lp.inftyCstarRing
code: instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) 
goal: CstarRing ↥(lp B ⊤)

full_name: PreLp.ring
code: instance _root_.PreLp.ring : Ring (PreLp B) 
goal: Ring (PreLp B)

full_name: one_memℓp_infty
code: theorem _root_.one_memℓp_infty : Memℓp (1 : ∀ i, B i) ∞ 
goal: Memℓp 1 ⊤

full_name: lpInftySubring
code: /-- The `𝕜`-subring of elements of `∀ i : α, B i` whose `lp` norm is finite. This is `lp E ∞`,
with extra structure. -/
def _root_.lpInftySubring : Subring (PreLp B) 
goal: Subring (PreLp B)

full_name: lp.inftyRing
code: instance inftyRing : Ring (lp B ∞) 
goal: Ring ↥(lp B ⊤)

full_name: Memℓp.infty_pow
code: theorem _root_.Memℓp.infty_pow {f : ∀ i, B i} (hf : Memℓp f ∞) (n : ℕ) : Memℓp (f ^ n) ∞ 
goal: Memℓp (f ^ n) ⊤

full_name: natCast_memℓp_infty
code: theorem _root_.natCast_memℓp_infty (n : ℕ) : Memℓp (n : ∀ i, B i) ∞ 
goal: Memℓp ↑n ⊤

full_name: intCast_memℓp_infty
code: theorem _root_.intCast_memℓp_infty (z : ℤ) : Memℓp (z : ∀ i, B i) ∞ 
goal: Memℓp ↑z ⊤

full_name: lp.infty_coeFn_one
code: @[simp]
theorem infty_coeFn_one : ⇑(1 : lp B ∞) = 1 
goal: ↑1 = 1

full_name: lp.infty_coeFn_pow
code: @[simp]
theorem infty_coeFn_pow (f : lp B ∞) (n : ℕ) : ⇑(f ^ n) = (⇑f) ^ n 
goal: ↑(f ^ n) = ↑f ^ n

full_name: lp.infty_coeFn_natCast
code: @[simp]
theorem infty_coeFn_natCast (n : ℕ) : ⇑(n : lp B ∞) = n 
goal: ↑↑n = ↑n

full_name: lp.infty_coeFn_intCast
code: @[simp]
theorem infty_coeFn_intCast (z : ℤ) : ⇑(z : lp B ∞) = z 
goal: ↑↑z = ↑z

full_name: lp.instNormOneClassSubtypePreLpMemAddSubgroupTopENNRealOfNonempty
code: instance [Nonempty I] : NormOneClass (lp B ∞) 
goal: NormOneClass ↥(lp B ⊤)

full_name: lp.inftyNormedRing
code: instance inftyNormedRing : NormedRing (lp B ∞) 
goal: NormedRing ↥(lp B ⊤)

full_name: lp.inftyCommRing
code: instance inftyCommRing : CommRing (lp B ∞) 
goal: CommRing ↥(lp B ⊤)

full_name: lp.inftyNormedCommRing
code: instance inftyNormedCommRing : NormedCommRing (lp B ∞) 
goal: NormedCommRing ↥(lp B ⊤)

full_name: Pi.algebraOfNormedAlgebra
code: /-- A variant of `Pi.algebra` that lean can't find otherwise. -/
instance _root_.Pi.algebraOfNormedAlgebra : Algebra 𝕜 (∀ i, B i) 
goal: Algebra 𝕜 ((i : I) → B i)

full_name: PreLp.algebra
code: instance _root_.PreLp.algebra : Algebra 𝕜 (PreLp B) 
goal: Algebra 𝕜 (PreLp B)

full_name: algebraMap_memℓp_infty
code: theorem _root_.algebraMap_memℓp_infty (k : 𝕜) : Memℓp (algebraMap 𝕜 (∀ i, B i) k) ∞ 
goal: Memℓp ((algebraMap 𝕜 ((i : I) → B i)) k) ⊤

full_name: lpInftySubalgebra
code: /-- The `𝕜`-subalgebra of elements of `∀ i : α, B i` whose `lp` norm is finite. This is `lp E ∞`,
with extra structure. -/
def _root_.lpInftySubalgebra : Subalgebra 𝕜 (PreLp B) 
goal: Subalgebra 𝕜 (PreLp B)

full_name: lp.inftyNormedAlgebra
code: instance inftyNormedAlgebra : NormedAlgebra 𝕜 (lp B ∞) 
goal: NormedAlgebra 𝕜 ↥(lp B ⊤)

full_name: lp.single
code: /-- The element of `lp E p` which is `a : E i` at the index `i`, and zero elsewhere. -/
protected def single (p) (i : α) (a : E i) : lp E p 
goal: ↥(lp E p)

full_name: lp.single_apply
code: protected theorem single_apply (p) (i : α) (a : E i) (j : α) :
    lp.single p i a j = if h : j = i then Eq.ndrec a h.symm else 0 
goal: ↑(lp.single p i a) j = if h : j = i then ⋯ ▸ a else 0

full_name: lp.single_apply_self
code: protected theorem single_apply_self (p) (i : α) (a : E i) : lp.single p i a i = a 
goal: ↑(lp.single p i a) i = a

full_name: lp.single_apply_ne
code: protected theorem single_apply_ne (p) (i : α) (a : E i) {j : α} (hij : j ≠ i) :
    lp.single p i a j = 0 
goal: ↑(lp.single p i a) j = 0

full_name: lp.single_neg
code: @[simp]
protected theorem single_neg (p) (i : α) (a : E i) : lp.single p i (-a) = -lp.single p i a 
goal: lp.single p i (-a) = -lp.single p i a

full_name: lp.single_smul
code: @[simp]
protected theorem single_smul (p) (i : α) (a : E i) (c : 𝕜) :
    lp.single p i (c • a) = c • lp.single p i a 
goal: lp.single p i (c • a) = c • lp.single p i a

full_name: lp.norm_sum_single
code: protected theorem norm_sum_single (hp : 0 < p.toReal) (f : ∀ i, E i) (s : Finset α) :
    ‖∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal = ∑ i ∈ s, ‖f i‖ ^ p.toReal 
goal: ‖∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal = ∑ i ∈ s, ‖f i‖ ^ p.toReal

full_name: lp.norm_single
code: protected theorem norm_single (hp : 0 < p.toReal) (f : ∀ i, E i) (i : α) :
    ‖lp.single p i (f i)‖ = ‖f i‖ 
goal: ‖lp.single p i (f i)‖ = ‖f i‖

full_name: lp.norm_sub_norm_compl_sub_single
code: protected theorem norm_sub_norm_compl_sub_single (hp : 0 < p.toReal) (f : lp E p) (s : Finset α) :
    ‖f‖ ^ p.toReal - ‖f - ∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal =
      ∑ i ∈ s, ‖f i‖ ^ p.toReal 
goal: ‖f‖ ^ p.toReal - ‖f - ∑ i ∈ s, lp.single p i (↑f i)‖ ^ p.toReal = ∑ i ∈ s, ‖↑f i‖ ^ p.toReal

full_name: lp.norm_compl_sum_single
code: protected theorem norm_compl_sum_single (hp : 0 < p.toReal) (f : lp E p) (s : Finset α) :
    ‖f - ∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal = ‖f‖ ^ p.toReal - ∑ i ∈ s, ‖f i‖ ^ p.toReal 
goal: ‖f - ∑ i ∈ s, lp.single p i (↑f i)‖ ^ p.toReal = ‖f‖ ^ p.toReal - ∑ i ∈ s, ‖↑f i‖ ^ p.toReal

full_name: lp.hasSum_single
code: /-- The canonical finitely-supported approximations to an element `f` of `lp` converge to it, in the
`lp` topology. -/
protected theorem hasSum_single [Fact (1 ≤ p)] (hp : p ≠ ⊤) (f : lp E p) :
    HasSum (fun i : α => lp.single p i (f i : E i)) f 
goal: HasSum (fun i => lp.single p i (↑f i)) f

full_name: lp.uniformContinuous_coe
code: /-- The coercion from `lp E p` to `∀ i, E i` is uniformly continuous. -/
theorem uniformContinuous_coe [_i : Fact (1 ≤ p)] :
    UniformContinuous (α := lp E p) ((↑) : lp E p → ∀ i, E i) 
goal: UniformContinuous Subtype.val

full_name: lp.norm_apply_le_of_tendsto
code: theorem norm_apply_le_of_tendsto {C : ℝ} {F : ι → lp E ∞} (hCF : ∀ᶠ k in l, ‖F k‖ ≤ C)
    {f : ∀ a, E a} (hf : Tendsto (id fun i => F i : ι → ∀ a, E a) l (𝓝 f)) (a : α) : ‖f a‖ ≤ C 
goal: ‖f a‖ ≤ C

full_name: lp.sum_rpow_le_of_tendsto
code: theorem sum_rpow_le_of_tendsto (hp : p ≠ ∞) {C : ℝ} {F : ι → lp E p} (hCF : ∀ᶠ k in l, ‖F k‖ ≤ C)
    {f : ∀ a, E a} (hf : Tendsto (id fun i => F i : ι → ∀ a, E a) l (𝓝 f)) (s : Finset α) :
    ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal 
goal: ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal

full_name: lp.norm_le_of_tendsto
code: /-- "Semicontinuity of the `lp` norm": If all sufficiently large elements of a sequence in `lp E p`
 have `lp` norm `≤ C`, then the pointwise limit, if it exists, also has `lp` norm `≤ C`. -/
theorem norm_le_of_tendsto {C : ℝ} {F : ι → lp E p} (hCF : ∀ᶠ k in l, ‖F k‖ ≤ C) {f : lp E p}
    (hf : Tendsto (id fun i => F i : ι → ∀ a, E a) l (𝓝 f)) : ‖f‖ ≤ C 
goal: ‖f‖ ≤ C

full_name: lp.memℓp_of_tendsto
code: /-- If `f` is the pointwise limit of a bounded sequence in `lp E p`, then `f` is in `lp E p`. -/
theorem memℓp_of_tendsto {F : ι → lp E p} (hF : Bornology.IsBounded (Set.range F)) {f : ∀ a, E a}
    (hf : Tendsto (id fun i => F i : ι → ∀ a, E a) l (𝓝 f)) : Memℓp f p 
goal: Memℓp f p

full_name: lp.tendsto_lp_of_tendsto_pi
code: /-- If a sequence is Cauchy in the `lp E p` topology and pointwise convergent to an element `f` of
`lp E p`, then it converges to `f` in the `lp E p` topology. -/
theorem tendsto_lp_of_tendsto_pi {F : ℕ → lp E p} (hF : CauchySeq F) {f : lp E p}
    (hf : Tendsto (id fun i => F i : ℕ → ∀ a, E a) atTop (𝓝 f)) : Tendsto F atTop (𝓝 f) 
goal: Filter.Tendsto F Filter.atTop (nhds f)

full_name: lp.completeSpace
code: instance completeSpace : CompleteSpace (lp E p) 
goal: CompleteSpace ↥(lp E p)

full_name: LipschitzWith.uniformly_bounded
code: lemma LipschitzWith.uniformly_bounded [PseudoMetricSpace α] (g : α → ι → ℝ) {K : ℝ≥0}
    (hg : ∀ i, LipschitzWith K (g · i)) (a₀ : α) (hga₀b : Memℓp (g a₀) ∞) (a : α) :
    Memℓp (g a) ∞ 
goal: Memℓp (g a) ⊤

full_name: LipschitzOnWith.coordinate
code: theorem LipschitzOnWith.coordinate [PseudoMetricSpace α] (f : α → ℓ^∞(ι)) (s : Set α) (K : ℝ≥0) :
    LipschitzOnWith K f s ↔ ∀ i : ι, LipschitzOnWith K (fun a : α ↦ f a i) s 
goal: LipschitzOnWith K f s ↔ ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) s

full_name: LipschitzWith.coordinate
code: theorem LipschitzWith.coordinate [PseudoMetricSpace α] {f : α → ℓ^∞(ι)} (K : ℝ≥0) :
    LipschitzWith K f ↔ ∀ i : ι, LipschitzWith K (fun a : α ↦ f a i) 
goal: LipschitzWith K f ↔ ∀ (i : ι), LipschitzWith K fun a => ↑(f a) i