zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_49.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let e := fun t ω => rexp (t * X ω) * X ω;
  let e' := fun t ω => rexp (t * X ω) * X ω ^ 2;
  Integrable (e' t) μ ∧ HasDerivAt (fun t => ∫ (x : Ω), e t x ∂μ) (∫ (x : Ω), e' t x ∂μ) t →
    let g := fun t => ∫ (x : Ω), (fun ω => rexp (t * X ω) * X ω) x ∂μ;
    let g' := fun t => ∫ (x : Ω), (fun ω => rexp (t * X ω) * X ω ^ 2) x ∂μ;
    Integrable (fun ω => rexp (t * X ω) * X ω ^ 2) μ → HasDerivAt g (g' t) t := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
this : Integrable (e' t) μ ∧ HasDerivAt (fun t => ∫ (x : Ω), e t x ∂μ) (∫ (x : Ω), e' t x ∂μ) t
g✝ : ℝ → ℝ := fun t => ∫ (x : Ω), (fun ω => rexp (t * X ω) * X ω) x ∂μ
g'✝ : ℝ → ℝ := fun t => ∫ (x : Ω), (fun ω => rexp (t * X ω) * X ω ^ 2) x ∂μ
hint : Integrable (fun ω => rexp (t * X ω) * X ω ^ 2) μ
⊢ HasDerivAt g✝ (g'✝ t) t

Tactic:
apply this.2

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_53 (t : ℝ) : 0 < |t| + 1 := sorry

Tactic state before:
case ε_pos
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ 0 < ?ε

Tactic:
exact LE.le.trans_lt (abs_nonneg t) (lt_add_one |t|)

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_54.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let e := fun t ω => rexp (t * X ω) * X ω;
  (∀ᶠ (x : ℝ) in nhds t, AEStronglyMeasurable (e x) μ) → ∀ (x : ℝ), AEStronglyMeasurable (e x) μ := sorry

Tactic state before:
case hF_meas
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ ∀ᶠ (x : ℝ) in nhds t, AEStronglyMeasurable (e x) μ

Tactic:
apply Filter.Eventually.of_forall

Tactic state after:
[case hF_meas.hp
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ ∀ (x : ℝ), AEStronglyMeasurable (e x) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_55.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (t' : ℝ) (h_original_goal : AEStronglyMeasurable (fun ω => rexp (t' * X ω) * X ω) μ) :
  AEMeasurable (fun ω => rexp (t' * X ω) * X ω) μ := sorry

Tactic state before:
case hF_meas.hp
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
t' : ℝ
⊢ AEStronglyMeasurable (fun ω => rexp (t' * X ω) * X ω) μ

Tactic:
rw [aestronglyMeasurable_iff_aemeasurable]

Tactic state after:
[case hF_meas.hp
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 t' : ℝ
 ⊢ AEMeasurable (fun ω => rexp (t' * X ω) * X ω) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_56.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (t' : ℝ) (h_original_goal : AEMeasurable (fun ω => rexp (t' * X ω) * X ω) μ) :
  AEMeasurable (fun a => rexp (t' * X a)) μ := sorry

Tactic state before:
case hF_meas.hp
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
t' : ℝ
⊢ AEMeasurable (fun ω => rexp (t' * X ω) * X ω) μ

Tactic:
apply AEMeasurable.mul _ hX

Tactic state after:
[Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 t' : ℝ
 ⊢ AEMeasurable (fun a => rexp (t' * X a)) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_57.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (t' : ℝ) : AEMeasurable (fun a => rexp (t' * X a)) μ := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
t' : ℝ
⊢ AEMeasurable (fun a => rexp (t' * X a)) μ

Tactic:
exact Measurable.comp_aemeasurable' measurable_exp (hX.const_mul t')

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_58.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let e := fun t ω => rexp (t * X ω) * X ω;
  Integrable (e t) μ → Integrable (fun ω => rexp (t * X ω) * X ω) μ := sorry

Tactic state before:
case hF_int
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ Integrable (e t) μ

Tactic:
simp only [e]

Tactic state after:
[case hF_int
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ Integrable (fun ω => rexp (t * X ω) * X ω) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_59.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h_1 : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let c := ‖a‖ ⊔ ‖b‖;
  ∀ (ω : Ω), X ω ∈ Set.Icc a b → ‖rexp (t * X ω)‖ ≤ rexp (|t| * c) → t * X ω ≤ |t| * c := sorry

Tactic state before:
case h
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ ‖rexp (t * X ω)‖ ≤ rexp (|t| * c)

Tactic:
simp only [norm_eq_abs, abs_exp, exp_le_exp]

Tactic state after:
[case h
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ω : Ω
 h : X ω ∈ Set.Icc a b
 ⊢ t * X ω ≤ |t| * c]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_60.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h_1 : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let c := ‖a‖ ⊔ ‖b‖;
  ∀ (ω : Ω), X ω ∈ Set.Icc a b → |t| * |X ω| ≤ |t| * c → |X ω| ≤ c := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ |t| * |X ω| ≤ |t| * c

Tactic:
apply mul_le_mul_of_nonneg_left

Tactic state after:
[case h
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ω : Ω
 h : X ω ∈ Set.Icc a b
 ⊢ |X ω| ≤ c,
 case a0
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ω : Ω
 h : X ω ∈ Set.Icc a b
 ⊢ 0 ≤ |t|]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_61.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h_1 : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let c := ‖a‖ ⊔ ‖b‖;
  ∀ (ω : Ω), X ω ∈ Set.Icc a b → |t| * |X ω| ≤ |t| * c → 0 ≤ |t| := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ |t| * |X ω| ≤ |t| * c

Tactic:
apply mul_le_mul_of_nonneg_left

Tactic state after:
[case h
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ω : Ω
 h : X ω ∈ Set.Icc a b
 ⊢ |X ω| ≤ c,
 case a0
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ω : Ω
 h : X ω ∈ Set.Icc a b
 ⊢ 0 ≤ |t|]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_62.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h_1 : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let c := ‖a‖ ⊔ ‖b‖;
  ∀ (ω : Ω), X ω ∈ Set.Icc a b → |X ω| ≤ c → |X ω| ≤ |c| := sorry

Tactic state before:
case h
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ |X ω| ≤ c

Tactic:
rw [←
  (by dsimp only [c]; to_theorem simp only [norm_eq_abs, abs_eq_self, le_max_iff, abs_nonneg, or_self] : |c| = c)]

Tactic state after:
[case h
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ω : Ω
 h : X ω ∈ Set.Icc a b
 ⊢ |X ω| ≤ |c|]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_63.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h_1 : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (ω : Ω) (h : X ω ∈ Set.Icc a b) : |‖a‖ ⊔ ‖b‖| = ‖a‖ ⊔ ‖b‖ := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ |‖a‖ ⊔ ‖b‖| = ‖a‖ ⊔ ‖b‖

Tactic:
simp only [norm_eq_abs, abs_eq_self, le_max_iff, abs_nonneg, or_self]

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_64.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h_1 : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  let c := ‖a‖ ⊔ ‖b‖;
  ∀ (ω : Ω), X ω ∈ Set.Icc a b → |X ω| ≤ |c| := sorry

Tactic state before:
case h
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ |X ω| ≤ |c|

Tactic:
exact le_trans' (le_abs_self (max ‖a‖ ‖b‖)) (abs_le_max_abs_abs h.1 h.2)

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_65 (t : ℝ) : 0 ≤ |t| := sorry

Tactic state before:
case a0
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h✝ : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
ω : Ω
h : X ω ∈ Set.Icc a b
⊢ 0 ≤ |t|

Tactic:
exact abs_nonneg t

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_66.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (h_original_goal : AEStronglyMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ) :
  AEMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ := sorry

Tactic state before:
case hF'_meas
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ AEStronglyMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ

Tactic:
rw [aestronglyMeasurable_iff_aemeasurable]

Tactic state after:
[case hF'_meas
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_67.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (h_original_goal : AEMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ) :
  AEMeasurable (fun a => rexp (t * X a)) μ := sorry

Tactic state before:
case hF'_meas
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ AEMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ

Tactic:
apply AEMeasurable.mul

Tactic state after:
[case hF'_meas.hf
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun a => rexp (t * X a)) μ,
 case hF'_meas.hg
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun a => X a ^ 2) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_68.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (h_original_goal : AEMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ) : AEMeasurable (fun a => X a ^ 2) μ := sorry

Tactic state before:
case hF'_meas
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ AEMeasurable (fun ω => rexp (t * X ω) * X ω ^ 2) μ

Tactic:
apply AEMeasurable.mul

Tactic state after:
[case hF'_meas.hf
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun a => rexp (t * X a)) μ,
 case hF'_meas.hg
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun a => X a ^ 2) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_69 : Measurable rexp := sorry

Tactic state before:
case hF'_meas.hf
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ AEMeasurable (fun a => rexp (t * X a)) μ

Tactic:
apply Measurable.comp_aemeasurable' _ _

Tactic state after:
[Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ Measurable rexp,
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun x => t * X x) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_70.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b)
  (h_original_goal : AEMeasurable (fun a => rexp (t * X a)) μ) : AEMeasurable (fun x => t * X x) μ := sorry

Tactic state before:
case hF'_meas.hf
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ AEMeasurable (fun a => rexp (t * X a)) μ

Tactic:
apply Measurable.comp_aemeasurable' _ _

Tactic state after:
[Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ Measurable rexp,
 Ω : Type u_1
 m : MeasurableSpace Ω
 μ : Measure Ω
 inst✝ : IsFiniteMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 c : ℝ := ‖a‖ ⊔ ‖b‖
 e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
 e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
 ⊢ AEMeasurable (fun x => t * X x) μ]
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_71 : Measurable rexp := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ Measurable rexp

Tactic:
exact measurable_exp

Tactic state after:
import Mathlib
import FoML


open MeasureTheory Filter Finset Real

open scoped MeasureTheory ProbabilityTheory ENNReal NNReal

theorem extracted_formal_statement_72.{u_1} {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : Measure Ω}
  [inst : IsFiniteMeasure μ] (t a b : ℝ) {X : Ω → ℝ} (hX : AEMeasurable X μ) (h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) :
  AEMeasurable (fun x => t * X x) μ := sorry

Tactic state before:
Ω : Type u_1
m : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t a b : ℝ
X : Ω → ℝ
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
c : ℝ := ‖a‖ ⊔ ‖b‖
e : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω
e' : ℝ → Ω → ℝ := fun t ω => rexp (t * X ω) * X ω ^ 2
⊢ AEMeasurable (fun x => t * X x) μ

Tactic:
exact hX.const_mul t

Tactic state after: