theorem extracted_formal_statement_0 (ε 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) →
        (∀ (t : { t // t > 0 }), rexp (g t) ≥ rexp (g t_min)) →
          g t_min = -2 * ε ^ 2 / ((b - a) ^ 2 * ↑m) →
            rexp (g t_min) = rexp (-2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) →
              ⨅ t, rexp (-↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) = rexp (-2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)) := sorry

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)
h_inf : ∀ (t : { t // t > 0 }), g t ≥ g t_min
h_exp : ∀ (t : { t // t > 0 }), rexp (g t) ≥ rexp (g t_min)
h_g_tmin : g t_min = -2 * ε ^ 2 / ((b - a) ^ 2 * ↑m)
h_exp_tmin : rexp (g t_min) = rexp (-2 * ε ^ 2 / ((b - a) ^ 2 * ↑m))
⊢ ⨅ t, rexp (-↑t * ε + ↑t ^ 2 * ↑m * (b - a) ^ 2 / 8) = rexp (-2 * ε ^ 2 / ((b - a) ^ 2 * ↑m))

Tactic: rw [← h_exp_tmin]
    have h_inf_rewrite :
  ⨅ t : { t : ℝ // t > 0 }, rexp (-t * ε + t ^ 2 * ↑m * (b - a) ^ 2 / 8) = ⨅ t : { t : ℝ // 0 < t }, rexp (g t) := by
  congr
    rw [h_inf_rewrite]
    have inf_eq_at_min (g : { t : ℝ // t > 0 } → ℝ) (t_min : { t : ℝ // t > 0 })
  (h_exp : ∀ t : { t : ℝ // t > 0 }, rexp (g t) ≥ rexp (g t_min)) :
  ⨅ t : { t : ℝ // t > 0 }, rexp (g t) = rexp (g t_min) :=
  by
  apply le_antisymm
  · have bdd : BddBelow (Set.range (fun t => rexp (g t))) :=
      by
      use rexp (g t_min)
      intro y hy
      rcases hy with ⟨t, rfl⟩
      exact h_exp t
    apply ciInf_le bdd
  · have positive_reals_nonempty : Nonempty { t : ℝ // t > 0 } := by exact ⟨⟨1, by norm_num⟩⟩
    apply le_ciInf
    intro t
    exact (h_exp t)
    exact inf_eq_at_min g t_min h_exp

State after:

Relevant lemmas:
error