l3lab/ntp-mathlib huggingface dataset:
theorem support_mul_single_eq_image [DecidableEq G] [Mul G] (f : MonoidAlgebra k G) {r : k}
    (hr : ∀ y, y * r = 0 ↔ y = 0) {x : G} (rx : IsRightRegular x) :
    (f * single x r).support = Finset.image (· * x) f.support := by
  refine' subset_antisymm (support_mul_single_subset f _ _) fun y hy => _
  obtain ⟨y, yf, rfl⟩ : ∃ a : G, a ∈ f.support ∧ a * x = y := by
    

Proof state:
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
hy : y ∈ image (fun x_1 => x_1 * x) f.support
⊢ ∃ a ∈ f.support, a * x = y

Next tactic:
simpa only [Finset.mem_image, exists_prop] using hy
theorem support_mul_single_eq_image [DecidableEq G] [Mul G] (f : MonoidAlgebra k G) {r : k}
    (hr : ∀ y, y * r = 0 ↔ y = 0) {x : G} (rx : IsRightRegular x) :
    (f * single x r).support = Finset.image (· * x) f.support := by
  refine' subset_antisymm (support_mul_single_subset f _ _) fun y hy => _
  obtain ⟨y, yf, rfl⟩ : ∃ a : G, a ∈ f.support ∧ a * x = y := by
    simpa only [Finset.mem_image, exists_prop] using hy
  

Proof state:
case intro.intro
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
yf : y ∈ f.support
hy : y * x ∈ image (fun x_1 => x_1 * x) f.support
⊢ y * x ∈ (f * single x r).support

Next tactic:
simp only [mul_apply, mem_support_iff.mp yf, hr, mem_support_iff, sum_single_index,
    Finsupp.sum_ite_eq', Ne.def, not_false_iff, if_true, mul_zero, ite_self, sum_zero, rx.eq_iff]
theorem support_mul_single [Mul G] [IsRightCancelMul G] (f : MonoidAlgebra k G) (r : k)
    (hr : ∀ y, y * r = 0 ↔ y = 0) (x : G) :
    (f * single x r).support = f.support.map (mulRightEmbedding x) := by
  

Proof state:
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsRightCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
⊢ (f * single x r).support = map (mulRightEmbedding x) f.support

Next tactic:
classical
    ext
    simp only [support_mul_single_eq_image f hr (IsRightRegular.all x),
      mem_image, mem_map, mulRightEmbedding_apply]
theorem support_mul_single [Mul G] [IsRightCancelMul G] (f : MonoidAlgebra k G) (r : k)
    (hr : ∀ y, y * r = 0 ↔ y = 0) (x : G) :
    (f * single x r).support = f.support.map (mulRightEmbedding x) := by
  classical
    

Proof state:
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsRightCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
⊢ (f * single x r).support = map (mulRightEmbedding x) f.support

Next tactic:
ext
theorem support_mul_single [Mul G] [IsRightCancelMul G] (f : MonoidAlgebra k G) (r : k)
    (hr : ∀ y, y * r = 0 ↔ y = 0) (x : G) :
    (f * single x r).support = f.support.map (mulRightEmbedding x) := by
  classical
    ext
    

Proof state:
case a
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsRightCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x a✝ : G
⊢ a✝ ∈ (f * single x r).support ↔ a✝ ∈ map (mulRightEmbedding x) f.support

Next tactic:
simp only [support_mul_single_eq_image f hr (IsRightRegular.all x),
      mem_image, mem_map, mulRightEmbedding_apply]
theorem support_single_mul [Mul G] [IsLeftCancelMul G] (f : MonoidAlgebra k G) (r : k)
    (hr : ∀ y, r * y = 0 ↔ y = 0) (x : G) :
    (single x r * f : MonoidAlgebra k G).support = f.support.map (mulLeftEmbedding x) := by
  

Proof state:
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
⊢ (single x r * f).support = map (mulLeftEmbedding x) f.support

Next tactic:
classical
    ext
    simp only [support_single_mul_eq_image f hr (IsLeftRegular.all x), mem_image,
      mem_map, mulLeftEmbedding_apply]
theorem support_single_mul [Mul G] [IsLeftCancelMul G] (f : MonoidAlgebra k G) (r : k)
    (hr : ∀ y, r * y = 0 ↔ y = 0) (x : G) :
    (single x r * f : MonoidAlgebra k G).support = f.support.map (mulLeftEmbedding x) := by
  classical
    

Proof state:
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
⊢ (single x r * f).support = map (mulLeftEmbedding x) f.support

Next tactic:
ext
theorem support_single_mul [Mul G] [IsLeftCancelMul G] (f : MonoidAlgebra k G) (r : k)
    (hr : ∀ y, r * y = 0 ↔ y = 0) (x : G) :
    (single x r * f : MonoidAlgebra k G).support = f.support.map (mulLeftEmbedding x) := by
  classical
    ext
    

Proof state:
case a
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : Mul G
inst✝ : IsLeftCancelMul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x a✝ : G
⊢ a✝ ∈ (single x r * f).support ↔ a✝ ∈ map (mulLeftEmbedding x) f.support

Next tactic:
simp only [support_single_mul_eq_image f hr (IsLeftRegular.all x), mem_image,
      mem_map, mulLeftEmbedding_apply]
/-- An element of `MonoidAlgebra k G` is in the subalgebra generated by its support. -/
theorem mem_span_support (f : MonoidAlgebra k G) :
    f ∈ Submodule.span k (of k G '' (f.support : Set G)) := by
  

Proof state:
k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : MulOneClass G
f : MonoidAlgebra k G
⊢ f ∈ Submodule.span k (⇑(of k G) '' ↑f.support)

Next tactic:
erw [of, MonoidHom.coe_mk, ← supported_eq_span_single, Finsupp.mem_supported]
/-- An element of `k[G]` is in the submodule generated by its support. -/
theorem mem_span_support [AddZeroClass G] (f : k[G]) :
    f ∈ Submodule.span k (of k G '' (f.support : Set G)) := by
  

Proof state:
k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : AddZeroClass G
f : k[G]
⊢ f ∈ Submodule.span k (⇑(of k G) '' ↑f.support)

Next tactic:
erw [of, MonoidHom.coe_mk, ← Finsupp.supported_eq_span_single, Finsupp.mem_supported]
/-- An element of `k[G]` is in the subalgebra generated by its support, using
unbundled inclusion. -/
theorem mem_span_support' (f : k[G]) :
    f ∈ Submodule.span k (of' k G '' (f.support : Set G)) := by
  

Proof state:
k : Type u₁
G : Type u₂
inst✝ : Semiring k
f : k[G]
⊢ f ∈ Submodule.span k (of' k G '' ↑f.support)

Next tactic:
delta of'
/-- An element of `k[G]` is in the subalgebra generated by its support, using
unbundled inclusion. -/
theorem mem_span_support' (f : k[G]) :
    f ∈ Submodule.span k (of' k G '' (f.support : Set G)) := by
  delta of'
  

Proof state:
k : Type u₁
G : Type u₂
inst✝ : Semiring k
f : k[G]
⊢ f ∈ Submodule.span k ((fun a => single a 1) '' ↑f.support)

Next tactic:
rw [← Finsupp.supported_eq_span_single, Finsupp.mem_supported]
theorem coeFn_le (f g : Lp E p μ) : f ≤ᵐ[μ] g ↔ f ≤ g := by
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g : ↥(Lp E p)
⊢ ↑↑f ≤ᵐ[μ] ↑↑g ↔ f ≤ g

Next tactic:
rw [← Subtype.coe_le_coe, ← AEEqFun.coeFn_le]
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
⊢ 0 ≤ᵐ[μ] ↑↑f ↔ 0 ≤ f

Next tactic:
rw [← coeFn_le]
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
⊢ 0 ≤ᵐ[μ] ↑↑f ↔ ↑↑0 ≤ᵐ[μ] ↑↑f

Next tactic:
have h0 := Lp.coeFn_zero E p μ
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
⊢ 0 ≤ᵐ[μ] ↑↑f ↔ ↑↑0 ≤ᵐ[μ] ↑↑f

Next tactic:
constructor
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  constructor <;> 

Proof state:
case mp
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
⊢ 0 ≤ᵐ[μ] ↑↑f → ↑↑0 ≤ᵐ[μ] ↑↑f

Next tactic:
intro h
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  constructor <;> 

Proof state:
case mpr
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
⊢ ↑↑0 ≤ᵐ[μ] ↑↑f → 0 ≤ᵐ[μ] ↑↑f

Next tactic:
intro h
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  constructor <;> intro h <;> 

Proof state:
case mp
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
h : 0 ≤ᵐ[μ] ↑↑f
⊢ ↑↑0 ≤ᵐ[μ] ↑↑f

Next tactic:
filter_upwards [h, h0] with _ _ h2
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  constructor <;> intro h <;> 

Proof state:
case mpr
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
h : ↑↑0 ≤ᵐ[μ] ↑↑f
⊢ 0 ≤ᵐ[μ] ↑↑f

Next tactic:
filter_upwards [h, h0] with _ _ h2
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  constructor <;> intro h <;> filter_upwards [h, h0] with _ _ h2
  · 

Proof state:
case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
h : 0 ≤ᵐ[μ] ↑↑f
a✝¹ : α
a✝ : OfNat.ofNat 0 a✝¹ ≤ ↑↑f a✝¹
h2 : ↑↑0 a✝¹ = OfNat.ofNat 0 a✝¹
⊢ ↑↑0 a✝¹ ≤ ↑↑f a✝¹

Next tactic:
rwa [h2]
theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f := by
  rw [← coeFn_le]
  have h0 := Lp.coeFn_zero E p μ
  constructor <;> intro h <;> filter_upwards [h, h0] with _ _ h2
  · rwa [h2]
  · 

Proof state:
case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p)
h0 : ↑↑0 =ᵐ[μ] 0
h : ↑↑0 ≤ᵐ[μ] ↑↑f
a✝¹ : α
a✝ : ↑↑0 a✝¹ ≤ ↑↑f a✝¹
h2 : ↑↑0 a✝¹ = OfNat.ofNat 0 a✝¹
⊢ OfNat.ofNat 0 a✝¹ ≤ ↑↑f a✝¹

Next tactic:
rwa [← h2]
instance instCovariantClassLE : CovariantClass (Lp E p μ) (Lp E p μ) (· + ·) (· ≤ ·) := by
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
⊢ CovariantClass (↥(Lp E p)) (↥(Lp E p)) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

Next tactic:
refine' ⟨fun f g₁ g₂ hg₁₂ => _⟩
instance instCovariantClassLE : CovariantClass (Lp E p μ) (Lp E p μ) (· + ·) (· ≤ ·) := by
  refine' ⟨fun f g₁ g₂ hg₁₂ => _⟩
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g₁ g₂ : ↥(Lp E p)
hg₁₂ : g₁ ≤ g₂
⊢ f + g₁ ≤ f + g₂

Next tactic:
rw [← coeFn_le] at hg₁₂ ⊢
instance instCovariantClassLE : CovariantClass (Lp E p μ) (Lp E p μ) (· + ·) (· ≤ ·) := by
  refine' ⟨fun f g₁ g₂ hg₁₂ => _⟩
  rw [← coeFn_le] at hg₁₂ ⊢
  

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g₁ g₂ : ↥(Lp E p)
hg₁₂ : ↑↑g₁ ≤ᵐ[μ] ↑↑g₂
⊢ ↑↑(f + g₁) ≤ᵐ[μ] ↑↑(f + g₂)

Next tactic:
filter_upwards [coeFn_add f g₁, coeFn_add f g₂, hg₁₂] with _ h1 h2 h3
instance instCovariantClassLE : CovariantClass (Lp E p μ) (Lp E p μ) (· + ·) (· ≤ ·) := by
  refine' ⟨fun f g₁ g₂ hg₁₂ => _⟩
  rw [← coeFn_le] at hg₁₂ ⊢
  filter_upwards [coeFn_add f g₁, coeFn_add f g₂, hg₁₂] with _ h1 h2 h3
  

Proof state:
case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g₁ g₂ : ↥(Lp E p)
hg₁₂ : ↑↑g₁ ≤ᵐ[μ] ↑↑g₂
a✝ : α
h1 : ↑↑(f + g₁) a✝ = (↑↑f + ↑↑g₁) a✝
h2 : ↑↑(f + g₂) a✝ = (↑↑f + ↑↑g₂) a✝
h3 : ↑↑g₁ a✝ ≤ ↑↑g₂ a✝
⊢ ↑↑(f + g₁) a✝ ≤ ↑↑(f + g₂) a✝

Next tactic:
rw [h1, h2, Pi.add_apply, Pi.add_apply]
instance instCovariantClassLE : CovariantClass (Lp E p μ) (Lp E p μ) (· + ·) (· ≤ ·) := by
  refine' ⟨fun f g₁ g₂ hg₁₂ => _⟩
  rw [← coeFn_le] at hg₁₂ ⊢
  filter_upwards [coeFn_add f g₁, coeFn_add f g₂, hg₁₂] with _ h1 h2 h3
  rw [h1, h2, Pi.add_apply, Pi.add_apply]
  

Proof state:
case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g₁ g₂ : ↥(Lp E p)
hg₁₂ : ↑↑g₁ ≤ᵐ[μ] ↑↑g₂
a✝ : α
h1 : ↑↑(f + g₁) a✝ = (↑↑f + ↑↑g₁) a✝
h2 : ↑↑(f + g₂) a✝ = (↑↑f + ↑↑g₂) a✝
h3 : ↑↑g₁ a✝ ≤ ↑↑g₂ a✝
⊢ ↑↑f a✝ + ↑↑g₁ a✝ ≤ ↑↑f a✝ + ↑↑g₂ a✝

Next tactic:
exact add_le_add le_rfl h3
instance instLattice : Lattice (Lp E p μ) :=
  Subtype.lattice
    (fun f g hf hg => by
      

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g : α →ₘ[μ] E
hf : f ∈ Lp E p
hg : g ∈ Lp E p
⊢ f ⊔ g ∈ Lp E p

Next tactic:
rw [mem_Lp_iff_memℒp] at *
instance instLattice : Lattice (Lp E p μ) :=
  Subtype.lattice
    (fun f g hf hg => by
      rw [mem_Lp_iff_memℒp] at *
      

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g : α →ₘ[μ] E
hf : Memℒp (↑f) p
hg : Memℒp (↑g) p
⊢ Memℒp (↑(f ⊔ g)) p

Next tactic:
exact (memℒp_congr_ae (AEEqFun.coeFn_sup _ _)).mpr (hf.sup hg)
instance instLattice : Lattice (Lp E p μ) :=
  Subtype.lattice
    (fun f g hf hg => by
      rw [mem_Lp_iff_memℒp] at *
      exact (memℒp_congr_ae (AEEqFun.coeFn_sup _ _)).mpr (hf.sup hg))
    fun f g hf hg => by
    

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g : α →ₘ[μ] E
hf : f ∈ Lp E p
hg : g ∈ Lp E p
⊢ f ⊓ g ∈ Lp E p

Next tactic:
rw [mem_Lp_iff_memℒp] at *
instance instLattice : Lattice (Lp E p μ) :=
  Subtype.lattice
    (fun f g hf hg => by
      rw [mem_Lp_iff_memℒp] at *
      exact (memℒp_congr_ae (AEEqFun.coeFn_sup _ _)).mpr (hf.sup hg))
    fun f g hf hg => by
    rw [mem_Lp_iff_memℒp] at *
    

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g : α →ₘ[μ] E
hf : Memℒp (↑f) p
hg : Memℒp (↑g) p
⊢ Memℒp (↑(f ⊓ g)) p

Next tactic:
exact (memℒp_congr_ae (AEEqFun.coeFn_inf _ _)).mpr (hf.inf hg)
noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) :=
  { Lp.instLattice, Lp.instNormedAddCommGroup with
    add_le_add_left := fun f g => add_le_add_left
    solid := fun f g hfg => by
      

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedLatticeAddCommGroup E
inst✝ : Fact (1 ≤ p)
src✝¹ : Lattice ↥(Lp E p) := instLattice
src✝ : NormedAddCommGroup ↥(Lp E p) := instNormedAddCommGroup
f g : ↥(Lp E p)
hfg : |f| ≤ |g|
⊢ ‖f‖ ≤ ‖g‖

Next tactic:
rw [← coeFn_le] at hfg
noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) :=
  { Lp.instLattice, Lp.instNormedAddCommGroup with
    add_le_add_left := fun f g => add_le_add_left
    solid := fun f g hfg => by
      rw [← coeFn_le] at hfg
      

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedLatticeAddCommGroup E
inst✝ : Fact (1 ≤ p)
src✝¹ : Lattice ↥(Lp E p) := instLattice
src✝ : NormedAddCommGroup ↥(Lp E p) := instNormedAddCommGroup
f g : ↥(Lp E p)
hfg : ↑↑|f| ≤ᵐ[μ] ↑↑|g|
⊢ ‖f‖ ≤ ‖g‖

Next tactic:
simp_rw [Lp.norm_def, ENNReal.toReal_le_toReal (Lp.snorm_ne_top f) (Lp.snorm_ne_top g)]
noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) :=
  { Lp.instLattice, Lp.instNormedAddCommGroup with
    add_le_add_left := fun f g => add_le_add_left
    solid := fun f g hfg => by
      rw [← coeFn_le] at hfg
      simp_rw [Lp.norm_def, ENNReal.toReal_le_toReal (Lp.snorm_ne_top f) (Lp.snorm_ne_top g)]
      

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedLatticeAddCommGroup E
inst✝ : Fact (1 ≤ p)
src✝¹ : Lattice ↥(Lp E p) := instLattice
src✝ : NormedAddCommGroup ↥(Lp E p) := instNormedAddCommGroup
f g : ↥(Lp E p)
hfg : ↑↑|f| ≤ᵐ[μ] ↑↑|g|
⊢ snorm (↑↑f) p μ ≤ snorm (↑↑g) p μ

Next tactic:
refine' snorm_mono_ae _
noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) :=
  { Lp.instLattice, Lp.instNormedAddCommGroup with
    add_le_add_left := fun f g => add_le_add_left
    solid := fun f g hfg => by
      rw [← coeFn_le] at hfg
      simp_rw [Lp.norm_def, ENNReal.toReal_le_toReal (Lp.snorm_ne_top f) (Lp.snorm_ne_top g)]
      refine' snorm_mono_ae _
      

Proof state:
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedLatticeAddCommGroup E
inst✝ : Fact (1 ≤ p)
src✝¹ : Lattice ↥(Lp E p) := instLattice
src✝ : NormedAddCommGroup ↥(Lp E p) := instNormedAddCommGroup
f g : ↥(Lp E p)
hfg : ↑↑|f| ≤ᵐ[μ] ↑↑|g|
⊢ ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ ‖↑↑g x‖

Next tactic:
filter_upwards [hfg, Lp.coeFn_abs f, Lp.coeFn_abs g] with x hx hxf hxg
noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) :=
  { Lp.instLattice, Lp.instNormedAddCommGroup with
    add_le_add_left := fun f g => add_le_add_left
    solid := fun f g hfg => by
      rw [← coeFn_le] at hfg
      simp_rw [Lp.norm_def, ENNReal.toReal_le_toReal (Lp.snorm_ne_top f) (Lp.snorm_ne_top g)]
      refine' snorm_mono_ae _
      filter_upwards [hfg, Lp.coeFn_abs f, Lp.coeFn_abs g] with x hx hxf hxg
      

Proof state:
case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedLatticeAddCommGroup E
inst✝ : Fact (1 ≤ p)
src✝¹ : Lattice ↥(Lp E p) := instLattice
src✝ : NormedAddCommGroup ↥(Lp E p) := instNormedAddCommGroup
f g : ↥(Lp E p)
hfg : ↑↑|f| ≤ᵐ[μ] ↑↑|g|
x : α
hx : ↑↑|f| x ≤ ↑↑|g| x
hxf : ↑↑|f| x = |↑↑f x|
hxg : ↑↑|g| x = |↑↑g x|
⊢ ‖↑↑f x‖ ≤ ‖↑↑g x‖

Next tactic:
rw [hxf, hxg] at hx
noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) :=
  { Lp.instLattice, Lp.instNormedAddCommGroup with
    add_le_add_left := fun f g => add_le_add_left
    solid := fun f g hfg => by
      rw [← coeFn_le] at hfg
      simp_rw [Lp.norm_def, ENNReal.toReal_le_toReal (Lp.snorm_ne_top f) (Lp.snorm_ne_top g)]
      refine' snorm_mono_ae _
      filter_upwards [hfg, Lp.coeFn_abs f, Lp.coeFn_abs g] with x hx hxf hxg
      rw [hxf, hxg] at hx
      

Proof state:
case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedLatticeAddCommGroup E
inst✝ : Fact (1 ≤ p)
src✝¹ : Lattice ↥(Lp E p) := instLattice
src✝ : NormedAddCommGroup ↥(Lp E p) := instNormedAddCommGroup
f g : ↥(Lp E p)
hfg : ↑↑|f| ≤ᵐ[μ] ↑↑|g|
x : α
hx : |↑↑f x| ≤ |↑↑g x|
hxf : ↑↑|f| x = |↑↑f x|
hxg : ↑↑|g| x = |↑↑g x|
⊢ ‖↑↑f x‖ ≤ ‖↑↑g x‖

Next tactic:
exact HasSolidNorm.solid hx
@[simp]
theorem reverse_cons : reverse (x ::ᵥ xs) = (reverse xs).snoc x := by
  

Proof state:
α : Type u_1
n : ℕ
xs : Vector α n
x : α
⊢ reverse (x ::ᵥ xs) = snoc (reverse xs) x

Next tactic:
cases xs
@[simp]
theorem reverse_cons : reverse (x ::ᵥ xs) = (reverse xs).snoc x := by
  cases xs
  

Proof state:
case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ reverse (x ::ᵥ { val := val✝, property := property✝ }) = snoc (reverse { val := val✝, property := property✝ }) x

Next tactic:
simp only [reverse, cons, toList_mk, List.reverse_cons, snoc]
@[simp]
theorem reverse_cons : reverse (x ::ᵥ xs) = (reverse xs).snoc x := by
  cases xs
  simp only [reverse, cons, toList_mk, List.reverse_cons, snoc]
  

Proof state:
case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ { val := List.reverse val✝ ++ [x],
      property := (_ : (fun l => List.length l = Nat.succ n) (List.reverse val✝ ++ [x])) } =
    append { val := List.reverse val✝, property := (_ : (fun l => List.length l = n) (List.reverse val✝)) }
      { val := [x], property := (_ : Nat.succ (List.length []) = Nat.succ 0) }

Next tactic:
congr
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs) := by
  

Proof state:
α : Type u_1
n : ℕ
xs : Vector α n
x : α
⊢ reverse (snoc xs x) = x ::ᵥ reverse xs

Next tactic:
cases xs
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs) := by
  cases xs
  

Proof state:
case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ reverse (snoc { val := val✝, property := property✝ } x) = x ::ᵥ reverse { val := val✝, property := property✝ }

Next tactic:
simp only [reverse, snoc, cons, toList_mk]
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs) := by
  cases xs
  simp only [reverse, snoc, cons, toList_mk]
  

Proof state:
case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ {
      val :=
        List.reverse
          (toList
            (append { val := val✝, property := property✝ }
              { val := [x], property := (_ : Nat.succ (List.length []) = Nat.succ 0) })),
      property :=
        (_ :
          (fun l => List.length l = n + 1)
            (List.reverse
              (toList
                (append { val := val✝, property := property✝ }
                  { val := [x], property := (_ : Nat.succ (List.length []) = Nat.succ 0) })))) } =
    { val := x :: List.reverse val✝, property := (_ : Nat.succ (List.length (List.reverse val✝)) = Nat.succ n) }

Next tactic:
congr
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs) := by
  cases xs
  simp only [reverse, snoc, cons, toList_mk]
  congr
  

Proof state:
case mk.e_val
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ List.reverse
      (toList
        (append { val := val✝, property := property✝ }
          { val := [x], property := (_ : Nat.succ (List.length []) = Nat.succ 0) })) =
    x :: List.reverse val✝

Next tactic:
simp [toList, (·++·), Vector.append, Append.append]
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs) := by
  cases xs
  simp only [reverse, snoc, cons, toList_mk]
  congr
  simp [toList, (·++·), Vector.append, Append.append]
  

Proof state:
case mk.e_val
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ [] ++ [x] ++ List.reverse val✝ = x :: List.reverse val✝

Next tactic:
rfl
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val := by
  

Proof state:
α : Type u_1
n : ℕ
xs : Vector α n
val : α
⊢ replicate (n + 1) val = snoc (replicate n val) val

Next tactic:
clear xs
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val := by
  clear xs
  

Proof state:
α : Type u_1
n : ℕ
val : α
⊢ replicate (n + 1) val = snoc (replicate n val) val

Next tactic:
induction n
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val := by
  clear xs
  induction n
  

Proof state:
case zero
α : Type u_1
n : ℕ
val : α
⊢ replicate (Nat.zero + 1) val = snoc (replicate Nat.zero val) val
case succ
α : Type u_1
n : ℕ
val : α
n✝ : ℕ
n_ih✝ : replicate (n✝ + 1) val = snoc (replicate n✝ val) val
⊢ replicate (Nat.succ n✝ + 1) val = snoc (replicate (Nat.succ n✝) val) val

Next tactic:
case zero => rfl
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val := by
  clear xs
  induction n
  

Proof state:
α : Type u_1
n : ℕ
val : α
⊢ replicate (Nat.zero + 1) val = snoc (replicate Nat.zero val) val

Next tactic:
case zero => rfl
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val := by
  clear xs
  induction n
  case zero => 

Proof state:
α : Type u_1
n : ℕ
val : α
⊢ replicate (Nat.zero + 1) val = snoc (replicate Nat.zero val) val

Next tactic:
rfl
theorem replicate_succ_to_snoc (val : α) :
    replicate (n+1) val = (replicate n val).snoc val := by
  clear xs
  induction n
  case zero => rfl
  

Proof state:
case succ
α : Type u_1
n : ℕ
val : α
n✝ : ℕ
n_ih✝ : replicate (n✝ + 1) val = snoc (replicate n✝ val) val
⊢ replicate (Nat.succ n✝ + 1) val = snoc (replicate (Nat.succ n✝) val) val

Next tactic:
case succ n ih =>
    rw [replicate_succ]
    conv => {
      rhs; rw [replicate_succ]
    }
    rw[snoc_cons, ih]