Theorem: MeasureTheory.lintegral_iSup
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: set c : ℝ≥0 → ℝ≥0∞ := (↑)
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
⊢ (∫⁻ (a : α), ⨆ (n : ℕ), f n a ∂μ) = ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: set F := fun a : α => ⨆ n, f n a
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
⊢ (∫⁻ (a : α), ⨆ (n : ℕ), f n a ∂μ) = ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: have _ : Measurable F := measurable_iSup hf
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
⊢ lintegral μ F = ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: refine' le_antisymm _ (iSup_lintegral_le _)
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
⊢ lintegral μ F = ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: rw [lintegral_eq_nnreal]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
⊢ lintegral μ F ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: refine' iSup_le fun s => iSup_le fun hsf => _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
⊢ (⨆ (φ : α →ₛ ℝ≥0) (_ : ∀ (x : α), ↑(↑φ x) ≤ ⨆ (n : ℕ), f n x),
      SimpleFunc.lintegral (SimpleFunc.map ENNReal.some φ) μ) ≤
    ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: refine' ENNReal.le_of_forall_lt_one_mul_le fun a ha => _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
⊢ SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: rcases ENNReal.lt_iff_exists_coe.1 ha with ⟨r, rfl, _⟩
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
a : ℝ≥0∞
ha : a < 1
⊢ a * SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: have ha : r < 1 := ENNReal.coe_lt_coe.1 ha
state_before: case intro.intro
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha : ↑r < 1
⊢ ↑r * SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: let rs := s.map fun a => r * a
state_before: case intro.intro
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
⊢ ↑r * SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: have eq_rs : (const α r : α →ₛ ℝ≥0∞) * map c s = rs.map c := by
  ext1 a
  exact ENNReal.coe_mul.symm
state_before: case intro.intro
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
⊢ ↑r * SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: have mono : ∀ r : ℝ≥0∞, Monotone fun n => rs.map c ⁻¹' {r} ∩ { a | r ≤ f n a } := by
  intro r i j h
  refine' inter_subset_inter (Subset.refl _) _
  intro x (hx : r ≤ f i x)
  exact le_trans hx (h_mono h x)
state_before: case intro.intro
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
⊢ ↑r * SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: have h_meas : ∀ n, MeasurableSet { a : α | (⇑(map c rs)) a ≤ f n a } := fun n =>
  measurableSet_le (SimpleFunc.measurable _) (hf n)
state_before: case intro.intro
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
⊢ ↑r * SimpleFunc.lintegral (SimpleFunc.map ENNReal.some s) μ ≤ ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: ext1 a
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
⊢ const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs

tactic: exact ENNReal.coe_mul.symm
state_before: case H
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
a : α
⊢ ↑(const α ↑r * SimpleFunc.map c s) a = ↑(SimpleFunc.map c rs) a

tactic: intro p
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
⊢ ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}

tactic: rw [← inter_iUnion]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
⊢ ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}

tactic: nth_rw 1 [← inter_univ (map c rs ⁻¹' {p})]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
⊢ ↑(SimpleFunc.map c rs) ⁻¹' {p} = ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ ⋃ (i : ℕ), {a | p ≤ f i a}

tactic: refine' Set.ext fun x => and_congr_right fun hx => true_iff_iff.2 _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
⊢ ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ univ = ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ ⋃ (i : ℕ), {a | p ≤ f i a}

tactic: by_cases p_eq : p = 0
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
x : α
hx : x ∈ ↑(SimpleFunc.map c rs) ⁻¹' {p}
⊢ x ∈ ⋃ (i : ℕ), {a | p ≤ f i a}

tactic: simp [-ENNReal.coe_mul] at hx
state_before: case neg
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
x : α
hx : x ∈ ↑(SimpleFunc.map c rs) ⁻¹' {p}
p_eq : ¬p = 0
⊢ x ∈ ⋃ (i : ℕ), {a | p ≤ f i a}

tactic: subst hx
state_before: case neg
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
x : α
p_eq : ¬p = 0
hx : ↑(r * ↑s x) = p
⊢ x ∈ ⋃ (i : ℕ), {a | p ≤ f i a}

tactic: have : r * s x ≠ 0 := by rwa [Ne, ← ENNReal.coe_eq_zero]
state_before: case neg
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
⊢ x ∈ ⋃ (i : ℕ), {a | ↑(r * ↑s x) ≤ f i a}

tactic: have : s x ≠ 0 := by
  refine' mt _ this
  intro h
  rw [h, MulZeroClass.mul_zero]
state_before: case neg
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this : r * ↑s x ≠ 0
⊢ x ∈ ⋃ (i : ℕ), {a | ↑(r * ↑s x) ≤ f i a}

tactic: have : (rs.map c) x < ⨆ n : ℕ, f n x := by
  refine' lt_of_lt_of_le (ENNReal.coe_lt_coe.2 _) (hsf x)
  suffices : r * s x < 1 * s x
  simpa
  exact mul_lt_mul_of_pos_right ha (pos_iff_ne_zero.2 this)
state_before: case neg
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝ : r * ↑s x ≠ 0
this : ↑s x ≠ 0
⊢ x ∈ ⋃ (i : ℕ), {a | ↑(r * ↑s x) ≤ f i a}

tactic: rcases lt_iSup_iff.1 this with ⟨i, hi⟩
state_before: case neg
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝¹ : r * ↑s x ≠ 0
this✝ : ↑s x ≠ 0
this : ↑(SimpleFunc.map c rs) x < ⨆ (n : ℕ), f n x
⊢ x ∈ ⋃ (i : ℕ), {a | ↑(r * ↑s x) ≤ f i a}

tactic: exact mem_iUnion.2 ⟨i, le_of_lt hi⟩
state_before: case neg.intro
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝¹ : r * ↑s x ≠ 0
this✝ : ↑s x ≠ 0
this : ↑(SimpleFunc.map c rs) x < ⨆ (n : ℕ), f n x
i : ℕ
hi : ↑(SimpleFunc.map c rs) x < f i x
⊢ x ∈ ⋃ (i : ℕ), {a | ↑(r * ↑s x) ≤ f i a}

tactic: simp [p_eq]
state_before: case pos
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
p : ℝ≥0∞
x : α
hx : x ∈ ↑(SimpleFunc.map c rs) ⁻¹' {p}
p_eq : p = 0
⊢ x ∈ ⋃ (i : ℕ), {a | p ≤ f i a}

tactic: rwa [Ne, ← ENNReal.coe_eq_zero]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
⊢ r * ↑s x ≠ 0

tactic: refine' mt _ this
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this : r * ↑s x ≠ 0
⊢ ↑s x ≠ 0

tactic: intro h
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this : r * ↑s x ≠ 0
⊢ ↑s x = 0 → r * ↑s x = 0

tactic: rw [h, MulZeroClass.mul_zero]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this : r * ↑s x ≠ 0
h : ↑s x = 0
⊢ r * ↑s x = 0

tactic: refine' lt_of_lt_of_le (ENNReal.coe_lt_coe.2 _) (hsf x)
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝ : r * ↑s x ≠ 0
this : ↑s x ≠ 0
⊢ ↑(SimpleFunc.map c rs) x < ⨆ (n : ℕ), f n x

tactic: suffices : r * s x < 1 * s x
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝ : r * ↑s x ≠ 0
this : ↑s x ≠ 0
⊢ ↑rs x < ↑s x

tactic: simpa
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝¹ : r * ↑s x ≠ 0
this✝ : ↑s x ≠ 0
this : r * ↑s x < 1 * ↑s x
⊢ ↑rs x < ↑s x

case this
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝ : r * ↑s x ≠ 0
this : ↑s x ≠ 0
⊢ r * ↑s x < 1 * ↑s x

tactic: exact mul_lt_mul_of_pos_right ha (pos_iff_ne_zero.2 this)
state_before: case this
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
x : α
p_eq : ¬↑(r * ↑s x) = 0
this✝ : r * ↑s x ≠ 0
this : ↑s x ≠ 0
⊢ r * ↑s x < 1 * ↑s x

tactic: intro r i j h
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
⊢ ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}

tactic: refine' inter_subset_inter (Subset.refl _) _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r✝ : ℝ≥0
right✝ ha✝ : ↑r✝ < 1
ha : r✝ < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r✝ * a) s
eq_rs : const α ↑r✝ * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
r : ℝ≥0∞
i j : ℕ
h : i ≤ j
⊢ (fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}) i ≤
    (fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}) j

tactic: intro x (hx : r ≤ f i x)
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r✝ : ℝ≥0
right✝ ha✝ : ↑r✝ < 1
ha : r✝ < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r✝ * a) s
eq_rs : const α ↑r✝ * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
r : ℝ≥0∞
i j : ℕ
h : i ≤ j
⊢ {a | r ≤ f i a} ⊆ {a | r ≤ f j a}

tactic: exact le_trans hx (h_mono h x)
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r✝ : ℝ≥0
right✝ ha✝ : ↑r✝ < 1
ha : r✝ < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r✝ * a) s
eq_rs : const α ↑r✝ * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
r : ℝ≥0∞
i j : ℕ
h : i ≤ j
x : α
hx : r ≤ f i x
⊢ x ∈ {a | r ≤ f j a}

tactic: rw [← const_mul_lintegral, eq_rs, SimpleFunc.lintegral]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
⊢ ↑r * SimpleFunc.lintegral (SimpleFunc.map c s) μ =
    ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r})

tactic: simp only [(eq _).symm]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
⊢ ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r}) =
    ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a})

tactic: rw [measure_iUnion_eq_iSup (directed_of_sup <| mono x), ENNReal.mul_iSup]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝¹ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
x : ℝ≥0∞
x✝ : x ∈ SimpleFunc.range (SimpleFunc.map c rs)
⊢ x * ↑↑μ (⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {x} ∩ {a | x ≤ f n a}) =
    ⨆ (n : ℕ), x * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {x} ∩ {a | x ≤ f n a})

tactic: rw [ENNReal.finset_sum_iSup_nat]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
⊢ (∑ r in SimpleFunc.range (SimpleFunc.map c rs),
      ⨆ (n : ℕ), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a})) =
    ⨆ (n : ℕ), ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a})

tactic: intro p i j h
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
⊢ ∀ (a : ℝ≥0∞), Monotone fun n => a * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {a} ∩ {a_1 | a ≤ f n a_1})

tactic: exact mul_le_mul_left' (measure_mono <| mono p h) _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
p : ℝ≥0∞
i j : ℕ
h : i ≤ j
⊢ (fun n => p * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a})) i ≤
    (fun n => p * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a})) j

tactic: refine' iSup_mono fun n => _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
⊢ (⨆ (n : ℕ),
      ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a})) ≤
    ⨆ (n : ℕ), SimpleFunc.lintegral (restrict (SimpleFunc.map c rs) {a | ↑(SimpleFunc.map c rs) a ≤ f n a}) μ

tactic: rw [restrict_lintegral _ (h_meas n)]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
⊢ ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}) ≤
    SimpleFunc.lintegral (restrict (SimpleFunc.map c rs) {a | ↑(SimpleFunc.map c rs) a ≤ f n a}) μ

tactic: refine' le_of_eq (Finset.sum_congr rfl fun r _ => _)
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
⊢ ∑ r in SimpleFunc.range (SimpleFunc.map c rs), r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}) ≤
    ∑ r in SimpleFunc.range (SimpleFunc.map c rs),
      r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | ↑(SimpleFunc.map c rs) a ≤ f n a})

tactic: congr 2 with a
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝¹ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r✝ : ℝ≥0
right✝ ha✝ : ↑r✝ < 1
ha : r✝ < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r✝ * a) s
eq_rs : const α ↑r✝ * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
r : ℝ≥0∞
x✝ : r ∈ SimpleFunc.range (SimpleFunc.map c rs)
⊢ r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}) =
    r * ↑↑μ (↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | ↑(SimpleFunc.map c rs) a ≤ f n a})

tactic: refine' and_congr_right _
state_before: case e_a.e_a.h
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝¹ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r✝ : ℝ≥0
right✝ ha✝ : ↑r✝ < 1
ha : r✝ < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r✝ * a) s
eq_rs : const α ↑r✝ * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
r : ℝ≥0∞
x✝ : r ∈ SimpleFunc.range (SimpleFunc.map c rs)
a : α
⊢ a ∈ ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a} ↔
    a ∈ ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | ↑(SimpleFunc.map c rs) a ≤ f n a}

tactic: simp (config := { contextual := true })
state_before: case e_a.e_a.h
α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝¹ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r✝ : ℝ≥0
right✝ ha✝ : ↑r✝ < 1
ha : r✝ < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r✝ * a) s
eq_rs : const α ↑r✝ * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
r : ℝ≥0∞
x✝ : r ∈ SimpleFunc.range (SimpleFunc.map c rs)
a : α
⊢ a ∈ ↑(SimpleFunc.map c rs) ⁻¹' {r} → (a ∈ {a | r ≤ f n a} ↔ a ∈ {a | ↑(SimpleFunc.map c rs) a ≤ f n a})

tactic: refine' iSup_mono fun n => _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
⊢ (⨆ (n : ℕ), SimpleFunc.lintegral (restrict (SimpleFunc.map c rs) {a | ↑(SimpleFunc.map c rs) a ≤ f n a}) μ) ≤
    ⨆ (n : ℕ), ∫⁻ (a : α), f n a ∂μ

tactic: rw [← SimpleFunc.lintegral_eq_lintegral]
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
⊢ SimpleFunc.lintegral (restrict (SimpleFunc.map c rs) {a | ↑(SimpleFunc.map c rs) a ≤ f n a}) μ ≤ ∫⁻ (a : α), f n a ∂μ

tactic: refine' lintegral_mono fun a => _
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
⊢ (∫⁻ (a : α), ↑(restrict (SimpleFunc.map c rs) {a | ↑(SimpleFunc.map c rs) a ≤ f n a}) a ∂μ) ≤ ∫⁻ (a : α), f n a ∂μ

tactic: simp only [map_apply] at h_meas
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(SimpleFunc.map c rs) a ≤ f n a}
n : ℕ
a : α
⊢ ↑(restrict (SimpleFunc.map c rs) {a | ↑(SimpleFunc.map c rs) a ≤ f n a}) a ≤ f n a

tactic: exact indicator_apply_le id
state_before: α : Type u_1
β : Type ?u.296965
γ : Type ?u.296968
δ : Type ?u.296971
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ENNReal.some
F : α → ℝ≥0∞ := fun a => ⨆ (n : ℕ), f n a
x✝ : Measurable F
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(↑s x) ≤ ⨆ (n : ℕ), f n x
r : ℝ≥0
right✝ ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : const α ↑r * SimpleFunc.map c s = SimpleFunc.map c rs
eq : ∀ (p : ℝ≥0∞), ↑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ (n : ℕ), ↑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ↑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | ↑(r * ↑s a) ≤ f n a}
n : ℕ
a : α
⊢ indicator {a | ↑(r * ↑s a) ≤ f n a} (fun x => ↑(r * ↑s x)) a ≤ f n a