zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_0.{u} {Ω : Type u} [inst : MeasurableSpace Ω] (μ : Measure Ω := by volume_tac)
  [inst_1 : IsProbabilityMeasure μ] {X : Ω → ℝ} (h0 : ∫ (x : Ω), X x ∂μ = 0)
  (h_original_goal :
    let f' := fun t => ∫ (x : Ω), X x ∂Measure.tilted μ fun ω => t * X ω;
    f' 0 = 0) :
  ∫ (x : Ω), X x ∂μ = 0 := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
μ : autoParam (Measure Ω) _auto✝
inst✝ : IsProbabilityMeasure μ
X : Ω → ℝ
h0 : ∫ (x : Ω), X x ∂μ = 0
⊢ let f' := fun t => ∫ (x : Ω), X x ∂Measure.tilted μ fun ω => t * X ω;
  f' 0 = 0

Tactic:
simp only [zero_mul, tilted_const', measure_univ, inv_one, one_smul]

Tactic state after:
[Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 μ : autoParam (Measure Ω) _auto✝
 inst✝ : IsProbabilityMeasure μ
 X : Ω → ℝ
 h0 : ∫ (x : Ω), X x ∂μ = 0
 ⊢ ∫ (x : Ω), X x ∂μ = 0]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_1.{u} {Ω : Type u} [inst : MeasurableSpace Ω] (μ : Measure Ω := by volume_tac)
  [inst_1 : IsProbabilityMeasure μ] {X : Ω → ℝ} (h0 : ∫ (x : Ω), X x ∂μ = 0) : ∫ (x : Ω), X x ∂μ = 0 := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
μ : autoParam (Measure Ω) _auto✝
inst✝ : IsProbabilityMeasure μ
X : Ω → ℝ
h0 : ∫ (x : Ω), X x ∂μ = 0
⊢ ∫ (x : Ω), X x ∂μ = 0

Tactic:
exact h0

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_2 : 0 ≤ 2⁻¹ := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
μ : autoParam (Measure Ω) _auto✝
inst✝ : IsProbabilityMeasure μ
t a b : ℝ
X : Ω → ℝ
ht : 0 ≤ t
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
h0 : ∫ (x : Ω), X x ∂μ = 0
w : ¬t = 0
f : ℝ → ℝ := fun t => cgf X μ t
hf : f 0 = 0
f' : ℝ → ℝ := fun t => ∫ (x : Ω), X x ∂Measure.tilted μ fun ω => t * X ω
hf' : f' 0 = 0
f'' : ℝ → ℝ := fun t => Var[X; Measure.tilted μ fun ω => t * X ω]
c : ℝ
left✝ : 0 < c ∧ c < t
cq' : f t = f'' c * t ^ 2 / 2
⊢ f'' c * t ^ 2 / 2 ≤ ((b - a) / 2) ^ 2 * t ^ 2 / 2

Tactic:
apply mul_le_mul_of_nonneg_right

Tactic state after:
[case h
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 μ : autoParam (Measure Ω) _auto✝
 inst✝ : IsProbabilityMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 ht : 0 ≤ t
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 h0 : ∫ (x : Ω), X x ∂μ = 0
 w : ¬t = 0
 f : ℝ → ℝ := fun t => cgf X μ t
 hf : f 0 = 0
 f' : ℝ → ℝ := fun t => ∫ (x : Ω), X x ∂Measure.tilted μ fun ω => t * X ω
 hf' : f' 0 = 0
 f'' : ℝ → ℝ := fun t => Var[X; Measure.tilted μ fun ω => t * X ω]
 c : ℝ
 left✝ : 0 < c ∧ c < t
 cq' : f t = f'' c * t ^ 2 / 2
 ⊢ f'' c * t ^ 2 ≤ ((b - a) / 2) ^ 2 * t ^ 2,
 case a0
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 μ : autoParam (Measure Ω) _auto✝
 inst✝ : IsProbabilityMeasure μ
 t a b : ℝ
 X : Ω → ℝ
 ht : 0 ≤ t
 hX : AEMeasurable X μ
 h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
 h0 : ∫ (x : Ω), X x ∂μ = 0
 w : ¬t = 0
 f : ℝ → ℝ := fun t => cgf X μ t
 hf : f 0 = 0
 f' : ℝ → ℝ := fun t => ∫ (x : Ω), X x ∂Measure.tilted μ fun ω => t * X ω
 hf' : f' 0 = 0
 f'' : ℝ → ℝ := fun t => Var[X; Measure.tilted μ fun ω => t * X ω]
 c : ℝ
 left✝ : 0 < c ∧ c < t
 cq' : f t = f'' c * t ^ 2 / 2
 ⊢ 0 ≤ 2⁻¹]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_3 : 0 ≤ 2⁻¹ := sorry

Tactic state before:
case a0
Ω : Type u
inst✝¹ : MeasurableSpace Ω
μ : autoParam (Measure Ω) _auto✝
inst✝ : IsProbabilityMeasure μ
t a b : ℝ
X : Ω → ℝ
ht : 0 ≤ t
hX : AEMeasurable X μ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
h0 : ∫ (x : Ω), X x ∂μ = 0
w : ¬t = 0
f : ℝ → ℝ := fun t => cgf X μ t
hf : f 0 = 0
f' : ℝ → ℝ := fun t => ∫ (x : Ω), X x ∂Measure.tilted μ fun ω => t * X ω
hf' : f' 0 = 0
f'' : ℝ → ℝ := fun t => Var[X; Measure.tilted μ fun ω => t * X ω]
c : ℝ
left✝ : 0 < c ∧ c < t
cq' : f t = f'' c * t ^ 2 / 2
⊢ 0 ≤ 2⁻¹

Tactic:
simp only [inv_nonneg, Nat.ofNat_nonneg]

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_4 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a)
  (h_original_goal : 4 * ε / ((b - a) ^ 2 * ↑m) > 0) : 0 < 4 * ε := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 4 * ε / ((b - a) ^ 2 * ↑m) > 0

Tactic:
apply div_pos

Tactic state after:
[case ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < 4 * ε,
 case hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < (b - a) ^ 2 * ↑m]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_5 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a)
  (h_original_goal : 4 * ε / ((b - a) ^ 2 * ↑m) > 0) : 0 < (b - a) ^ 2 * ↑m := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 4 * ε / ((b - a) ^ 2 * ↑m) > 0

Tactic:
apply div_pos

Tactic state after:
[case ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < 4 * ε,
 case hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < (b - a) ^ 2 * ↑m]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_6 : 0 < 4 := sorry

Tactic state before:
case ha
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < 4 * ε

Tactic:
apply mul_pos

Tactic state after:
[case ha.ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < 4,
 case ha.hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < ε]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_7 (ε : ℝ) (hε : ε > 0) (h_original_goal : 0 < 4 * ε) : 0 < ε := sorry

Tactic state before:
case ha
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < 4 * ε

Tactic:
apply mul_pos

Tactic state after:
[case ha.ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < 4,
 case ha.hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < ε]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_8 (ε : ℝ) (hε : ε > 0) : 0 < ε := sorry

Tactic state before:
case ha.hb
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < ε

Tactic:
exact hε

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_9 (a b : ℝ) (m : ℕ) (hm : m > 0) (hab : b > a)
  (h_original_goal : 0 < (b - a) ^ 2 * ↑m) : 0 < (b - a) ^ 2 := sorry

Tactic state before:
case hb
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < (b - a) ^ 2 * ↑m

Tactic:
apply mul_pos

Tactic state after:
[case hb.ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < (b - a) ^ 2,
 case hb.hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < ↑m]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_10 (a b : ℝ) (m : ℕ) (hm : m > 0) (hab : b > a)
  (h_original_goal : 0 < (b - a) ^ 2 * ↑m) : 0 < ↑m := sorry

Tactic state before:
case hb
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < (b - a) ^ 2 * ↑m

Tactic:
apply mul_pos

Tactic state after:
[case hb.ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < (b - a) ^ 2,
 case hb.hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 ⊢ 0 < ↑m]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_11 (a b : ℝ) (hab : b > a) : 0 < (b - a) ^ 2 := sorry

Tactic state before:
case hb.ha
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < (b - a) ^ 2

Tactic:
exact sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_12 (m : ℕ) (hm : m > 0) : 0 < ↑m := sorry

Tactic state before:
case hb.hb
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
⊢ 0 < ↑m

Tactic:
exact Nat.cast_pos.mpr hm

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_13 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8 := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
t : { t // t > 0 }
⊢ g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8

Tactic:
simp only [g]

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_14 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  let t_min :=
    ⟨4 * ε / ((b - a) ^ 2 * ↑m),
      div_pos
        (mul_pos
          (Mathlib.Meta.NormNum.isNat_lt_true (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero)
            (Mathlib.Meta.NormNum.isNat_ofNat ℝ (Eq.refl 4)) (Eq.refl false))
          hε)
        (mul_pos (sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))) (Nat.cast_pos.mpr hm))⟩;
  (∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) →
    ∀ (t : { t // t > 0 }),
      g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) →
        -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8 =
          ↑m * (b - a) ^ 2 / 8 * (↑t - 4 * ε / ((b - a) ^ 2 * ↑m)) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t : { t // t > 0 }
⊢ g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)

Tactic:
simp only [g, t_min]

Tactic state after:
[ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t : { t // t > 0 }
 ⊢ -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8 =
     ↑m * (b - a) ^ 2 / 8 * (↑t - 4 * ε / ((b - a) ^ 2 * ↑m)) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_15 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  let t_min :=
    ⟨4 * ε / ((b - a) ^ 2 * ↑m),
      div_pos
        (mul_pos
          (Mathlib.Meta.NormNum.isNat_lt_true (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero)
            (Mathlib.Meta.NormNum.isNat_ofNat ℝ (Eq.refl 4)) (Eq.refl false))
          hε)
        (mul_pos (sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))) (Nat.cast_pos.mpr hm))⟩;
  (∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) →
    (∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) →
      ∀ (t : { t // t > 0 }),
        g t ≥ g t_min →
          ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) ≥
            ↑m * (b - a) ^ 2 / 8 * (↑t_min - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
t : { t // t > 0 }
⊢ g t ≥ g t_min

Tactic:
rw [h_rewrite t, h_rewrite t_min]

Tactic state after:
[ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) ≥
     ↑m * (b - a) ^ 2 / 8 * (↑t_min - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_16 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  let t_min :=
    ⟨4 * ε / ((b - a) ^ 2 * ↑m),
      div_pos
        (mul_pos
          (Mathlib.Meta.NormNum.isNat_lt_true (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero)
            (Mathlib.Meta.NormNum.isNat_ofNat ℝ (Eq.refl 4)) (Eq.refl false))
          hε)
        (mul_pos (sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))) (Nat.cast_pos.mpr hm))⟩;
  (∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) →
    (∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) →
      ∀ (t : { t // t > 0 }),
        ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) ≥
            ↑m * (b - a) ^ 2 / 8 * (↑t_min - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) →
          ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) ≥
            ↑m * (b - a) ^ 2 / 8 * 0 ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
t : { t // t > 0 }
⊢ ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) ≥
    ↑m * (b - a) ^ 2 / 8 * (↑t_min - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)

Tactic:
simp only [sub_self, mul_zero]

Tactic state after:
[ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) ≥
     ↑m * (b - a) ^ 2 / 8 * 0 ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_17 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  let t_min :=
    ⟨4 * ε / ((b - a) ^ 2 * ↑m),
      div_pos
        (mul_pos
          (Mathlib.Meta.NormNum.isNat_lt_true (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero)
            (Mathlib.Meta.NormNum.isNat_ofNat ℝ (Eq.refl 4)) (Eq.refl false))
          hε)
        (mul_pos (sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))) (Nat.cast_pos.mpr hm))⟩;
  (∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) →
    (∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) →
      ∀ (t : { t // t > 0 }), ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 ≥ 0 → 0 ≤ ↑m * (b - a) ^ 2 / 8 := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
t : { t // t > 0 }
⊢ ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 ≥ 0

Tactic:
apply mul_nonneg

Tactic state after:
[case ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ 0 ≤ ↑m * (b - a) ^ 2 / 8,
 case hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ 0 ≤ (↑t - ↑t_min) ^ 2]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_18 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  let t_min :=
    ⟨4 * ε / ((b - a) ^ 2 * ↑m),
      div_pos
        (mul_pos
          (Mathlib.Meta.NormNum.isNat_lt_true (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero)
            (Mathlib.Meta.NormNum.isNat_ofNat ℝ (Eq.refl 4)) (Eq.refl false))
          hε)
        (mul_pos (sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))) (Nat.cast_pos.mpr hm))⟩;
  (∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) →
    (∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) →
      ∀ (t : { t // t > 0 }), ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 ≥ 0 → 0 ≤ (↑t - ↑t_min) ^ 2 := sorry

Tactic state before:
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
t : { t // t > 0 }
⊢ ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 ≥ 0

Tactic:
apply mul_nonneg

Tactic state after:
[case ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ 0 ≤ ↑m * (b - a) ^ 2 / 8,
 case hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ 0 ≤ (↑t - ↑t_min) ^ 2]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

theorem extracted_formal_statement_19 (ε a b : ℝ) (m : ℕ) (hm : m > 0) (hε : ε > 0) (hab : b > a) :
  let g := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8;
  let t_min :=
    ⟨4 * ε / ((b - a) ^ 2 * ↑m),
      div_pos
        (mul_pos
          (Mathlib.Meta.NormNum.isNat_lt_true (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero)
            (Mathlib.Meta.NormNum.isNat_ofNat ℝ (Eq.refl 4)) (Eq.refl false))
          hε)
        (mul_pos (sq_pos_of_ne_zero (ne_of_gt (sub_pos.mpr hab))) (Nat.cast_pos.mpr hm))⟩;
  (∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) →
    (∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) →
      0 ≤ ↑m * (b - a) ^ 2 / 8 → 0 ≤ ↑m * (b - a) ^ 2 := sorry

Tactic state before:
case ha
ε a b : ℝ
m : ℕ
hm : m > 0
hε : ε > 0
hab : b > a
g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
t : { t // t > 0 }
⊢ 0 ≤ ↑m * (b - a) ^ 2 / 8

Tactic:
apply div_nonneg

Tactic state after:
[case ha.ha
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ 0 ≤ ↑m * (b - a) ^ 2,
 case ha.hb
 ε a b : ℝ
 m : ℕ
 hm : m > 0
 hε : ε > 0
 hab : b > a
 g : { t // t > 0 } → ℝ := fun t => -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 t_min : { t // t > 0 } := ⟨4 * ε / ((b - a) ^ 2 * ↑m), ⋯⟩
 gt : ∀ (t : { t // t > 0 }), g t = -↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8
 h_rewrite : ∀ (t : { t // t > 0 }), g t = ↑m * (b - a) ^ 2 / 8 * (↑t - ↑t_min) ^ 2 - 2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
 t : { t // t > 0 }
 ⊢ 0 ≤ 8]