l3lab/ntp-mathlib huggingface dataset:
theorem _root_.MeasureTheory.memℒp_re_im_iff {f : α → K} :
    Memℒp (fun x => IsROrC.re (f x)) p μ ∧ Memℒp (fun x => IsROrC.im (f x)) p μ ↔ Memℒp f p μ := by
  

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
K : Type u_6
inst✝ : IsROrC K
f : α → K
⊢ Memℒp (fun x => IsROrC.re (f x)) p ∧ Memℒp (fun x => IsROrC.im (f x)) p ↔ Memℒp f p

Next tactic:
refine' ⟨_, fun hf => ⟨hf.re, hf.im⟩⟩
theorem _root_.MeasureTheory.memℒp_re_im_iff {f : α → K} :
    Memℒp (fun x => IsROrC.re (f x)) p μ ∧ Memℒp (fun x => IsROrC.im (f x)) p μ ↔ Memℒp f p μ := by
  refine' ⟨_, fun hf => ⟨hf.re, hf.im⟩⟩
  

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
K : Type u_6
inst✝ : IsROrC K
f : α → K
⊢ Memℒp (fun x => IsROrC.re (f x)) p ∧ Memℒp (fun x => IsROrC.im (f x)) p → Memℒp f p

Next tactic:
rintro ⟨hre, him⟩
theorem _root_.MeasureTheory.memℒp_re_im_iff {f : α → K} :
    Memℒp (fun x => IsROrC.re (f x)) p μ ∧ Memℒp (fun x => IsROrC.im (f x)) p μ ↔ Memℒp f p μ := by
  refine' ⟨_, fun hf => ⟨hf.re, hf.im⟩⟩
  rintro ⟨hre, him⟩
  

Proof state:
case intro
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
K : Type u_6
inst✝ : IsROrC K
f : α → K
hre : Memℒp (fun x => IsROrC.re (f x)) p
him : Memℒp (fun x => IsROrC.im (f x)) p
⊢ Memℒp f p

Next tactic:
convert MeasureTheory.Memℒp.add (E := K) hre.ofReal (him.ofReal.const_mul IsROrC.I)
theorem _root_.MeasureTheory.memℒp_re_im_iff {f : α → K} :
    Memℒp (fun x => IsROrC.re (f x)) p μ ∧ Memℒp (fun x => IsROrC.im (f x)) p μ ↔ Memℒp f p μ := by
  refine' ⟨_, fun hf => ⟨hf.re, hf.im⟩⟩
  rintro ⟨hre, him⟩
  convert MeasureTheory.Memℒp.add (E := K) hre.ofReal (him.ofReal.const_mul IsROrC.I)
  

Proof state:
case h.e'_5
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
K : Type u_6
inst✝ : IsROrC K
f : α → K
hre : Memℒp (fun x => IsROrC.re (f x)) p
him : Memℒp (fun x => IsROrC.im (f x)) p
⊢ f = (fun x => ↑(IsROrC.re (f x))) + fun x => IsROrC.I * ↑(IsROrC.im (f x))

Next tactic:
ext1 x
theorem _root_.MeasureTheory.memℒp_re_im_iff {f : α → K} :
    Memℒp (fun x => IsROrC.re (f x)) p μ ∧ Memℒp (fun x => IsROrC.im (f x)) p μ ↔ Memℒp f p μ := by
  refine' ⟨_, fun hf => ⟨hf.re, hf.im⟩⟩
  rintro ⟨hre, him⟩
  convert MeasureTheory.Memℒp.add (E := K) hre.ofReal (him.ofReal.const_mul IsROrC.I)
  ext1 x
  

Proof state:
case h.e'_5.h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
K : Type u_6
inst✝ : IsROrC K
f : α → K
hre : Memℒp (fun x => IsROrC.re (f x)) p
him : Memℒp (fun x => IsROrC.im (f x)) p
x : α
⊢ f x = ((fun x => ↑(IsROrC.re (f x))) + fun x => IsROrC.I * ↑(IsROrC.im (f x))) x

Next tactic:
rw [Pi.add_apply, mul_comm, IsROrC.re_add_im]
theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f := by
  

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : ↥(Lp E p)
⊢ compLp (L + L') f = compLp L f + compLp L' f

Next tactic:
ext1
theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f := by
  ext1
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : ↥(Lp E p)
⊢ ↑↑(compLp (L + L') f) =ᵐ[μ] ↑↑(compLp L f + compLp L' f)

Next tactic:
refine' (coeFn_compLp' (L + L') f).trans _
theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f := by
  ext1
  refine' (coeFn_compLp' (L + L') f).trans _
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (fun a => (L + L') (↑↑f a)) =ᵐ[μ] ↑↑(compLp L f + compLp L' f)

Next tactic:
refine' EventuallyEq.trans _ (Lp.coeFn_add _ _).symm
theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f := by
  ext1
  refine' (coeFn_compLp' (L + L') f).trans _
  refine' EventuallyEq.trans _ (Lp.coeFn_add _ _).symm
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (fun a => (L + L') (↑↑f a)) =ᵐ[μ] ↑↑(compLp L f) + ↑↑(compLp L' f)

Next tactic:
refine'
    EventuallyEq.trans _ (EventuallyEq.add (L.coeFn_compLp' f).symm (L'.coeFn_compLp' f).symm)
theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f := by
  ext1
  refine' (coeFn_compLp' (L + L') f).trans _
  refine' EventuallyEq.trans _ (Lp.coeFn_add _ _).symm
  refine'
    EventuallyEq.trans _ (EventuallyEq.add (L.coeFn_compLp' f).symm (L'.coeFn_compLp' f).symm)
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (fun a => (L + L') (↑↑f a)) =ᵐ[μ] fun x => L (↑↑f x) + L' (↑↑f x)

Next tactic:
refine' eventually_of_forall fun x => _
theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f := by
  ext1
  refine' (coeFn_compLp' (L + L') f).trans _
  refine' EventuallyEq.trans _ (Lp.coeFn_add _ _).symm
  refine'
    EventuallyEq.trans _ (EventuallyEq.add (L.coeFn_compLp' f).symm (L'.coeFn_compLp' f).symm)
  refine' eventually_of_forall fun x => _
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L L' : E →L[𝕜] F
f : ↥(Lp E p)
x : α
⊢ (fun a => (L + L') (↑↑f a)) x = (fun x => L (↑↑f x) + L' (↑↑f x)) x

Next tactic:
rw [coe_add', Pi.add_def]
theorem smul_compLp {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F]
    (c : 𝕜') (L : E →L[𝕜] F) (f : Lp E p μ) : (c • L).compLp f = c • L.compLp f := by
  

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedSpace 𝕜 F
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p)
⊢ compLp (c • L) f = c • compLp L f

Next tactic:
ext1
theorem smul_compLp {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F]
    (c : 𝕜') (L : E →L[𝕜] F) (f : Lp E p μ) : (c • L).compLp f = c • L.compLp f := by
  ext1
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedSpace 𝕜 F
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p)
⊢ ↑↑(compLp (c • L) f) =ᵐ[μ] ↑↑(c • compLp L f)

Next tactic:
refine' (coeFn_compLp' (c • L) f).trans _
theorem smul_compLp {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F]
    (c : 𝕜') (L : E →L[𝕜] F) (f : Lp E p μ) : (c • L).compLp f = c • L.compLp f := by
  ext1
  refine' (coeFn_compLp' (c • L) f).trans _
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedSpace 𝕜 F
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (fun a => (c • L) (↑↑f a)) =ᵐ[μ] ↑↑(c • compLp L f)

Next tactic:
refine' EventuallyEq.trans _ (Lp.coeFn_smul _ _).symm
theorem smul_compLp {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F]
    (c : 𝕜') (L : E →L[𝕜] F) (f : Lp E p μ) : (c • L).compLp f = c • L.compLp f := by
  ext1
  refine' (coeFn_compLp' (c • L) f).trans _
  refine' EventuallyEq.trans _ (Lp.coeFn_smul _ _).symm
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedSpace 𝕜 F
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (fun a => (c • L) (↑↑f a)) =ᵐ[μ] c • ↑↑(compLp L f)

Next tactic:
refine' (L.coeFn_compLp' f).mono fun x hx => _
theorem smul_compLp {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F]
    (c : 𝕜') (L : E →L[𝕜] F) (f : Lp E p μ) : (c • L).compLp f = c • L.compLp f := by
  ext1
  refine' (coeFn_compLp' (c • L) f).trans _
  refine' EventuallyEq.trans _ (Lp.coeFn_smul _ _).symm
  refine' (L.coeFn_compLp' f).mono fun x hx => _
  

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedSpace 𝕜 F
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p)
x : α
hx : ↑↑(compLp L f) x = (fun a => L (↑↑f a)) x
⊢ (fun a => (c • L) (↑↑f a)) x = (c • ↑↑(compLp L f)) x

Next tactic:
rw [Pi.smul_apply, hx, coe_smul', Pi.smul_def]
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g✝ : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
f g : ↥(Lp E p)
⊢ (fun f => compLp L f) (f + g) = (fun f => compLp L f) f + (fun f => compLp L f) g

Next tactic:
ext1
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g✝ : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
f g : ↥(Lp E p)
⊢ ↑↑((fun f => compLp L f) (f + g)) =ᵐ[μ] ↑↑((fun f => compLp L f) f + (fun f => compLp L f) g)

Next tactic:
filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
    

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g✝ : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
f g : ↥(Lp E p)
⊢ ∀ (a : α),
    ↑↑(f + g) a = (↑↑f + ↑↑g) a →
      ↑↑(compLp L (f + g)) a = L (↑↑(f + g) a) →
        ↑↑(compLp L f) a = L (↑↑f a) →
          ↑↑(compLp L g) a = L (↑↑g a) →
            ↑↑(compLp L f + compLp L g) a = (↑↑(compLp L f) + ↑↑(compLp L g)) a →
              ↑↑(compLp L (f + g)) a = ↑↑(compLp L f + compLp L g) a

Next tactic:
intro a ha1 ha2 ha3 ha4 ha5
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
    intro a ha1 ha2 ha3 ha4 ha5
    

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g✝ : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
f g : ↥(Lp E p)
a : α
ha1 : ↑↑(f + g) a = (↑↑f + ↑↑g) a
ha2 : ↑↑(compLp L (f + g)) a = L (↑↑(f + g) a)
ha3 : ↑↑(compLp L f) a = L (↑↑f a)
ha4 : ↑↑(compLp L g) a = L (↑↑g a)
ha5 : ↑↑(compLp L f + compLp L g) a = (↑↑(compLp L f) + ↑↑(compLp L g)) a
⊢ ↑↑(compLp L (f + g)) a = ↑↑(compLp L f + compLp L g) a

Next tactic:
simp only [ha1, ha2, ha3, ha4, ha5, map_add, Pi.add_apply]
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
    intro a ha1 ha2 ha3 ha4 ha5
    simp only [ha1, ha2, ha3, ha4, ha5, map_add, Pi.add_apply]
  map_smul' c f := by
    

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
c : 𝕜
f : ↥(Lp E p)
⊢ AddHom.toFun
      { toFun := fun f => compLp L f,
        map_add' :=
          (_ : ∀ (f g : ↥(Lp E p)), (fun f => compLp L f) (f + g) = (fun f => compLp L f) f + (fun f => compLp L f) g) }
      (c • f) =
    (RingHom.id 𝕜) c •
      AddHom.toFun
        { toFun := fun f => compLp L f,
          map_add' :=
            (_ :
              ∀ (f g : ↥(Lp E p)), (fun f => compLp L f) (f + g) = (fun f => compLp L f) f + (fun f => compLp L f) g) }
        f

Next tactic:
dsimp
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
    intro a ha1 ha2 ha3 ha4 ha5
    simp only [ha1, ha2, ha3, ha4, ha5, map_add, Pi.add_apply]
  map_smul' c f := by
    dsimp
    

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
c : 𝕜
f : ↥(Lp E p)
⊢ compLp L (c • f) = c • compLp L f

Next tactic:
ext1
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
    intro a ha1 ha2 ha3 ha4 ha5
    simp only [ha1, ha2, ha3, ha4, ha5, map_add, Pi.add_apply]
  map_smul' c f := by
    dsimp
    ext1
    

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
c : 𝕜
f : ↥(Lp E p)
⊢ ↑↑(compLp L (c • f)) =ᵐ[μ] ↑↑(c • compLp L f)

Next tactic:
filter_upwards [Lp.coeFn_smul c f, coeFn_compLp L (c • f), Lp.coeFn_smul c (L.compLp f),
      coeFn_compLp L f] with _ ha1 ha2 ha3 ha4
/-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ where
  toFun f := L.compLp f
  map_add' f g := by
    ext1
    filter_upwards [Lp.coeFn_add f g, coeFn_compLp L (f + g), coeFn_compLp L f,
      coeFn_compLp L g, Lp.coeFn_add (L.compLp f) (L.compLp g)]
    intro a ha1 ha2 ha3 ha4 ha5
    simp only [ha1, ha2, ha3, ha4, ha5, map_add, Pi.add_apply]
  map_smul' c f := by
    dsimp
    ext1
    filter_upwards [Lp.coeFn_smul c f, coeFn_compLp L (c • f), Lp.coeFn_smul c (L.compLp f),
      coeFn_compLp L f] with _ ha1 ha2 ha3 ha4
    

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace 𝕜 F
L : E →L[𝕜] F
c : 𝕜
f : ↥(Lp E p)
a✝ : α
ha1 : ↑↑(c • f) a✝ = (c • ↑↑f) a✝
ha2 : ↑↑(compLp L (c • f)) a✝ = L (↑↑(c • f) a✝)
ha3 : ↑↑(c • compLp L f) a✝ = (c • ↑↑(compLp L f)) a✝
ha4 : ↑↑(compLp L f) a✝ = L (↑↑f a✝)
⊢ ↑↑(compLp L (c • f)) a✝ = ↑↑(c • compLp L f) a✝

Next tactic:
simp only [ha1, ha2, ha3, ha4, map_smul, Pi.smul_apply]
theorem add_compLpL [Fact (1 ≤ p)] (L L' : E →L[𝕜] F) :
    (L + L').compLpL p μ = L.compLpL p μ + L'.compLpL p μ := by 

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Fact (1 ≤ p)
L L' : E →L[𝕜] F
⊢ compLpL p μ (L + L') = compLpL p μ L + compLpL p μ L'

Next tactic:
ext1 f
theorem add_compLpL [Fact (1 ≤ p)] (L L' : E →L[𝕜] F) :
    (L + L').compLpL p μ = L.compLpL p μ + L'.compLpL p μ := by ext1 f; 

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
𝕜 : Type u_5
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Fact (1 ≤ p)
L L' : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (compLpL p μ (L + L')) f = (compLpL p μ L + compLpL p μ L') f

Next tactic:
exact add_compLp L L' f
theorem smul_compLpL [Fact (1 ≤ p)] {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F]
    [SMulCommClass 𝕜 𝕜' F] (c : 𝕜') (L : E →L[𝕜] F) : (c • L).compLpL p μ = c • L.compLpL p μ := by
  

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
⊢ compLpL p μ (c • L) = c • compLpL p μ L

Next tactic:
ext1 f
theorem smul_compLpL [Fact (1 ≤ p)] {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F]
    [SMulCommClass 𝕜 𝕜' F] (c : 𝕜') (L : E →L[𝕜] F) : (c • L).compLpL p μ = c • L.compLpL p μ := by
  ext1 f; 

Proof state:
case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p)
⊢ (compLpL p μ (c • L)) f = (c • compLpL p μ L) f

Next tactic:
exact smul_compLp c L f
theorem indicatorConstLp_eq_toSpanSingleton_compLp {s : Set α} [NormedSpace ℝ F]
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : F) :
    indicatorConstLp 2 hs hμs x =
      (ContinuousLinearMap.toSpanSingleton ℝ x).compLp (indicatorConstLp 2 hs hμs (1 : ℝ)) := by
  

Proof state:
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
s : Set α
inst✝ : NormedSpace ℝ F
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
x : F
⊢ indicatorConstLp 2 hs hμs x =
    ContinuousLinearMap.compLp (ContinuousLinearMap.toSpanSingleton ℝ x) (indicatorConstLp 2 hs hμs 1)

Next tactic:
ext1