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

tactic: have h_bound_finite : ∀ᵐ a ∂μ, F a ≠ ∞ := by
  filter_upwards [ae_lt_top' hF_meas h_int_finite] with a ha using ha.ne
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))

tactic: classical
let F' : α → ℝ≥0∞ := fun a ↦ if h : ∃ l, Tendsto (fun i ↦ f i a) atTop (𝓝 l)
  then h.choose else ∞
have hF'_tendsto : ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F' a)) := by
  filter_upwards [h_exists] with a ha
  simp_rw [F', dif_pos ha]
  exact ha.choose_spec
suffices F' =ᵐ[μ] F by
  filter_upwards [this, hF'_tendsto] with a h_eq h_tendsto using h_eq ▸ h_tendsto
have hF'_le : F' ≤ᵐ[μ] F := by
  filter_upwards [h_bound, hF'_tendsto] with a h_le h_tendsto
  exact le_of_tendsto' h_tendsto (fun m ↦ h_le _)
suffices ∫⁻ a, F' a ∂μ = ∫⁻ a, F a ∂μ from
  ae_eq_of_ae_le_of_lintegral_le hF'_le (this ▸ h_int_finite) hF_meas this.symm.le
refine tendsto_nhds_unique ?_ hf_tendsto
exact lintegral_tendsto_of_tendsto_of_monotone hf_meas hf_mono hF'_tendsto
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
state_after: no goals

tactic: filter_upwards [ae_lt_top' hF_meas h_int_finite] with a ha using ha.ne
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
⊢ ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
state_after: no goals

tactic: filter_upwards [h_bound, h_bound_finite, hf_mono] with a h_le h_fin h_mono
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
⊢ ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)

tactic: have h_tendsto : Tendsto (fun i ↦ f i a) atTop atTop ∨
    ∃ l, Tendsto (fun i ↦ f i a) atTop (𝓝 l) := tendsto_of_monotone h_mono
state_before: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_tendsto : Tendsto (fun i => f i a) atTop atTop ∨ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)

tactic: cases' h_tendsto with h_absurd h_tendsto
state_before: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_tendsto : Tendsto (fun i => f i a) atTop atTop ∨ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: case h.inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : Tendsto (fun i => f i a) atTop atTop
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)

case h.inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_tendsto : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)

tactic: rw [tendsto_atTop_atTop_iff_of_monotone h_mono] at h_absurd
state_before: case h.inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : Tendsto (fun i => f i a) atTop atTop
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: case h.inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : ∀ (b : ℝ≥0∞), ∃ a_1, b ≤ f a_1 a
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)

tactic: obtain ⟨i, hi⟩ := h_absurd (F a + 1)
state_before: case h.inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : ∀ (b : ℝ≥0∞), ∃ a_1, b ≤ f a_1 a
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: case h.inl.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : ∀ (b : ℝ≥0∞), ∃ a_1, b ≤ f a_1 a
i : ℕ
hi : F a + 1 ≤ f i a
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)

tactic: refine absurd (hi.trans (h_le _)) (not_le.mpr ?_)
state_before: case h.inl.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : ∀ (b : ℝ≥0∞), ∃ a_1, b ≤ f a_1 a
i : ℕ
hi : F a + 1 ≤ f i a
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: case h.inl.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : ∀ (b : ℝ≥0∞), ∃ a_1, b ≤ f a_1 a
i : ℕ
hi : F a + 1 ≤ f i a
⊢ F a < F a + 1

tactic: exact ENNReal.lt_add_right h_fin one_ne_zero
state_before: case h.inl.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_absurd : ∀ (b : ℝ≥0∞), ∃ a_1, b ≤ f a_1 a
i : ℕ
hi : F a + 1 ≤ f i a
⊢ F a < F a + 1
state_after: no goals

tactic: exact h_tendsto
state_before: case h.inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_fin : F a ≠ ⊤
h_mono : Monotone fun i => f i a
h_tendsto : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
state_after: no goals

tactic: let F' : α → ℝ≥0∞ := fun a ↦ if h : ∃ l, Tendsto (fun i ↦ f i a) atTop (𝓝 l)
  then h.choose else ∞
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))

tactic: have hF'_tendsto : ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F' a)) := by
  filter_upwards [h_exists] with a ha
  simp_rw [F', dif_pos ha]
  exact ha.choose_spec
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))

tactic: suffices F' =ᵐ[μ] F by
  filter_upwards [this, hF'_tendsto] with a h_eq h_tendsto using h_eq ▸ h_tendsto
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ F' =ᶠ[ae μ] F

tactic: have hF'_le : F' ≤ᵐ[μ] F := by
  filter_upwards [h_bound, hF'_tendsto] with a h_le h_tendsto
  exact le_of_tendsto' h_tendsto (fun m ↦ h_le _)
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ F' =ᶠ[ae μ] F
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
hF'_le : F' ≤ᶠ[ae μ] F
⊢ F' =ᶠ[ae μ] F

tactic: suffices ∫⁻ a, F' a ∂μ = ∫⁻ a, F a ∂μ from
  ae_eq_of_ae_le_of_lintegral_le hF'_le (this ▸ h_int_finite) hF_meas this.symm.le
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
hF'_le : F' ≤ᶠ[ae μ] F
⊢ F' =ᶠ[ae μ] F
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
hF'_le : F' ≤ᶠ[ae μ] F
⊢ ∫⁻ (a : α), F' a ∂μ = ∫⁻ (a : α), F a ∂μ

tactic: refine tendsto_nhds_unique ?_ hf_tendsto
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
hF'_le : F' ≤ᶠ[ae μ] F
⊢ ∫⁻ (a : α), F' a ∂μ = ∫⁻ (a : α), F a ∂μ
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
hF'_le : F' ≤ᶠ[ae μ] F
⊢ Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F' a ∂μ))

tactic: exact lintegral_tendsto_of_tendsto_of_monotone hf_meas hf_mono hF'_tendsto
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
hF'_le : F' ≤ᶠ[ae μ] F
⊢ Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F' a ∂μ))
state_after: no goals

tactic: filter_upwards [h_exists] with a ha
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
state_after: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
a : α
ha : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ Tendsto (fun i => f i a) atTop (𝓝 (F' a))

tactic: simp_rw [F', dif_pos ha]
state_before: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
a : α
ha : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ Tendsto (fun i => f i a) atTop (𝓝 (F' a))
state_after: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
a : α
ha : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ Tendsto (fun i => f i a) atTop (𝓝 ha.choose)

tactic: exact ha.choose_spec
state_before: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
a : α
ha : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
⊢ Tendsto (fun i => f i a) atTop (𝓝 ha.choose)
state_after: no goals

tactic: filter_upwards [this, hF'_tendsto] with a h_eq h_tendsto using h_eq ▸ h_tendsto
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
this : F' =ᶠ[ae μ] F
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
state_after: no goals

tactic: filter_upwards [h_bound, hF'_tendsto] with a h_le h_tendsto
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ F' ≤ᶠ[ae μ] F
state_after: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_tendsto : Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ F' a ≤ F a

tactic: exact le_of_tendsto' h_tendsto (fun m ↦ h_le _)
state_before: case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α✝
μ✝ ν : Measure α✝
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hF_meas : AEMeasurable F μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Monotone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), f i a ≤ F a
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_bound_finite : ∀ᵐ (a : α) ∂μ, F a ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
a : α
h_le : ∀ (i : ℕ), f i a ≤ F a
h_tendsto : Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ F' a ≤ F a
state_after: no goals