l3lab/ntp-mathlib huggingface dataset:
theorem exists_large_sphere (n d : ℕ) :
    ∃ k, ((d ^ n :) / (n * d ^ 2 :) : ℝ) ≤ (sphere n d k).card := by
  obtain ⟨k, -, hk⟩ := exists_large_sphere_aux n d
  refine' ⟨k, _⟩
  obtain rfl | hn := n.eq_zero_or_pos
  · simp
  obtain rfl | hd := d.eq_zero_or_pos
  · simp
  refine' (div_le_div_of_le_left _ _ _).trans hk
  · exact cast_nonneg _
  · exact cast_add_one_pos _
  simp only [← le_sub_iff_add_le', cast_mul, ← mul_sub, cast_pow, cast_sub hd, sub_sq, one_pow,
    cast_one, mul_one, sub_add, sub_sub_self]
  apply one_le_mul_of_one_le_of_one_le
  · rwa [one_le_cast]
  rw [_root_.le_sub_iff_add_le]
  norm_num
  

Proof state:
case intro.intro.inr.inr.refine'_3.hb
α : Type u_1
β : Type u_2
n✝ d✝ k✝ N : ℕ
x : Fin n✝ → ℕ
n d k : ℕ
hk : ↑(d ^ n) / (↑(n * (d - 1) ^ 2) + 1) ≤ ↑(card (sphere n d k))
hn : n > 0
hd : d > 0
⊢ 1 ≤ d

Next tactic:
exact one_le_cast.2 hd
theorem bound_aux (hd : d ≠ 0) (hn : 2 ≤ n) :
    (d ^ (n - 2 :) / n : ℝ) ≤ rothNumberNat ((2 * d - 1) ^ n) := by
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n ≤ ↑(rothNumberNat ((2 * d - 1) ^ n))

Next tactic:
convert bound_aux' n d using 1
theorem bound_aux (hd : d ≠ 0) (hn : 2 ≤ n) :
    (d ^ (n - 2 :) / n : ℝ) ≤ rothNumberNat ((2 * d - 1) ^ n) := by
  convert bound_aux' n d using 1
  

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n = ↑(d ^ n) / ↑(n * d ^ 2)

Next tactic:
rw [cast_mul, cast_pow, mul_comm, ← div_div, pow_sub₀ _ _ hn, ← div_eq_mul_inv, cast_pow]
theorem bound_aux (hd : d ≠ 0) (hn : 2 ≤ n) :
    (d ^ (n - 2 :) / n : ℝ) ≤ rothNumberNat ((2 * d - 1) ^ n) := by
  convert bound_aux' n d using 1
  rw [cast_mul, cast_pow, mul_comm, ← div_div, pow_sub₀ _ _ hn, ← div_eq_mul_inv, cast_pow]
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ≠ 0

Next tactic:
rwa [cast_ne_zero]
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ log 2 * 2 ≤ Real.sqrt (log 8)

Next tactic:
have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 8 = 2 ^ ↑3

Next tactic:
rw [rpow_nat_cast]
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 8 = 2 ^ 3

Next tactic:
norm_num
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ log 2 * 2 ≤ Real.sqrt (log 8)

Next tactic:
rw [this, log_rpow zero_lt_two (3 : ℕ)]
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ log 2 * 2 ≤ Real.sqrt (↑3 * log 2)

Next tactic:
apply le_sqrt_of_sq_le
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ (log 2 * 2) ^ 2 ≤ ↑3 * log 2

Next tactic:
rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
  

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ log 2 * 2 ^ 2 * log 2 ≤ ↑3 * log 2

Next tactic:
refine' mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
  refine' mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ log 2 * 2 ^ 2 ≤ ↑3

Next tactic:
rw [← le_div_iff]
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
  refine' mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  rw [← le_div_iff]
  

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ log 2 ≤ ↑3 / 2 ^ 2
case h α : Type u_1 β : Type u_2 n d k N : ℕ x : Fin n → ℕ this : 8 = 2 ^ ↑3 ⊢ 0 < 2 ^ 2

Next tactic:
apply log_two_lt_d9.le.trans
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
  refine' mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  rw [← le_div_iff]
  apply log_two_lt_d9.le.trans
  

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ 0.6931471808 ≤ ↑3 / 2 ^ 2
case h α : Type u_1 β : Type u_2 n d k N : ℕ x : Fin n → ℕ this : 8 = 2 ^ ↑3 ⊢ 0 < 2 ^ 2

Next tactic:
all_goals norm_num1
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
  refine' mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  rw [← le_div_iff]
  apply log_two_lt_d9.le.trans
  all_goals 

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ 0.6931471808 ≤ ↑3 / 2 ^ 2

Next tactic:
norm_num1
theorem log_two_mul_two_le_sqrt_log_eight : log 2 * 2 ≤ sqrt (log 8) := by
  have : (8 : ℝ) = 2 ^ ((3 : ℕ) : ℝ) := by rw [rpow_nat_cast]; norm_num
  rw [this, log_rpow zero_lt_two (3 : ℕ)]
  apply le_sqrt_of_sq_le
  rw [mul_pow, sq (log 2), mul_assoc, mul_comm]
  refine' mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  rw [← le_div_iff]
  apply log_two_lt_d9.le.trans
  all_goals 

Proof state:
case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 8 = 2 ^ ↑3
⊢ 0 < 2 ^ 2

Next tactic:
norm_num1
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 2 / (1 - 2 / rexp 1) ≤ 8

Next tactic:
rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 8 * 2 ≤ (8 - 2) * rexp 1

Next tactic:
have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 16 < 6 * 2.7182818283

Next tactic:
norm_num
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
    

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
this : 16 < 6 * 2.7182818283
⊢ 8 * 2 ≤ (8 - 2) * rexp 1

Next tactic:
linarith [exp_one_gt_d9]
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
    linarith [exp_one_gt_d9]
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < 1 - 2 / rexp 1

Next tactic:
rw [sub_pos, div_lt_one]
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
    linarith [exp_one_gt_d9]
  rw [sub_pos, div_lt_one] <;> 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 2 < rexp 1

Next tactic:
exact exp_one_gt_d9.trans' (by norm_num)
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
    linarith [exp_one_gt_d9]
  rw [sub_pos, div_lt_one] <;> exact exp_one_gt_d9.trans' (by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 2 < 2.7182818283

Next tactic:
norm_num
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
    linarith [exp_one_gt_d9]
  rw [sub_pos, div_lt_one] <;> 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < rexp 1

Next tactic:
exact exp_one_gt_d9.trans' (by norm_num)
theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) ≤ 8 := by
  rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
  · have : 16 < 6 * (2.7182818283 : ℝ) := by norm_num
    linarith [exp_one_gt_d9]
  rw [sub_pos, div_lt_one] <;> exact exp_one_gt_d9.trans' (by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < 2.7182818283

Next tactic:
norm_num
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
⊢ log (2 / (1 - 2 / rexp 1)) * (69 / 50) ≤ Real.sqrt (log ↑N)

Next tactic:
have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
⊢ ↑12 * log 2 ≤ log ↑N

Next tactic:
rw [← log_rpow zero_lt_two, rpow_nat_cast]
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
⊢ log (2 ^ 12) ≤ log ↑N

Next tactic:
exact log_le_log (by positivity) (mod_cast hN)
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
⊢ 0 < 2 ^ 12

Next tactic:
positivity
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ log (2 / (1 - 2 / rexp 1)) * (69 / 50) ≤ Real.sqrt (log ↑N)

Next tactic:
refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ 0 ≤ 69 / 50

Next tactic:
norm_num1
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · 

Proof state:
case refine_1
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ 0 < 2 / (1 - 2 / rexp 1)

Next tactic:
refine' div_pos zero_lt_two _
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    

Proof state:
case refine_1
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ 0 < 1 - 2 / rexp 1

Next tactic:
rw [sub_pos, div_lt_one (exp_pos _)]
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    

Proof state:
case refine_1
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ 2 < rexp 1

Next tactic:
exact exp_one_gt_d9.trans_le' (by norm_num1)
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ 2 ≤ 2.7182818283

Next tactic:
norm_num1
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  

Proof state:
case refine_2
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ log 8 * (69 / 50) ≤ Real.sqrt (log ↑N)

Next tactic:
have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ log 8 = ↑3 * log 2

Next tactic:
rw [← log_rpow zero_lt_two, rpow_nat_cast]
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
⊢ log 8 = log (2 ^ 3)

Next tactic:
norm_num
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  

Proof state:
case refine_2
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ log 8 * (69 / 50) ≤ Real.sqrt (log ↑N)

Next tactic:
rw [l8]
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  rw [l8]
  

Proof state:
case refine_2
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ ↑3 * log 2 * (69 / 50) ≤ Real.sqrt (log ↑N)

Next tactic:
apply le_sqrt_of_sq_le (le_trans _ this)
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  rw [l8]
  apply le_sqrt_of_sq_le (le_trans _ this)
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ (↑3 * log 2 * (69 / 50)) ^ 2 ≤ ↑12 * log 2

Next tactic:
rw [mul_right_comm, mul_pow, sq (log 2), ← mul_assoc]
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  rw [l8]
  apply le_sqrt_of_sq_le (le_trans _ this)
  rw [mul_right_comm, mul_pow, sq (log 2), ← mul_assoc]
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ (↑3 * (69 / 50)) ^ 2 * log 2 * log 2 ≤ ↑12 * log 2

Next tactic:
apply mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  rw [l8]
  apply le_sqrt_of_sq_le (le_trans _ this)
  rw [mul_right_comm, mul_pow, sq (log 2), ← mul_assoc]
  apply mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ (↑3 * (69 / 50)) ^ 2 * log 2 ≤ ↑12

Next tactic:
rw [← le_div_iff']
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  rw [l8]
  apply le_sqrt_of_sq_le (le_trans _ this)
  rw [mul_right_comm, mul_pow, sq (log 2), ← mul_assoc]
  apply mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  rw [← le_div_iff']
  · 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ log 2 ≤ ↑12 / (↑3 * (69 / 50)) ^ 2

Next tactic:
exact log_two_lt_d9.le.trans (by norm_num1)
theorem le_sqrt_log (hN : 4096 ≤ N) : log (2 / (1 - 2 / exp 1)) * (69 / 50) ≤ sqrt (log ↑N) := by
  have : (12 : ℕ) * log 2 ≤ log N := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    exact log_le_log (by positivity) (mod_cast hN)
  refine (mul_le_mul_of_nonneg_right (log_le_log ?_ two_div_one_sub_two_div_e_le_eight) <| by
    norm_num1).trans ?_
  · refine' div_pos zero_lt_two _
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact exp_one_gt_d9.trans_le' (by norm_num1)
  have l8 : log 8 = (3 : ℕ) * log 2 := by
    rw [← log_rpow zero_lt_two, rpow_nat_cast]
    norm_num
  rw [l8]
  apply le_sqrt_of_sq_le (le_trans _ this)
  rw [mul_right_comm, mul_pow, sq (log 2), ← mul_assoc]
  apply mul_le_mul_of_nonneg_right _ (log_nonneg one_le_two)
  rw [← le_div_iff']
  · exact log_two_lt_d9.le.trans (by 

Proof state:
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 4096 ≤ N
this : ↑12 * log 2 ≤ log ↑N
l8 : log 8 = ↑3 * log 2
⊢ 0.6931471808 ≤ ↑12 / (↑3 * (69 / 50)) ^ 2

Next tactic:
norm_num1