l3lab/ntp-mathlib huggingface dataset:
theorem log_div_self_antitoneOn : AntitoneOn (fun x : ℝ => log x / x) { x | exp 1 ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y hey hxy
  have x_pos : 0 < x := (exp_pos 1).trans_le hex
  have y_pos : 0 < y := (exp_pos 1).trans_le hey
  have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
  have hyx : 0 ≤ y / x - 1 := by 

Proof state:
x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ 0 ≤ y / x - 1

Next tactic:
rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
theorem log_div_self_antitoneOn : AntitoneOn (fun x : ℝ => log x / x) { x | exp 1 ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y hey hxy
  have x_pos : 0 < x := (exp_pos 1).trans_le hex
  have y_pos : 0 < y := (exp_pos 1).trans_le hey
  have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
  have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
  

Proof state:
x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y / y ≤ log x / x

Next tactic:
rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
theorem log_div_self_antitoneOn : AntitoneOn (fun x : ℝ => log x / x) { x | exp 1 ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y hey hxy
  have x_pos : 0 < x := (exp_pos 1).trans_le hex
  have y_pos : 0 < y := (exp_pos 1).trans_le hey
  have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
  have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
  rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
  

Proof state:
x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x ≤ log x / x * y - log x

Next tactic:
calc
    log y - log x = log (y / x) := by rw [log_div y_pos.ne' x_pos.ne']
    _ ≤ y / x - 1 := (log_le_sub_one_of_pos (div_pos y_pos x_pos))
    _ ≤ log x * (y / x - 1) := (le_mul_of_one_le_left hyx hlogx)
    _ = log x / x * y - log x := by ring
theorem log_div_self_antitoneOn : AntitoneOn (fun x : ℝ => log x / x) { x | exp 1 ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y hey hxy
  have x_pos : 0 < x := (exp_pos 1).trans_le hex
  have y_pos : 0 < y := (exp_pos 1).trans_le hey
  have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
  have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
  rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
  calc
    log y - log x = log (y / x) := by 

Proof state:
x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x = log (y / x)

Next tactic:
rw [log_div y_pos.ne' x_pos.ne']
theorem log_div_self_antitoneOn : AntitoneOn (fun x : ℝ => log x / x) { x | exp 1 ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y hey hxy
  have x_pos : 0 < x := (exp_pos 1).trans_le hex
  have y_pos : 0 < y := (exp_pos 1).trans_le hey
  have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
  have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
  rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
  calc
    log y - log x = log (y / x) := by rw [log_div y_pos.ne' x_pos.ne']
    _ ≤ y / x - 1 := (log_le_sub_one_of_pos (div_pos y_pos x_pos))
    _ ≤ log x * (y / x - 1) := (le_mul_of_one_le_left hyx hlogx)
    _ = log x / x * y - log x := by 

Proof state:
x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log x * (y / x - 1) = log x / x * y - log x

Next tactic:
ring
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  

Proof state:
x y a : ℝ
ha : 0 < a
⊢ AntitoneOn (fun x => log x / x ^ a) {x | rexp (1 / a) ≤ x}

Next tactic:
simp only [AntitoneOn, mem_setOf_eq]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  

Proof state:
x y a : ℝ
ha : 0 < a
⊢ ∀ ⦃a_1 : ℝ⦄, rexp (1 / a) ≤ a_1 → ∀ ⦃b : ℝ⦄, rexp (1 / a) ≤ b → a_1 ≤ b → log b / b ^ a ≤ log a_1 / a_1 ^ a

Next tactic:
intro x hex y _ hxy
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
⊢ log y / y ^ a ≤ log x / x ^ a

Next tactic:
have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log y / y ^ a ≤ log x / x ^ a

Next tactic:
have y_pos : 0 < y := by linarith
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by 

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ 0 < y

Next tactic:
linarith
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log y / y ^ a ≤ log x / x ^ a

Next tactic:
have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
⊢ log y / y ^ a ≤ log x / x ^ a

Next tactic:
have y_nonneg : 0 ≤ y := by linarith
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by 

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
⊢ 0 ≤ y

Next tactic:
linarith
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log y / y ^ a ≤ log x / x ^ a

Next tactic:
nth_rw 1 [← rpow_one y]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log (y ^ 1) / y ^ a ≤ log x / x ^ a

Next tactic:
nth_rw 1 [← rpow_one x]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log (y ^ 1) / y ^ a ≤ log (x ^ 1) / x ^ a

Next tactic:
rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · 

Proof state:
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ log (y ^ a) / y ^ a ≤ log (x ^ a) / x ^ a

Next tactic:
refine' log_div_self_antitoneOn _ _ _
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · 

Proof state:
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ x ^ a ∈ {x | rexp 1 ≤ x}

Next tactic:
simp only [Set.mem_setOf_eq]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      

Proof state:
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ rexp 1 ≤ x ^ a

Next tactic:
convert rpow_le_rpow _ hex (le_of_lt ha) using 1
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      

Proof state:
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ rexp 1 = rexp (1 / a) ^ a
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ rexp (1 / a)

Next tactic:
rw [← exp_mul]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      

Proof state:
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ rexp 1 = rexp (1 / a * a)
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ rexp (1 / a)

Next tactic:
simp only [Real.exp_eq_exp]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      simp only [Real.exp_eq_exp]
      

Proof state:
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 1 = 1 / a * a
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ rexp (1 / a)

Next tactic:
field_simp [(ne_of_lt ha).symm]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      simp only [Real.exp_eq_exp]
      field_simp [(ne_of_lt ha).symm]
      

Proof state:
case refine'_1
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ rexp (1 / a)

Next tactic:
exact le_of_lt (exp_pos (1 / a))
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      simp only [Real.exp_eq_exp]
      field_simp [(ne_of_lt ha).symm]
      exact le_of_lt (exp_pos (1 / a))
    · 

Proof state:
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ y ^ a ∈ {x | rexp 1 ≤ x}

Next tactic:
simp only [Set.mem_setOf_eq]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      simp only [Real.exp_eq_exp]
      field_simp [(ne_of_lt ha).symm]
      exact le_of_lt (exp_pos (1 / a))
    · simp only [Set.mem_setOf_eq]
      

Proof state:
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ rexp 1 ≤ y ^ a

Next tactic:
convert rpow_le_rpow _ (_root_.trans hex hxy) (le_of_lt ha) using 1
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      simp only [Real.exp_eq_exp]
      field_simp [(ne_of_lt ha).symm]
      exact le_of_lt (exp_pos (1 / a))
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ (_root_.trans hex hxy) (le_of_lt ha) using 1
      

Proof state:
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ rexp 1 = rexp (1 / a) ^ a
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ rexp (1 / a)

Next tactic:
rw [← exp_mul]
theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } := by
  simp only [AntitoneOn, mem_setOf_eq]
  intro x hex y _ hxy
  have x_pos : 0 < x := lt_of_lt_of_le (exp_pos (1 / a)) hex
  have y_pos : 0 < y := by linarith
  have x_nonneg : 0 ≤ x := le_trans (le_of_lt (exp_pos (1 / a))) hex
  have y_nonneg : 0 ≤ y := by linarith
  nth_rw 1 [← rpow_one y]
  nth_rw 1 [← rpow_one x]
  rw [← div_self (ne_of_lt ha).symm, div_eq_mul_one_div a a, rpow_mul y_nonneg, rpow_mul x_nonneg,
    log_rpow (rpow_pos_of_pos y_pos a), log_rpow (rpow_pos_of_pos x_pos a), mul_div_assoc,
    mul_div_assoc, mul_le_mul_left (one_div_pos.mpr ha)]
  · refine' log_div_self_antitoneOn _ _ _
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ hex (le_of_lt ha) using 1
      rw [← exp_mul]
      simp only [Real.exp_eq_exp]
      field_simp [(ne_of_lt ha).symm]
      exact le_of_lt (exp_pos (1 / a))
    · simp only [Set.mem_setOf_eq]
      convert rpow_le_rpow _ (_root_.trans hex hxy) (le_of_lt ha) using 1
      rw [← exp_mul]
      

Proof state:
case h.e'_3
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ rexp 1 = rexp (1 / a * a)
case refine'_2
x✝¹ y✝ a : ℝ
ha : 0 < a
x : ℝ
hex : rexp (1 / a) ≤ x
y : ℝ
x✝ : rexp (1 / a) ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
x_nonneg : 0 ≤ x
y_nonneg : 0 ≤ y
⊢ 0 ≤ rexp (1 / a)

Next tactic:
simp only [Real.exp_eq_exp]