l3lab/ntp-mathlib huggingface dataset:
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    

Proof state:
case h
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
x : α
hx : Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
⊢ Tendsto (fun n => ↑(fs n) x * g x) atTop (𝓝 (f x * g x))

Next tactic:
exact Tendsto.mul hx tendsto_const_nhds
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · 

Proof state:
case neg.refine'_4
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
⊢ ∀ᵐ (x : α) ∂μ, Tendsto (fun n => (fun n x => ↑(fs n) x * (μ[g|m]) x) n x) atTop (𝓝 ((f * μ[g|m]) x))

Next tactic:
filter_upwards [hfs_tendsto] with x hx
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    

Proof state:
case h
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
x : α
hx : Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
⊢ Tendsto (fun n => ↑(fs n) x * (μ[g|m]) x) atTop (𝓝 ((f * μ[g|m]) x))

Next tactic:
rw [Pi.mul_apply]
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    

Proof state:
case h
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
x : α
hx : Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
⊢ Tendsto (fun n => ↑(fs n) x * (μ[g|m]) x) atTop (𝓝 (f x * (μ[g|m]) x))

Next tactic:
exact Tendsto.mul hx tendsto_const_nhds
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · 

Proof state:
case neg.refine'_5
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
⊢ Integrable fun x => c * ‖g x‖

Next tactic:
exact hg.norm.const_mul c
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · exact hg.norm.const_mul c
  · 

Proof state:
case neg.refine'_6
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
⊢ Integrable fun x => c * ‖(μ[g|m]) x‖

Next tactic:
exact integrable_condexp.norm.const_mul c
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · exact hg.norm.const_mul c
  · exact integrable_condexp.norm.const_mul c
  · 

Proof state:
case neg.refine'_7
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
⊢ ∀ (n : ℕ), ∀ᵐ (x : α) ∂μ, ‖(fun n x => ↑(fs n) x * g x) n x‖ ≤ (fun x => c * ‖g x‖) x

Next tactic:
refine' fun n => eventually_of_forall fun x => _
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · exact hg.norm.const_mul c
  · exact integrable_condexp.norm.const_mul c
  · refine' fun n => eventually_of_forall fun x => _
    

Proof state:
case neg.refine'_7
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
n : ℕ
x : α
⊢ ‖(fun n x => ↑(fs n) x * g x) n x‖ ≤ (fun x => c * ‖g x‖) x

Next tactic:
exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (hfs_bound n x) (norm_nonneg _))
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · exact hg.norm.const_mul c
  · exact integrable_condexp.norm.const_mul c
  · refine' fun n => eventually_of_forall fun x => _
    exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (hfs_bound n x) (norm_nonneg _))
  · 

Proof state:
case neg.refine'_8
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
⊢ ∀ (n : ℕ), ∀ᵐ (x : α) ∂μ, ‖(fun n x => ↑(fs n) x * (μ[g|m]) x) n x‖ ≤ (fun x => c * ‖(μ[g|m]) x‖) x

Next tactic:
refine' fun n => eventually_of_forall fun x => _
theorem condexp_stronglyMeasurable_mul_of_bound (hm : m ≤ m0) [IsFiniteMeasure μ] {f g : α → ℝ}
    (hf : StronglyMeasurable[m] f) (hg : Integrable g μ) (c : ℝ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    μ[f * g|m] =ᵐ[μ] f * μ[g|m] := by
  let fs := hf.approxBounded c
  have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
  by_cases hμ : μ = 0
  · simp only [hμ, ae_zero]; norm_cast
  have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
  have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
  have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
  have : μ[f * μ[g|m]|m] = f * μ[g|m] := by
    refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
    exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
  rw [← this]
  refine' tendsto_condexp_unique (fun n x => fs n x * g x) (fun n x => fs n x * (μ[g|m]) x) (f * g)
    (f * μ[g|m]) _ _ _ _ (fun x => c * ‖g x‖) _ (fun x => c * ‖(μ[g|m]) x‖) _ _ _ _
  · exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · filter_upwards [hfs_tendsto] with x hx
    rw [Pi.mul_apply]
    exact Tendsto.mul hx tendsto_const_nhds
  · exact hg.norm.const_mul c
  · exact integrable_condexp.norm.const_mul c
  · refine' fun n => eventually_of_forall fun x => _
    exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (hfs_bound n x) (norm_nonneg _))
  · refine' fun n => eventually_of_forall fun x => _
    

Proof state:
case neg.refine'_8
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : IsFiniteMeasure μ
f g : α → ℝ
hf : StronglyMeasurable f
hg : Integrable g
c : ℝ
hf_bound : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c
fs : ℕ → SimpleFunc α ℝ := StronglyMeasurable.approxBounded hf c
hfs_tendsto : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => ↑(fs n) x) atTop (𝓝 (f x))
hμ : ¬μ = 0
this✝ : NeBot (Measure.ae μ)
hc : 0 ≤ c
hfs_bound : ∀ (n : ℕ) (x : α), ‖↑(fs n) x‖ ≤ c
this : μ[f * μ[g|m]|m] = f * μ[g|m]
n : ℕ
x : α
⊢ ‖(fun n x => ↑(fs n) x * (μ[g|m]) x) n x‖ ≤ (fun x => c * ‖(μ[g|m]) x‖) x

Next tactic:
exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (hfs_bound n x) (norm_nonneg _))