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
  

Proof state:
α : 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
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
let fs := hf.approxBounded 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
  

Proof state:
α : 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
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
have hfs_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x)) :=
    hf.tendsto_approxBounded_ae hf_bound
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
  

Proof state:
α : 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))
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
by_cases hμ : μ = 0
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
  · 

Proof state:
case pos
α : 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
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
simp only [hμ, ae_zero]
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]; 

Proof state:
case pos
α : 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
⊢ 0[f * g|m] =ᶠ[⊥] f * 0[g|m]

Next tactic:
norm_cast
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
  

Proof state:
case neg
α : 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
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
have : μ.ae.NeBot := by simp only [hμ, ae_neBot, Ne.def, not_false_iff]
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 

Proof state:
α : 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
⊢ NeBot (Measure.ae μ)

Next tactic:
simp only [hμ, ae_neBot, Ne.def, not_false_iff]
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]
  

Proof state:
case neg
α : 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 μ)
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
have hc : 0 ≤ c :=
    haveI h_exists : ∃ x, ‖f x‖ ≤ c := Eventually.exists hf_bound
    (norm_nonneg _).trans h_exists.choose_spec
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
  

Proof state:
case neg
α : 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
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
have hfs_bound : ∀ n x, ‖fs n x‖ ≤ c := hf.norm_approxBounded_le hc
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
  

Proof state:
case neg
α : 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
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
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
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
    

Proof state:
α : 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
⊢ μ[f * μ[g|m]|m] = f * μ[g|m]

Next tactic:
refine' condexp_of_stronglyMeasurable hm (hf.mul stronglyMeasurable_condexp) _
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) _
    

Proof state:
α : 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
⊢ Integrable (f * μ[g|m])

Next tactic:
exact integrable_condexp.bdd_mul' (hf.mono hm).aestronglyMeasurable hf_bound
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
  

Proof state:
case neg
α : 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]
⊢ μ[f * g|m] =ᵐ[μ] f * μ[g|m]

Next tactic:
rw [← this]
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]
  

Proof state:
case neg
α : 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]
⊢ μ[f * g|m] =ᵐ[μ] μ[f * μ[g|m]|m]

Next tactic:
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‖) _ _ _ _
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‖) _ _ _ _
  · 

Proof state:
case neg.refine'_1
α : 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 : ℕ), Integrable ((fun n x => ↑(fs n) x * g x) n)

Next tactic:
exact fun n => hg.bdd_mul' ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
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))
  · 

Proof state:
case neg.refine'_2
α : 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 : ℕ), Integrable ((fun n x => ↑(fs n) x * (μ[g|m]) x) n)

Next tactic:
exact fun n => integrable_condexp.bdd_mul'
      ((SimpleFunc.stronglyMeasurable (fs n)).mono hm).aestronglyMeasurable
      (eventually_of_forall (hfs_bound n))
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))
  · 

Proof state:
case neg.refine'_3
α : 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 x) n x) atTop (𝓝 ((f * g) 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
    

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 * g) x))

Next tactic:
rw [Pi.mul_apply]