Theorem: Real.Gamma_three_div_two_lt_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

tactic: have A : (0 : ℝ) < 3 / 2 := by norm_num
state_before: ⊢ Gamma (3 / 2) < 1
state_after: A : 0 < 3 / 2
⊢ Gamma (3 / 2) < 1

tactic: have :=
  BohrMollerup.f_add_nat_le convexOn_log_Gamma (fun {y} hy => ?_) two_ne_zero one_half_pos
    (by norm_num : 1 / 2 ≤ (1 : ℝ))
state_before: A : 0 < 3 / 2
⊢ Gamma (3 / 2) < 1
state_after: case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1

case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y

tactic: swap
state_before: case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1

case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y
state_after: case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y

case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1

tactic: rw [Function.comp_apply, Function.comp_apply, Nat.cast_two, Gamma_two, log_one, zero_add,
  (by norm_num : (2 : ℝ) + 1 / 2 = 3 / 2 + 1), Gamma_add_one A.ne',
  log_mul A.ne' (Gamma_pos_of_pos A).ne', ← le_sub_iff_add_le',
  log_le_iff_le_exp (Gamma_pos_of_pos A)] at this
state_before: case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ Gamma (3 / 2) < 1

tactic: refine this.trans_lt (exp_lt_one_iff.mpr ?_)
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ Gamma (3 / 2) < 1
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ 1 / 2 * log 2 - log (3 / 2) < 0

tactic: rw [mul_comm, ← mul_div_assoc, div_sub' _ _ (2 : ℝ) two_ne_zero]
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ 1 / 2 * log 2 - log (3 / 2) < 0
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ (log 2 * 1 - 2 * log (3 / 2)) / 2 < 0

tactic: refine div_neg_of_neg_of_pos ?_ two_pos
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ (log 2 * 1 - 2 * log (3 / 2)) / 2 < 0
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ log 2 * 1 - 2 * log (3 / 2) < 0

tactic: rw [sub_neg, mul_one, ← Nat.cast_two, ← log_pow, ← exp_lt_exp, Nat.cast_two, exp_log two_pos,
    exp_log] <;>
  norm_num
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ log 2 * 1 - 2 * log (3 / 2) < 0
state_after: no goals

tactic: norm_num
state_before: ⊢ 0 < 3 / 2
state_after: no goals

tactic: norm_num
state_before: A : 0 < 3 / 2
⊢ 1 / 2 ≤ 1
state_after: no goals

tactic: rw [Function.comp_apply, Gamma_add_one hy.ne', log_mul hy.ne' (Gamma_pos_of_pos hy).ne',
  add_comm, Function.comp_apply]
state_before: case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y
state_after: no goals

tactic: norm_num
state_before: A : 0 < 3 / 2
this : log (Gamma (2 + 1 / 2)) ≤ 1 / 2 * log 2
⊢ 2 + 1 / 2 = 3 / 2 + 1
state_after: no goals