l3lab/ntp-mathlib huggingface dataset:
theorem div_rpow (hx : 0 ≤ x) (hy : 0 ≤ y) (z : ℝ) : (x / y) ^ z = x ^ z / y ^ z := by
  

Proof state:
x y z✝ : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
z : ℝ
⊢ (x / y) ^ z = x ^ z / y ^ z

Next tactic:
simp only [div_eq_mul_inv, mul_rpow hx (inv_nonneg.2 hy), inv_rpow hy]
theorem log_rpow {x : ℝ} (hx : 0 < x) (y : ℝ) : log (x ^ y) = y * log x := by
  

Proof state:
x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ log (x ^ y) = y * log x

Next tactic:
apply exp_injective
theorem log_rpow {x : ℝ} (hx : 0 < x) (y : ℝ) : log (x ^ y) = y * log x := by
  apply exp_injective
  

Proof state:
case a
x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ rexp (log (x ^ y)) = rexp (y * log x)

Next tactic:
rw [exp_log (rpow_pos_of_pos hx y), ← exp_log hx, mul_comm, rpow_def_of_pos (exp_pos (log x)) y]
theorem mul_log_eq_log_iff {x y z : ℝ} (hx : 0 < x) (hz : 0 < z) :
    y * log x = log z ↔ x ^ y = z :=
  ⟨fun h ↦ log_injOn_pos (rpow_pos_of_pos hx _) hz <| log_rpow hx _ |>.trans h,
  by 

Proof state:
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
hx : 0 < x
hz : 0 < z
⊢ x ^ y = z → y * log x = log z

Next tactic:
rintro rfl
theorem mul_log_eq_log_iff {x y z : ℝ} (hx : 0 < x) (hz : 0 < z) :
    y * log x = log z ↔ x ^ y = z :=
  ⟨fun h ↦ log_injOn_pos (rpow_pos_of_pos hx _) hz <| log_rpow hx _ |>.trans h,
  by rintro rfl; 

Proof state:
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hx : 0 < x
hz : 0 < x ^ y
⊢ y * log x = log (x ^ y)

Next tactic:
rw [log_rpow hx]
@[simp] lemma rpow_rpow_inv (hx : 0 ≤ x) (hy : y ≠ 0) : (x ^ y) ^ y⁻¹ = x := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : y ≠ 0
⊢ (x ^ y) ^ y⁻¹ = x

Next tactic:
rw [← rpow_mul hx, mul_inv_cancel hy, rpow_one]
@[simp] lemma rpow_inv_rpow (hx : 0 ≤ x) (hy : y ≠ 0) : (x ^ y⁻¹) ^ y = x := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : y ≠ 0
⊢ (x ^ y⁻¹) ^ y = x

Next tactic:
rw [← rpow_mul hx, inv_mul_cancel hy, rpow_one]
theorem pow_rpow_inv_natCast (hx : 0 ≤ x) (hn : n ≠ 0) : (x ^ n) ^ (n⁻¹ : ℝ) = x := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
⊢ (x ^ n) ^ (↑n)⁻¹ = x

Next tactic:
have hn0 : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.2 hn
theorem pow_rpow_inv_natCast (hx : 0 ≤ x) (hn : n ≠ 0) : (x ^ n) ^ (n⁻¹ : ℝ) = x := by
  have hn0 : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.2 hn
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (x ^ n) ^ (↑n)⁻¹ = x

Next tactic:
rw [← rpow_nat_cast, ← rpow_mul hx, mul_inv_cancel hn0, rpow_one]
theorem rpow_inv_natCast_pow (hx : 0 ≤ x) (hn : n ≠ 0) : (x ^ (n⁻¹ : ℝ)) ^ n = x := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
⊢ (x ^ (↑n)⁻¹) ^ n = x

Next tactic:
have hn0 : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.2 hn
theorem rpow_inv_natCast_pow (hx : 0 ≤ x) (hn : n ≠ 0) : (x ^ (n⁻¹ : ℝ)) ^ n = x := by
  have hn0 : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.2 hn
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (x ^ (↑n)⁻¹) ^ n = x

Next tactic:
rw [← rpow_nat_cast, ← rpow_mul hx, inv_mul_cancel hn0, rpow_one]
lemma rpow_natCast_mul (hx : 0 ≤ x) (n : ℕ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z := by
  

Proof state:
x y z✝ : ℝ
n✝ : ℕ
hx : 0 ≤ x
n : ℕ
z : ℝ
⊢ x ^ (↑n * z) = (x ^ n) ^ z

Next tactic:
rw [rpow_mul hx, rpow_nat_cast]
lemma rpow_mul_natCast (hx : 0 ≤ x) (y : ℝ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n := by
  

Proof state:
x y✝ z : ℝ
n✝ : ℕ
hx : 0 ≤ x
y : ℝ
n : ℕ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n

Next tactic:
rw [rpow_mul hx, rpow_nat_cast]
lemma rpow_intCast_mul (hx : 0 ≤ x) (n : ℤ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z := by
  

Proof state:
x y z✝ : ℝ
n✝ : ℕ
hx : 0 ≤ x
n : ℤ
z : ℝ
⊢ x ^ (↑n * z) = (x ^ n) ^ z

Next tactic:
rw [rpow_mul hx, rpow_int_cast]
lemma rpow_mul_intCast (hx : 0 ≤ x) (y : ℝ) (n : ℤ) : x ^ (y * n) = (x ^ y) ^ n := by
  

Proof state:
x y✝ z : ℝ
n✝ : ℕ
hx : 0 ≤ x
y : ℝ
n : ℤ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n

Next tactic:
rw [rpow_mul hx, rpow_int_cast]
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z

Next tactic:
rw [le_iff_eq_or_lt] at hx
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  rw [le_iff_eq_or_lt] at hx; 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 = x ∨ 0 < x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z

Next tactic:
cases' hx with hx hx
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  rw [le_iff_eq_or_lt] at hx; cases' hx with hx hx
  · 

Proof state:
case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ x ^ z < y ^ z

Next tactic:
rw [← hx, zero_rpow (ne_of_gt hz)]
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  rw [le_iff_eq_or_lt] at hx; cases' hx with hx hx
  · rw [← hx, zero_rpow (ne_of_gt hz)]
    

Proof state:
case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ 0 < y ^ z

Next tactic:
exact rpow_pos_of_pos (by rwa [← hx] at hxy) _
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  rw [le_iff_eq_or_lt] at hx; cases' hx with hx hx
  · rw [← hx, zero_rpow (ne_of_gt hz)]
    exact rpow_pos_of_pos (by 

Proof state:
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ 0 < y

Next tactic:
rwa [← hx] at hxy
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  rw [le_iff_eq_or_lt] at hx; cases' hx with hx hx
  · rw [← hx, zero_rpow (ne_of_gt hz)]
    exact rpow_pos_of_pos (by rwa [← hx] at hxy) _
  · 

Proof state:
case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ x ^ z < y ^ z

Next tactic:
rw [rpow_def_of_pos hx, rpow_def_of_pos (lt_trans hx hxy), exp_lt_exp]
@[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z := by
  rw [le_iff_eq_or_lt] at hx; cases' hx with hx hx
  · rw [← hx, zero_rpow (ne_of_gt hz)]
    exact rpow_pos_of_pos (by rwa [← hx] at hxy) _
  · rw [rpow_def_of_pos hx, rpow_def_of_pos (lt_trans hx hxy), exp_lt_exp]
    

Proof state:
case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ log x * z < log y * z

Next tactic:
exact mul_lt_mul_of_pos_right (log_lt_log hx hxy) hz
@[gcongr]
theorem rpow_le_rpow {x y z : ℝ} (h : 0 ≤ x) (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z := by
  

Proof state:
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
⊢ x ^ z ≤ y ^ z

Next tactic:
rcases eq_or_lt_of_le h₁ with (rfl | h₁')
@[gcongr]
theorem rpow_le_rpow {x y z : ℝ} (h : 0 ≤ x) (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z := by
  rcases eq_or_lt_of_le h₁ with (rfl | h₁'); · 

Proof state:
case inl
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
h : 0 ≤ x
h₂ : 0 ≤ z
h₁ : x ≤ x
⊢ x ^ z ≤ x ^ z

Next tactic:
rfl
@[gcongr]
theorem rpow_le_rpow {x y z : ℝ} (h : 0 ≤ x) (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z := by
  rcases eq_or_lt_of_le h₁ with (rfl | h₁'); · rfl
  

Proof state:
case inr
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
h₁' : x < y
⊢ x ^ z ≤ y ^ z

Next tactic:
rcases eq_or_lt_of_le h₂ with (rfl | h₂')
@[gcongr]
theorem rpow_le_rpow {x y z : ℝ} (h : 0 ≤ x) (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z := by
  rcases eq_or_lt_of_le h₁ with (rfl | h₁'); · rfl
  rcases eq_or_lt_of_le h₂ with (rfl | h₂'); · 

Proof state:
case inr.inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₁' : x < y
h₂ : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0

Next tactic:
simp
@[gcongr]
theorem rpow_le_rpow {x y z : ℝ} (h : 0 ≤ x) (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z := by
  rcases eq_or_lt_of_le h₁ with (rfl | h₁'); · rfl
  rcases eq_or_lt_of_le h₂ with (rfl | h₂'); · simp
  

Proof state:
case inr.inr
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
h₁' : x < y
h₂' : 0 < z
⊢ x ^ z ≤ y ^ z

Next tactic:
exact le_of_lt (rpow_lt_rpow h h₁' h₂')
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
⊢ y ^ z < x ^ z

Next tactic:
have := hx.trans hxy
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ y ^ z < x ^ z

Next tactic:
rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ x ^ (-z) < y ^ (-z)
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ y
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ x
case ha
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 < x ^ z
case hb x y z : ℝ n : ℕ hx : 0 < x hxy : x < y hz : z < 0 this : 0 < y ⊢ 0 < y ^ z

Next tactic:
refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ x
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ y
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ x
case ha
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 < x ^ z
case hb x y z : ℝ n : ℕ hx : 0 < x hxy : x < y hz : z < 0 this : 0 < y ⊢ 0 < y ^ z

Next tactic:
all_goals positivity
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
  all_goals 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ x

Next tactic:
positivity
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
  all_goals 

Proof state:
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ y

Next tactic:
positivity
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
  all_goals 

Proof state:
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 ≤ x

Next tactic:
positivity
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
  all_goals 

Proof state:
case ha
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 < x ^ z

Next tactic:
positivity
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z := by
  have := hx.trans hxy
  rw [← inv_lt_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_lt_rpow ?_ hxy (neg_pos.2 hz)
  all_goals 

Proof state:
case hb
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x < y
hz : z < 0
this : 0 < y
⊢ 0 < y ^ z

Next tactic:
positivity
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
⊢ y ^ z ≤ x ^ z

Next tactic:
have := hx.trans_le hxy
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ y ^ z ≤ x ^ z

Next tactic:
rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ x ^ (-z) ≤ y ^ (-z)
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ y
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ x
case ha
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 < x ^ z
case hb x y z : ℝ n : ℕ hx : 0 < x hxy : x ≤ y hz : z ≤ 0 this : 0 < y ⊢ 0 < y ^ z

Next tactic:
refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ x
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ y
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ x
case ha
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 < x ^ z
case hb x y z : ℝ n : ℕ hx : 0 < x hxy : x ≤ y hz : z ≤ 0 this : 0 < y ⊢ 0 < y ^ z

Next tactic:
all_goals positivity
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
  all_goals 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ x

Next tactic:
positivity
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
  all_goals 

Proof state:
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ y

Next tactic:
positivity
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
  all_goals 

Proof state:
case hx
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 ≤ x

Next tactic:
positivity
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
  all_goals 

Proof state:
case ha
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 < x ^ z

Next tactic:
positivity
lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z := by
  have := hx.trans_le hxy
  rw [← inv_le_inv, ← rpow_neg, ← rpow_neg]
  refine rpow_le_rpow ?_ hxy (neg_nonneg.2 hz)
  all_goals 

Proof state:
case hb
x y z : ℝ
n : ℕ
hx : 0 < x
hxy : x ≤ y
hz : z ≤ 0
this : 0 < y
⊢ 0 < y ^ z

Next tactic:
positivity
lemma le_rpow_inv_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y

Next tactic:
rw [← rpow_le_rpow_iff hx _ hz, rpow_inv_rpow]
lemma le_rpow_inv_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y := by
  rw [← rpow_le_rpow_iff hx _ hz, rpow_inv_rpow] <;> 

Proof state:
case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ 0 ≤ y

Next tactic:
positivity
lemma le_rpow_inv_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y := by
  rw [← rpow_le_rpow_iff hx _ hz, rpow_inv_rpow] <;> 

Proof state:
case hy
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ z ≠ 0

Next tactic:
positivity
lemma le_rpow_inv_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y := by
  rw [← rpow_le_rpow_iff hx _ hz, rpow_inv_rpow] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ 0 ≤ y ^ z⁻¹

Next tactic:
positivity
lemma rpow_inv_le_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z

Next tactic:
rw [← rpow_le_rpow_iff _ hy hz, rpow_inv_rpow]
lemma rpow_inv_le_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z := by
  rw [← rpow_le_rpow_iff _ hy hz, rpow_inv_rpow] <;> 

Proof state:
case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ 0 ≤ x

Next tactic:
positivity
lemma rpow_inv_le_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z := by
  rw [← rpow_le_rpow_iff _ hy hz, rpow_inv_rpow] <;> 

Proof state:
case hy
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ z ≠ 0

Next tactic:
positivity
lemma rpow_inv_le_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z := by
  rw [← rpow_le_rpow_iff _ hy hz, rpow_inv_rpow] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 < z
⊢ 0 ≤ x ^ z⁻¹

Next tactic:
positivity
theorem le_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z

Next tactic:
rw [← rpow_le_rpow_iff_of_neg _ hx hz, rpow_inv_rpow _ hz.ne]
theorem le_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z := by
  rw [← rpow_le_rpow_iff_of_neg _ hx hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 ≤ y

Next tactic:
positivity
theorem le_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z := by
  rw [← rpow_le_rpow_iff_of_neg _ hx hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 < y ^ z⁻¹

Next tactic:
positivity
theorem lt_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x < y ^ z⁻¹ ↔ y < x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x < y ^ z⁻¹ ↔ y < x ^ z

Next tactic:
rw [← rpow_lt_rpow_iff_of_neg _ hx hz, rpow_inv_rpow _ hz.ne]
theorem lt_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x < y ^ z⁻¹ ↔ y < x ^ z := by
  rw [← rpow_lt_rpow_iff_of_neg _ hx hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 ≤ y

Next tactic:
positivity
theorem lt_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x < y ^ z⁻¹ ↔ y < x ^ z := by
  rw [← rpow_lt_rpow_iff_of_neg _ hx hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 < y ^ z⁻¹

Next tactic:
positivity
theorem rpow_inv_lt_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ < y ↔ y ^ z < x := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x ^ z⁻¹ < y ↔ y ^ z < x

Next tactic:
rw [← rpow_lt_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne]
theorem rpow_inv_lt_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ < y ↔ y ^ z < x := by
  rw [← rpow_lt_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 ≤ x

Next tactic:
positivity
theorem rpow_inv_lt_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ < y ↔ y ^ z < x := by
  rw [← rpow_lt_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 < x ^ z⁻¹

Next tactic:
positivity
theorem rpow_inv_le_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x

Next tactic:
rw [← rpow_le_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne]
theorem rpow_inv_le_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x := by
  rw [← rpow_le_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 ≤ x

Next tactic:
positivity
theorem rpow_inv_le_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x := by
  rw [← rpow_le_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne] <;> 

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 < x ^ z⁻¹

Next tactic:
positivity
theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
hyz : y < z
⊢ x ^ y < x ^ z

Next tactic:
repeat' rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
hyz : y < z
⊢ x ^ y < x ^ z

Next tactic:
rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
hyz : y < z
⊢ rexp (log x * y) < x ^ z

Next tactic:
rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
hyz : y < z
⊢ rexp (log x * y) < rexp (log x * z)

Next tactic:
rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z := by
  repeat' rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
  

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
hyz : y < z
⊢ rexp (log x * y) < rexp (log x * z)

Next tactic:
rw [exp_lt_exp]
theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z := by
  repeat' rw [rpow_def_of_pos (lt_trans zero_lt_one hx)]
  rw [exp_lt_exp]; 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
hyz : y < z
⊢ log x * y < log x * z

Next tactic:
exact mul_lt_mul_of_pos_left hyz (log_pos hx)
@[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ x ^ y ≤ x ^ z

Next tactic:
repeat' rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
@[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ x ^ y ≤ x ^ z

Next tactic:
rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
@[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ x ^ z

Next tactic:
rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
@[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)

Next tactic:
rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
@[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z := by
  repeat' rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
  

Proof state:
x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)

Next tactic:
rw [exp_le_exp]
@[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z := by
  repeat' rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
  rw [exp_le_exp]; 

Proof state:
x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ log x * y ≤ log x * z

Next tactic:
exact mul_le_mul_of_nonneg_left hyz (log_nonneg hx)
theorem rpow_lt_rpow_of_exponent_neg {x y z : ℝ} (hy : 0 < y) (hxy : y < x) (hz : z < 0) :
    x ^ z < y ^ z := by
  

Proof state:
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
hy : 0 < y
hxy : y < x
hz : z < 0
⊢ x ^ z < y ^ z

Next tactic:
have hx : 0 < x := hy.trans hxy
theorem rpow_lt_rpow_of_exponent_neg {x y z : ℝ} (hy : 0 < y) (hxy : y < x) (hz : z < 0) :
    x ^ z < y ^ z := by
  have hx : 0 < x := hy.trans hxy
  

Proof state:
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
hy : 0 < y
hxy : y < x
hz : z < 0
hx : 0 < x
⊢ x ^ z < y ^ z

Next tactic:
rw [← neg_neg z, Real.rpow_neg (le_of_lt hx) (-z), Real.rpow_neg (le_of_lt hy) (-z),
      inv_lt_inv (rpow_pos_of_pos hx _) (rpow_pos_of_pos hy _)]
theorem rpow_lt_rpow_of_exponent_neg {x y z : ℝ} (hy : 0 < y) (hxy : y < x) (hz : z < 0) :
    x ^ z < y ^ z := by
  have hx : 0 < x := hy.trans hxy
  rw [← neg_neg z, Real.rpow_neg (le_of_lt hx) (-z), Real.rpow_neg (le_of_lt hy) (-z),
      inv_lt_inv (rpow_pos_of_pos hx _) (rpow_pos_of_pos hy _)]
  

Proof state:
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
hy : 0 < y
hxy : y < x
hz : z < 0
hx : 0 < x
⊢ y ^ (-z) < x ^ (-z)

Next tactic:
exact Real.rpow_lt_rpow (by positivity) hxy <| neg_pos_of_neg hz