l3lab/ntp-mathlib huggingface dataset:
theorem norm_const_smul (hp : p ≠ 0) {c : 𝕜} (f : lp E p) : ‖c • f‖ = ‖c‖ * ‖f‖ := by
  obtain rfl | hc := eq_or_ne c 0
  · simp
  

Proof state:
case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : (i : α) → Module 𝕜 (E i)
inst✝ : ∀ (i : α), BoundedSMul 𝕜 (E i)
hp : p ≠ 0
c : 𝕜
f : ↥(lp E p)
hc : c ≠ 0
⊢ ‖c • f‖ = ‖c‖ * ‖f‖

Next tactic:
refine' le_antisymm (norm_const_smul_le hp c f) _
theorem norm_const_smul (hp : p ≠ 0) {c : 𝕜} (f : lp E p) : ‖c • f‖ = ‖c‖ * ‖f‖ := by
  obtain rfl | hc := eq_or_ne c 0
  · simp
  refine' le_antisymm (norm_const_smul_le hp c f) _
  

Proof state:
case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : (i : α) → Module 𝕜 (E i)
inst✝ : ∀ (i : α), BoundedSMul 𝕜 (E i)
hp : p ≠ 0
c : 𝕜
f : ↥(lp E p)
hc : c ≠ 0
⊢ ‖c‖ * ‖f‖ ≤ ‖c • f‖

Next tactic:
have := mul_le_mul_of_nonneg_left (norm_const_smul_le hp c⁻¹ (c • f)) (norm_nonneg c)
theorem norm_const_smul (hp : p ≠ 0) {c : 𝕜} (f : lp E p) : ‖c • f‖ = ‖c‖ * ‖f‖ := by
  obtain rfl | hc := eq_or_ne c 0
  · simp
  refine' le_antisymm (norm_const_smul_le hp c f) _
  have := mul_le_mul_of_nonneg_left (norm_const_smul_le hp c⁻¹ (c • f)) (norm_nonneg c)
  

Proof state:
case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : (i : α) → Module 𝕜 (E i)
inst✝ : ∀ (i : α), BoundedSMul 𝕜 (E i)
hp : p ≠ 0
c : 𝕜
f : ↥(lp E p)
hc : c ≠ 0
this : ‖c‖ * ‖c⁻¹ • c • f‖ ≤ ‖c‖ * (‖c⁻¹‖ * ‖c • f‖)
⊢ ‖c‖ * ‖f‖ ≤ ‖c • f‖

Next tactic:
rwa [inv_smul_smul₀ hc, norm_inv, mul_inv_cancel_left₀ (norm_ne_zero_iff.mpr hc)] at this
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f p
⊢ Memℓp (star f) p

Next tactic:
rcases p.trichotomy with (rfl | rfl | hp)
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  rcases p.trichotomy with (rfl | rfl | hp)
  · 

Proof state:
case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f 0
⊢ Memℓp (star f) 0

Next tactic:
apply memℓp_zero
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  rcases p.trichotomy with (rfl | rfl | hp)
  · apply memℓp_zero
    

Proof state:
case inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f 0
⊢ Set.Finite {i | star f i ≠ 0}

Next tactic:
simp [hf.finite_dsupport]
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  rcases p.trichotomy with (rfl | rfl | hp)
  · apply memℓp_zero
    simp [hf.finite_dsupport]
  · 

Proof state:
case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f ⊤
⊢ Memℓp (star f) ⊤

Next tactic:
apply memℓp_infty
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  rcases p.trichotomy with (rfl | rfl | hp)
  · apply memℓp_zero
    simp [hf.finite_dsupport]
  · apply memℓp_infty
    

Proof state:
case inr.inl.hf
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f ⊤
⊢ BddAbove (Set.range fun i => ‖star f i‖)

Next tactic:
simpa using hf.bddAbove
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  rcases p.trichotomy with (rfl | rfl | hp)
  · apply memℓp_zero
    simp [hf.finite_dsupport]
  · apply memℓp_infty
    simpa using hf.bddAbove
  · 

Proof state:
case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f p
hp : 0 < ENNReal.toReal p
⊢ Memℓp (star f) p

Next tactic:
apply memℓp_gen
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p := by
  rcases p.trichotomy with (rfl | rfl | hp)
  · apply memℓp_zero
    simp [hf.finite_dsupport]
  · apply memℓp_infty
    simpa using hf.bddAbove
  · apply memℓp_gen
    

Proof state:
case inr.inr.hf
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
f : (i : α) → E i
hf : Memℓp f p
hp : 0 < ENNReal.toReal p
⊢ Summable fun i => ‖star f i‖ ^ ENNReal.toReal p

Next tactic:
simpa using hf.summable hp
instance instInvolutiveStar : InvolutiveStar (lp E p) where
  star_involutive x := by 

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
x : ↥(lp E p)
⊢ star (star x) = x

Next tactic:
simp [star]
instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) where
  norm_star f := by
    

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
hp : Fact (1 ≤ p)
f : ↥(lp E p)
⊢ ‖star f‖ = ‖f‖

Next tactic:
rcases p.trichotomy with (rfl | rfl | h)
instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) where
  norm_star f := by
    rcases p.trichotomy with (rfl | rfl | h)
    · 

Proof state:
case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
hp : Fact (1 ≤ 0)
f : ↥(lp E 0)
⊢ ‖star f‖ = ‖f‖

Next tactic:
exfalso
instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) where
  norm_star f := by
    rcases p.trichotomy with (rfl | rfl | h)
    · exfalso
      

Proof state:
case inl.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
hp : Fact (1 ≤ 0)
f : ↥(lp E 0)
⊢ False

Next tactic:
have := ENNReal.toReal_mono ENNReal.zero_ne_top hp.elim
instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) where
  norm_star f := by
    rcases p.trichotomy with (rfl | rfl | h)
    · exfalso
      have := ENNReal.toReal_mono ENNReal.zero_ne_top hp.elim
      

Proof state:
case inl.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
hp : Fact (1 ≤ 0)
f : ↥(lp E 0)
this : ENNReal.toReal 1 ≤ ENNReal.toReal 0
⊢ False

Next tactic:
norm_num at this
instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) where
  norm_star f := by
    rcases p.trichotomy with (rfl | rfl | h)
    · exfalso
      have := ENNReal.toReal_mono ENNReal.zero_ne_top hp.elim
      norm_num at this
    · 

Proof state:
case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
hp : Fact (1 ≤ ⊤)
f : ↥(lp E ⊤)
⊢ ‖star f‖ = ‖f‖

Next tactic:
simp only [lp.norm_eq_ciSup, lp.star_apply, norm_star]
instance [hp : Fact (1 ≤ p)] : NormedStarGroup (lp E p) where
  norm_star f := by
    rcases p.trichotomy with (rfl | rfl | h)
    · exfalso
      have := ENNReal.toReal_mono ENNReal.zero_ne_top hp.elim
      norm_num at this
    · simp only [lp.norm_eq_ciSup, lp.star_apply, norm_star]
    · 

Proof state:
case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
inst✝¹ : (i : α) → StarAddMonoid (E i)
inst✝ : ∀ (i : α), NormedStarGroup (E i)
hp : Fact (1 ≤ p)
f : ↥(lp E p)
h : 0 < ENNReal.toReal p
⊢ ‖star f‖ = ‖f‖

Next tactic:
simp only [lp.norm_eq_tsum_rpow h, lp.star_apply, norm_star]
theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞ := by
  

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
⊢ Memℓp (f * g) ⊤

Next tactic:
rw [memℓp_infty_iff]
theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞ := by
  rw [memℓp_infty_iff]
  

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
⊢ BddAbove (Set.range fun i => ‖(f * g) i‖)

Next tactic:
obtain ⟨⟨Cf, hCf⟩, ⟨Cg, hCg⟩⟩ := hf.bddAbove, hg.bddAbove
theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞ := by
  rw [memℓp_infty_iff]
  obtain ⟨⟨Cf, hCf⟩, ⟨Cg, hCg⟩⟩ := hf.bddAbove, hg.bddAbove
  

Proof state:
case intro.intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
Cf : ℝ
hCf : Cf ∈ upperBounds (Set.range fun i => ‖f i‖)
Cg : ℝ
hCg : Cg ∈ upperBounds (Set.range fun i => ‖g i‖)
⊢ BddAbove (Set.range fun i => ‖(f * g) i‖)

Next tactic:
refine' ⟨Cf * Cg, _⟩
theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞ := by
  rw [memℓp_infty_iff]
  obtain ⟨⟨Cf, hCf⟩, ⟨Cg, hCg⟩⟩ := hf.bddAbove, hg.bddAbove
  refine' ⟨Cf * Cg, _⟩
  

Proof state:
case intro.intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
Cf : ℝ
hCf : Cf ∈ upperBounds (Set.range fun i => ‖f i‖)
Cg : ℝ
hCg : Cg ∈ upperBounds (Set.range fun i => ‖g i‖)
⊢ Cf * Cg ∈ upperBounds (Set.range fun i => ‖(f * g) i‖)

Next tactic:
rintro _ ⟨i, rfl⟩
theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞ := by
  rw [memℓp_infty_iff]
  obtain ⟨⟨Cf, hCf⟩, ⟨Cg, hCg⟩⟩ := hf.bddAbove, hg.bddAbove
  refine' ⟨Cf * Cg, _⟩
  rintro _ ⟨i, rfl⟩
  

Proof state:
case intro.intro.intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝ : (i : I) → NonUnitalNormedRing (B i)
f g : (i : I) → B i
hf : Memℓp f ⊤
hg : Memℓp g ⊤
Cf : ℝ
hCf : Cf ∈ upperBounds (Set.range fun i => ‖f i‖)
Cg : ℝ
hCg : Cg ∈ upperBounds (Set.range fun i => ‖g i‖)
i : I
⊢ (fun i => ‖(f * g) i‖) i ≤ Cf * Cg

Next tactic:
calc
    ‖(f * g) i‖ ≤ ‖f i‖ * ‖g i‖ := norm_mul_le (f i) (g i)
    _ ≤ Cf * Cg :=
      mul_le_mul (hCf ⟨i, rfl⟩) (hCg ⟨i, rfl⟩) (norm_nonneg _)
        ((norm_nonneg _).trans (hCf ⟨i, rfl⟩))
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
⊢ ∀ {x : ↥(lp B ⊤)}, ‖star x * x‖ = ‖x‖ * ‖x‖

Next tactic:
intro f
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
⊢ ‖star f * f‖ = ‖f‖ * ‖f‖

Next tactic:
apply le_antisymm
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · 

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
⊢ ‖star f * f‖ ≤ ‖f‖ * ‖f‖

Next tactic:
rw [← sq]
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
⊢ ‖star f * f‖ ≤ ‖f‖ ^ 2

Next tactic:
refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
i : I
⊢ ‖↑(star f * f) i‖ ≤ ‖f‖ ^ 2

Next tactic:
simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
i : I
⊢ ‖↑f i‖ ^ 2 ≤ ‖f‖ ^ 2

Next tactic:
refine' sq_le_sq' _ (lp.norm_apply_le_norm ENNReal.top_ne_zero _ _)
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
      refine' sq_le_sq' _ (lp.norm_apply_le_norm ENNReal.top_ne_zero _ _)
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
i : I
⊢ -‖f‖ ≤ ‖↑f i‖

Next tactic:
linarith [norm_nonneg (f i), norm_nonneg f]
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
      refine' sq_le_sq' _ (lp.norm_apply_le_norm ENNReal.top_ne_zero _ _)
      linarith [norm_nonneg (f i), norm_nonneg f]
    · 

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
⊢ ‖f‖ * ‖f‖ ≤ ‖star f * f‖

Next tactic:
rw [← sq, ← Real.le_sqrt (norm_nonneg _) (norm_nonneg _)]
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
      refine' sq_le_sq' _ (lp.norm_apply_le_norm ENNReal.top_ne_zero _ _)
      linarith [norm_nonneg (f i), norm_nonneg f]
    · rw [← sq, ← Real.le_sqrt (norm_nonneg _) (norm_nonneg _)]
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
⊢ ‖f‖ ≤ Real.sqrt ‖star f * f‖

Next tactic:
refine' lp.norm_le_of_forall_le ‖star f * f‖.sqrt_nonneg fun i => _
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
      refine' sq_le_sq' _ (lp.norm_apply_le_norm ENNReal.top_ne_zero _ _)
      linarith [norm_nonneg (f i), norm_nonneg f]
    · rw [← sq, ← Real.le_sqrt (norm_nonneg _) (norm_nonneg _)]
      refine' lp.norm_le_of_forall_le ‖star f * f‖.sqrt_nonneg fun i => _
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
i : I
⊢ ‖↑f i‖ ≤ Real.sqrt ‖star f * f‖

Next tactic:
rw [Real.le_sqrt (norm_nonneg _) (norm_nonneg _), sq, ← CstarRing.norm_star_mul_self]
instance inftyCstarRing [∀ i, CstarRing (B i)] : CstarRing (lp B ∞) where
  norm_star_mul_self := by
    intro f
    apply le_antisymm
    · rw [← sq]
      refine' lp.norm_le_of_forall_le (sq_nonneg ‖f‖) fun i => _
      simp only [lp.star_apply, CstarRing.norm_star_mul_self, ← sq, infty_coeFn_mul, Pi.mul_apply]
      refine' sq_le_sq' _ (lp.norm_apply_le_norm ENNReal.top_ne_zero _ _)
      linarith [norm_nonneg (f i), norm_nonneg f]
    · rw [← sq, ← Real.le_sqrt (norm_nonneg _) (norm_nonneg _)]
      refine' lp.norm_le_of_forall_le ‖star f * f‖.sqrt_nonneg fun i => _
      rw [Real.le_sqrt (norm_nonneg _) (norm_nonneg _), sq, ← CstarRing.norm_star_mul_self]
      

Proof state:
case a
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝³ : (i : I) → NonUnitalNormedRing (B i)
inst✝² : (i : I) → StarRing (B i)
inst✝¹ : ∀ (i : I), NormedStarGroup (B i)
inst✝ : ∀ (i : I), CstarRing (B i)
f : ↥(lp B ⊤)
i : I
⊢ ‖star (↑f i) * ↑f i‖ ≤ ‖star f * f‖

Next tactic:
exact lp.norm_apply_le_norm ENNReal.top_ne_zero (star f * f) i
theorem _root_.one_memℓp_infty : Memℓp (1 : ∀ i, B i) ∞ :=
  ⟨1, by 

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
⊢ 1 ∈ upperBounds (Set.range fun i => ‖OfNat.ofNat 1 i‖)

Next tactic:
rintro i ⟨i, rfl⟩
theorem _root_.one_memℓp_infty : Memℓp (1 : ∀ i, B i) ∞ :=
  ⟨1, by rintro i ⟨i, rfl⟩; 

Proof state:
case intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
i : I
⊢ (fun i => ‖OfNat.ofNat 1 i‖) i ≤ 1

Next tactic:
exact norm_one.le
instance [Nonempty I] : NormOneClass (lp B ∞) where
  norm_one := by 

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝² : (i : I) → NormedRing (B i)
inst✝¹ : ∀ (i : I), NormOneClass (B i)
inst✝ : Nonempty I
⊢ ‖1‖ = 1

Next tactic:
simp_rw [lp.norm_eq_ciSup, infty_coeFn_one, Pi.one_apply, norm_one, ciSup_const]
instance inftyCommRing : CommRing (lp B ∞) :=
  { lp.inftyRing with
    mul_comm := fun f g => by 

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedCommRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
src✝ : Ring ↥(lp B ⊤) := inftyRing
f g : ↥(lp B ⊤)
⊢ f * g = g * f

Next tactic:
ext
instance inftyCommRing : CommRing (lp B ∞) :=
  { lp.inftyRing with
    mul_comm := fun f g => by ext; 

Proof state:
case h.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedCommRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
src✝ : Ring ↥(lp B ⊤) := inftyRing
f g : ↥(lp B ⊤)
x✝ : I
⊢ ↑(f * g) x✝ = ↑(g * f) x✝

Next tactic:
simp only [lp.infty_coeFn_mul, Pi.mul_apply, mul_comm]
theorem _root_.algebraMap_memℓp_infty (k : 𝕜) : Memℓp (algebraMap 𝕜 (∀ i, B i) k) ∞ := by
  

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
𝕜 : Type u_4
B : I → Type u_5
inst✝³ : NormedField 𝕜
inst✝² : (i : I) → NormedRing (B i)
inst✝¹ : (i : I) → NormedAlgebra 𝕜 (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
k : 𝕜
⊢ Memℓp ((algebraMap 𝕜 ((i : I) → B i)) k) ⊤

Next tactic:
rw [Algebra.algebraMap_eq_smul_one]
theorem _root_.algebraMap_memℓp_infty (k : 𝕜) : Memℓp (algebraMap 𝕜 (∀ i, B i) k) ∞ := by
  rw [Algebra.algebraMap_eq_smul_one]
  

Proof state:
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
𝕜 : Type u_4
B : I → Type u_5
inst✝³ : NormedField 𝕜
inst✝² : (i : I) → NormedRing (B i)
inst✝¹ : (i : I) → NormedAlgebra 𝕜 (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
k : 𝕜
⊢ Memℓp (k • 1) ⊤

Next tactic:
exact (one_memℓp_infty.const_smul k : Memℓp (k • (1 : ∀ i, B i)) ∞)
/-- 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 :=
  ⟨fun j => if h : j = i then Eq.ndrec a h.symm else 0, by
    

Proof state:
α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
⊢ (fun j => if h : j = i then (_ : i = j) ▸ a else 0) ∈ lp E p

Next tactic:
refine' (memℓp_zero _).of_exponent_ge (zero_le p)
/-- 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 :=
  ⟨fun j => if h : j = i then Eq.ndrec a h.symm else 0, by
    refine' (memℓp_zero _).of_exponent_ge (zero_le p)
    

Proof state:
α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
⊢ Set.Finite {i_1 | (fun j => if h : j = i then (_ : i = j) ▸ a else 0) i_1 ≠ 0}

Next tactic:
refine' (Set.finite_singleton i).subset _
/-- 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 :=
  ⟨fun j => if h : j = i then Eq.ndrec a h.symm else 0, by
    refine' (memℓp_zero _).of_exponent_ge (zero_le p)
    refine' (Set.finite_singleton i).subset _
    

Proof state:
α : Type u_1
E : α → Type u_2
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
⊢ {i_1 | (fun j => if h : j = i then (_ : i = j) ▸ a else 0) i_1 ≠ 0} ⊆ {i}

Next tactic:
intro j