l3lab/ntp-mathlib huggingface dataset:
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 _)]
  exact Real.rpow_lt_rpow (by 

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

Next tactic:
positivity
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  

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

Next tactic:
rcases ne_or_eq z 0 with hz_zero | rfl
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  

Proof state:
case inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
⊢ x ^ z ≤ y ^ z
case inr x✝ y✝ : ℝ n : ℕ x y : ℝ hy : 0 < y hxy : y ≤ x hz : 0 ≤ 0 ⊢ x ^ 0 ≤ y ^ 0

Next tactic:
case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    case inr => simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  

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

Next tactic:
case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    case inr => simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    

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

Next tactic:
rcases ne_or_eq x y with hxy' | rfl
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    

Proof state:
case inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
hxy' : x ≠ y
⊢ x ^ z ≤ y ^ z
case inr x✝ y z : ℝ n : ℕ x : ℝ hz : z ≤ 0 hz_zero : z ≠ 0 hy : 0 < x hxy : x ≤ x ⊢ x ^ z ≤ x ^ z

Next tactic:
case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    

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

Next tactic:
case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      

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

Next tactic:
exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    

Proof state:
case inr
x✝ y z : ℝ
n : ℕ
x : ℝ
hz : z ≤ 0
hz_zero : z ≠ 0
hy : 0 < x
hxy : x ≤ x
⊢ x ^ z ≤ x ^ z

Next tactic:
case inr => simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    

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

Next tactic:
case inr => simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    case inr => 

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

Next tactic:
simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    case inr => simp
  

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

Next tactic:
case inr => simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    case inr => simp
  

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

Next tactic:
case inr => simp
theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z := by
  rcases ne_or_eq z 0 with hz_zero | rfl
  case inl =>
    rcases ne_or_eq x y with hxy' | rfl
    case inl =>
      exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
        (Ne.lt_of_le hz_zero hz)
    case inr => simp
  case inr => 

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

Next tactic:
simp
@[simp]
theorem rpow_le_rpow_left_iff (hx : 1 < x) : x ^ y ≤ x ^ z ↔ y ≤ z := by
  

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

Next tactic:
have x_pos : 0 < x := lt_trans zero_lt_one hx
@[simp]
theorem rpow_le_rpow_left_iff (hx : 1 < x) : x ^ y ≤ x ^ z ↔ y ≤ z := by
  have x_pos : 0 < x := lt_trans zero_lt_one hx
  

Proof state:
x y z : ℝ
n : ℕ
hx : 1 < x
x_pos : 0 < x
⊢ x ^ y ≤ x ^ z ↔ y ≤ z

Next tactic:
rw [← log_le_log_iff (rpow_pos_of_pos x_pos y) (rpow_pos_of_pos x_pos z), log_rpow x_pos,
    log_rpow x_pos, mul_le_mul_right (log_pos hx)]
@[simp]
theorem rpow_lt_rpow_left_iff (hx : 1 < x) : x ^ y < x ^ z ↔ y < z := by
  

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

Next tactic:
rw [lt_iff_not_le, rpow_le_rpow_left_iff hx, lt_iff_not_le]
theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ x ^ y < x ^ z

Next tactic:
repeat' rw [rpow_def_of_pos hx0]
theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ x ^ y < x ^ z

Next tactic:
rw [rpow_def_of_pos hx0]
theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z := by
  repeat' 

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

Next tactic:
rw [rpow_def_of_pos hx0]
theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z := by
  repeat' 

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

Next tactic:
rw [rpow_def_of_pos hx0]
theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z := by
  repeat' rw [rpow_def_of_pos hx0]
  

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

Next tactic:
rw [exp_lt_exp]
theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z := by
  repeat' rw [rpow_def_of_pos hx0]
  rw [exp_lt_exp]; 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ log x * y < log x * z

Next tactic:
exact mul_lt_mul_of_neg_left hyz (log_neg hx0 hx1)
theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x ≤ 1
hyz : z ≤ y
⊢ x ^ y ≤ x ^ z

Next tactic:
repeat' rw [rpow_def_of_pos hx0]
theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x ≤ 1
hyz : z ≤ y
⊢ x ^ y ≤ x ^ z

Next tactic:
rw [rpow_def_of_pos hx0]
theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x ≤ 1
hyz : z ≤ y
⊢ rexp (log x * y) ≤ x ^ z

Next tactic:
rw [rpow_def_of_pos hx0]
theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z := by
  repeat' 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x ≤ 1
hyz : z ≤ y
⊢ rexp (log x * y) ≤ rexp (log x * z)

Next tactic:
rw [rpow_def_of_pos hx0]
theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z := by
  repeat' rw [rpow_def_of_pos hx0]
  

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x ≤ 1
hyz : z ≤ y
⊢ rexp (log x * y) ≤ rexp (log x * z)

Next tactic:
rw [exp_le_exp]
theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z := by
  repeat' rw [rpow_def_of_pos hx0]
  rw [exp_le_exp]; 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x ≤ 1
hyz : z ≤ y
⊢ log x * y ≤ log x * z

Next tactic:
exact mul_le_mul_of_nonpos_left hyz (log_nonpos (le_of_lt hx0) hx1)
@[simp]
theorem rpow_le_rpow_left_iff_of_base_lt_one (hx0 : 0 < x) (hx1 : x < 1) :
    x ^ y ≤ x ^ z ↔ z ≤ y := by
  

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
⊢ x ^ y ≤ x ^ z ↔ z ≤ y

Next tactic:
rw [← log_le_log_iff (rpow_pos_of_pos hx0 y) (rpow_pos_of_pos hx0 z), log_rpow hx0, log_rpow hx0,
    mul_le_mul_right_of_neg (log_neg hx0 hx1)]
@[simp]
theorem rpow_lt_rpow_left_iff_of_base_lt_one (hx0 : 0 < x) (hx1 : x < 1) : x ^ y < x ^ z ↔ z < y :=
  by 

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
⊢ x ^ y < x ^ z ↔ z < y

Next tactic:
rw [lt_iff_not_le, rpow_le_rpow_left_iff_of_base_lt_one hx0 hx1, lt_iff_not_le]
theorem rpow_lt_one {x z : ℝ} (hx1 : 0 ≤ x) (hx2 : x < 1) (hz : 0 < z) : x ^ z < 1 := by
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x < 1
hz : 0 < z
⊢ x ^ z < 1

Next tactic:
rw [← one_rpow z]
theorem rpow_lt_one {x z : ℝ} (hx1 : 0 ≤ x) (hx2 : x < 1) (hz : 0 < z) : x ^ z < 1 := by
  rw [← one_rpow z]
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x < 1
hz : 0 < z
⊢ x ^ z < 1 ^ z

Next tactic:
exact rpow_lt_rpow hx1 hx2 hz
theorem rpow_le_one {x z : ℝ} (hx1 : 0 ≤ x) (hx2 : x ≤ 1) (hz : 0 ≤ z) : x ^ z ≤ 1 := by
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1

Next tactic:
rw [← one_rpow z]
theorem rpow_le_one {x z : ℝ} (hx1 : 0 ≤ x) (hx2 : x ≤ 1) (hz : 0 ≤ z) : x ^ z ≤ 1 := by
  rw [← one_rpow z]
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1 ^ z

Next tactic:
exact rpow_le_rpow hx1 hx2 hz
theorem rpow_lt_one_of_one_lt_of_neg {x z : ℝ} (hx : 1 < x) (hz : z < 0) : x ^ z < 1 := by
  

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

Next tactic:
convert rpow_lt_rpow_of_exponent_lt hx hz
theorem rpow_lt_one_of_one_lt_of_neg {x z : ℝ} (hx : 1 < x) (hz : z < 0) : x ^ z < 1 := by
  convert rpow_lt_rpow_of_exponent_lt hx hz
  

Proof state:
case h.e'_4
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 < x
hz : z < 0
⊢ 1 = x ^ 0

Next tactic:
exact (rpow_zero x).symm
theorem rpow_le_one_of_one_le_of_nonpos {x z : ℝ} (hx : 1 ≤ x) (hz : z ≤ 0) : x ^ z ≤ 1 := by
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : z ≤ 0
⊢ x ^ z ≤ 1

Next tactic:
convert rpow_le_rpow_of_exponent_le hx hz
theorem rpow_le_one_of_one_le_of_nonpos {x z : ℝ} (hx : 1 ≤ x) (hz : z ≤ 0) : x ^ z ≤ 1 := by
  convert rpow_le_rpow_of_exponent_le hx hz
  

Proof state:
case h.e'_4
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : z ≤ 0
⊢ 1 = x ^ 0

Next tactic:
exact (rpow_zero x).symm
theorem one_lt_rpow {x z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z := by
  

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

Next tactic:
rw [← one_rpow z]
theorem one_lt_rpow {x z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z := by
  rw [← one_rpow z]
  

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

Next tactic:
exact rpow_lt_rpow zero_le_one hx hz
theorem one_le_rpow {x z : ℝ} (hx : 1 ≤ x) (hz : 0 ≤ z) : 1 ≤ x ^ z := by
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ≤ x ^ z

Next tactic:
rw [← one_rpow z]
theorem one_le_rpow {x z : ℝ} (hx : 1 ≤ x) (hz : 0 ≤ z) : 1 ≤ x ^ z := by
  rw [← one_rpow z]
  

Proof state:
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ^ z ≤ x ^ z

Next tactic:
exact rpow_le_rpow zero_le_one hx hz
theorem one_lt_rpow_of_pos_of_lt_one_of_neg (hx1 : 0 < x) (hx2 : x < 1) (hz : z < 0) :
    1 < x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 < x ^ z

Next tactic:
convert rpow_lt_rpow_of_exponent_gt hx1 hx2 hz
theorem one_lt_rpow_of_pos_of_lt_one_of_neg (hx1 : 0 < x) (hx2 : x < 1) (hz : z < 0) :
    1 < x ^ z := by
  convert rpow_lt_rpow_of_exponent_gt hx1 hx2 hz
  

Proof state:
case h.e'_3
x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 = x ^ 0

Next tactic:
exact (rpow_zero x).symm
theorem one_le_rpow_of_pos_of_le_one_of_nonpos (hx1 : 0 < x) (hx2 : x ≤ 1) (hz : z ≤ 0) :
    1 ≤ x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x ≤ 1
hz : z ≤ 0
⊢ 1 ≤ x ^ z

Next tactic:
convert rpow_le_rpow_of_exponent_ge hx1 hx2 hz
theorem one_le_rpow_of_pos_of_le_one_of_nonpos (hx1 : 0 < x) (hx2 : x ≤ 1) (hz : z ≤ 0) :
    1 ≤ x ^ z := by
  convert rpow_le_rpow_of_exponent_ge hx1 hx2 hz
  

Proof state:
case h.e'_3
x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x ≤ 1
hz : z ≤ 0
⊢ 1 = x ^ 0

Next tactic:
exact (rpow_zero x).symm
theorem rpow_lt_one_iff_of_pos (hx : 0 < x) : x ^ y < 1 ↔ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
⊢ x ^ y < 1 ↔ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y

Next tactic:
rw [rpow_def_of_pos hx, exp_lt_one_iff, mul_neg_iff, log_pos_iff hx, log_neg_iff hx]
theorem rpow_lt_one_iff (hx : 0 ≤ x) :
    x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
⊢ x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y

Next tactic:
rcases hx.eq_or_lt with (rfl | hx)
theorem rpow_lt_one_iff (hx : 0 ≤ x) :
    x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y := by
  rcases hx.eq_or_lt with (rfl | hx)
  · 

Proof state:
case inl
y z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 0 ^ y < 1 ↔ 0 = 0 ∧ y ≠ 0 ∨ 1 < 0 ∧ y < 0 ∨ 0 < 1 ∧ 0 < y

Next tactic:
rcases _root_.em (y = 0) with (rfl | hy)
theorem rpow_lt_one_iff (hx : 0 ≤ x) :
    x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y := by
  rcases hx.eq_or_lt with (rfl | hx)
  · rcases _root_.em (y = 0) with (rfl | hy) <;> 

Proof state:
case inl.inl
z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 0 ^ 0 < 1 ↔ 0 = 0 ∧ 0 ≠ 0 ∨ 1 < 0 ∧ 0 < 0 ∨ 0 < 1 ∧ 0 < 0

Next tactic:
simp [*, lt_irrefl, zero_lt_one]
theorem rpow_lt_one_iff (hx : 0 ≤ x) :
    x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y := by
  rcases hx.eq_or_lt with (rfl | hx)
  · rcases _root_.em (y = 0) with (rfl | hy) <;> 

Proof state:
case inl.inr
y z : ℝ
n : ℕ
hx : 0 ≤ 0
hy : ¬y = 0
⊢ 0 ^ y < 1 ↔ 0 = 0 ∧ y ≠ 0 ∨ 1 < 0 ∧ y < 0 ∨ 0 < 1 ∧ 0 < y

Next tactic:
simp [*, lt_irrefl, zero_lt_one]
theorem rpow_lt_one_iff (hx : 0 ≤ x) :
    x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y := by
  rcases hx.eq_or_lt with (rfl | hx)
  · rcases _root_.em (y = 0) with (rfl | hy) <;> simp [*, lt_irrefl, zero_lt_one]
  · 

Proof state:
case inr
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y

Next tactic:
simp [rpow_lt_one_iff_of_pos hx, hx.ne.symm]
theorem rpow_lt_one_iff' {x y : ℝ} (hx : 0 ≤ x) (hy : 0 < y) :
    x ^ y < 1 ↔ x < 1 := by
  

Proof state:
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hx : 0 ≤ x
hy : 0 < y
⊢ x ^ y < 1 ↔ x < 1

Next tactic:
rw [← Real.rpow_lt_rpow_iff hx zero_le_one hy, Real.one_rpow]
theorem one_lt_rpow_iff_of_pos (hx : 0 < x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ x < 1 ∧ y < 0 := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ x < 1 ∧ y < 0

Next tactic:
rw [rpow_def_of_pos hx, one_lt_exp_iff, mul_pos_iff, log_pos_iff hx, log_neg_iff hx]
theorem one_lt_rpow_iff (hx : 0 ≤ x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0 := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0

Next tactic:
rcases hx.eq_or_lt with (rfl | hx)
theorem one_lt_rpow_iff (hx : 0 ≤ x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0 := by
  rcases hx.eq_or_lt with (rfl | hx)
  · 

Proof state:
case inl
y z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 1 < 0 ^ y ↔ 1 < 0 ∧ 0 < y ∨ 0 < 0 ∧ 0 < 1 ∧ y < 0

Next tactic:
rcases _root_.em (y = 0) with (rfl | hy)
theorem one_lt_rpow_iff (hx : 0 ≤ x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0 := by
  rcases hx.eq_or_lt with (rfl | hx)
  · rcases _root_.em (y = 0) with (rfl | hy) <;> 

Proof state:
case inl.inl
z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 1 < 0 ^ 0 ↔ 1 < 0 ∧ 0 < 0 ∨ 0 < 0 ∧ 0 < 1 ∧ 0 < 0

Next tactic:
simp [*, lt_irrefl, (zero_lt_one' ℝ).not_lt]
theorem one_lt_rpow_iff (hx : 0 ≤ x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0 := by
  rcases hx.eq_or_lt with (rfl | hx)
  · rcases _root_.em (y = 0) with (rfl | hy) <;> 

Proof state:
case inl.inr
y z : ℝ
n : ℕ
hx : 0 ≤ 0
hy : ¬y = 0
⊢ 1 < 0 ^ y ↔ 1 < 0 ∧ 0 < y ∨ 0 < 0 ∧ 0 < 1 ∧ y < 0

Next tactic:
simp [*, lt_irrefl, (zero_lt_one' ℝ).not_lt]
theorem one_lt_rpow_iff (hx : 0 ≤ x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0 := by
  rcases hx.eq_or_lt with (rfl | hx)
  · rcases _root_.em (y = 0) with (rfl | hy) <;> simp [*, lt_irrefl, (zero_lt_one' ℝ).not_lt]
  · 

Proof state:
case inr
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0

Next tactic:
simp [one_lt_rpow_iff_of_pos hx, hx]
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx0 : 0 ≤ x
hx1 : x ≤ 1
hz : 0 ≤ z
hyz : z ≤ y
⊢ x ^ y ≤ x ^ z

Next tactic:
rcases eq_or_lt_of_le hx0 with (rfl | hx0')
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  rcases eq_or_lt_of_le hx0 with (rfl | hx0')
  · 

Proof state:
case inl
y z : ℝ
n : ℕ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
⊢ 0 ^ y ≤ 0 ^ z

Next tactic:
rcases eq_or_lt_of_le hz with (rfl | hz')
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  rcases eq_or_lt_of_le hx0 with (rfl | hx0')
  · rcases eq_or_lt_of_le hz with (rfl | hz')
    · 

Proof state:
case inl.inl
y : ℝ
n : ℕ
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
hz : 0 ≤ 0
hyz : 0 ≤ y
⊢ 0 ^ y ≤ 0 ^ 0

Next tactic:
exact (rpow_zero 0).symm ▸ rpow_le_one hx0 hx1 hyz
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  rcases eq_or_lt_of_le hx0 with (rfl | hx0')
  · rcases eq_or_lt_of_le hz with (rfl | hz')
    · exact (rpow_zero 0).symm ▸ rpow_le_one hx0 hx1 hyz
    

Proof state:
case inl.inr
y z : ℝ
n : ℕ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
hz' : 0 < z
⊢ 0 ^ y ≤ 0 ^ z

Next tactic:
rw [zero_rpow, zero_rpow]
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  rcases eq_or_lt_of_le hx0 with (rfl | hx0')
  · rcases eq_or_lt_of_le hz with (rfl | hz')
    · exact (rpow_zero 0).symm ▸ rpow_le_one hx0 hx1 hyz
    rw [zero_rpow, zero_rpow] <;> 

Proof state:
case inl.inr
y z : ℝ
n : ℕ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
hz' : 0 < z
⊢ z ≠ 0

Next tactic:
linarith
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  rcases eq_or_lt_of_le hx0 with (rfl | hx0')
  · rcases eq_or_lt_of_le hz with (rfl | hz')
    · exact (rpow_zero 0).symm ▸ rpow_le_one hx0 hx1 hyz
    rw [zero_rpow, zero_rpow] <;> 

Proof state:
case inl.inr
y z : ℝ
n : ℕ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
hz' : 0 < z
⊢ y ≠ 0

Next tactic:
linarith
theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z := by
  rcases eq_or_lt_of_le hx0 with (rfl | hx0')
  · rcases eq_or_lt_of_le hz with (rfl | hz')
    · exact (rpow_zero 0).symm ▸ rpow_le_one hx0 hx1 hyz
    rw [zero_rpow, zero_rpow] <;> linarith
  · 

Proof state:
case inr
x y z : ℝ
n : ℕ
hx0 : 0 ≤ x
hx1 : x ≤ 1
hz : 0 ≤ z
hyz : z ≤ y
hx0' : 0 < x
⊢ x ^ y ≤ x ^ z

Next tactic:
exact rpow_le_rpow_of_exponent_ge hx0' hx1 hyz
theorem rpow_left_injOn {x : ℝ} (hx : x ≠ 0) : InjOn (fun y : ℝ => y ^ x) { y : ℝ | 0 ≤ y } := by
  

Proof state:
x✝ y z : ℝ
n : ℕ
x : ℝ
hx : x ≠ 0
⊢ InjOn (fun y => y ^ x) {y | 0 ≤ y}

Next tactic:
rintro y hy z hz (hyz : y ^ x = z ^ x)
theorem rpow_left_injOn {x : ℝ} (hx : x ≠ 0) : InjOn (fun y : ℝ => y ^ x) { y : ℝ | 0 ≤ y } := by
  rintro y hy z hz (hyz : y ^ x = z ^ x)
  

Proof state:
x✝ y✝ z✝ : ℝ
n : ℕ
x : ℝ
hx : x ≠ 0
y : ℝ
hy : y ∈ {y | 0 ≤ y}
z : ℝ
hz : z ∈ {y | 0 ≤ y}
hyz : y ^ x = z ^ x
⊢ y = z

Next tactic:
rw [← rpow_one y, ← rpow_one z, ← _root_.mul_inv_cancel hx, rpow_mul hy, rpow_mul hz, hyz]
lemma rpow_inv_eq (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : z ≠ 0) : x ^ z⁻¹ = y ↔ x = y ^ z := by
  

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

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

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

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

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

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

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

Next tactic:
positivity
theorem le_rpow_iff_log_le (hx : 0 < x) (hy : 0 < y) : x ≤ y ^ z ↔ Real.log x ≤ z * Real.log y := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
⊢ x ≤ y ^ z ↔ log x ≤ z * log y

Next tactic:
rw [← Real.log_le_log_iff hx (Real.rpow_pos_of_pos hy z), Real.log_rpow hy]
theorem le_rpow_of_log_le (hx : 0 ≤ x) (hy : 0 < y) (h : Real.log x ≤ z * Real.log y) :
    x ≤ y ^ z := by
  

Proof state:
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
⊢ x ≤ y ^ z

Next tactic:
obtain hx | rfl := hx.lt_or_eq
theorem le_rpow_of_log_le (hx : 0 ≤ x) (hy : 0 < y) (h : Real.log x ≤ z * Real.log y) :
    x ≤ y ^ z := by
  obtain hx | rfl := hx.lt_or_eq
  · 

Proof state:
case inl
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
hx : 0 < x
⊢ x ≤ y ^ z

Next tactic:
exact (le_rpow_iff_log_le hx hy).2 h