Theorem: ENNReal.zpow_le_of_le
File: Mathlib/Data/ENNReal/Inv.lean

tactic: induction' a with a a <;> induction' b with b b
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℤ
h : a ≤ b
⊢ x ^ a ≤ x ^ b
state_after: case ofNat.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.ofNat b
⊢ x ^ Int.ofNat a ≤ x ^ Int.ofNat b

case ofNat.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.negSucc b
⊢ x ^ Int.ofNat a ≤ x ^ Int.negSucc b

case negSucc.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.ofNat b
⊢ x ^ Int.negSucc a ≤ x ^ Int.ofNat b

case negSucc.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.negSucc b
⊢ x ^ Int.negSucc a ≤ x ^ Int.negSucc b

tactic: simp only [Int.ofNat_eq_coe, zpow_natCast]
state_before: case ofNat.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.ofNat b
⊢ x ^ Int.ofNat a ≤ x ^ Int.ofNat b
state_after: case ofNat.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.ofNat b
⊢ x ^ a ≤ x ^ b

tactic: exact pow_le_pow_right hx (Int.le_of_ofNat_le_ofNat h)
state_before: case ofNat.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.ofNat b
⊢ x ^ a ≤ x ^ b
state_after: no goals

tactic: apply absurd h (not_le_of_gt _)
state_before: case ofNat.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.negSucc b
⊢ x ^ Int.ofNat a ≤ x ^ Int.negSucc b
state_after: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.negSucc b
⊢ Int.ofNat a > Int.negSucc b

tactic: exact lt_of_lt_of_le (Int.negSucc_lt_zero _) (Int.ofNat_nonneg _)
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.ofNat a ≤ Int.negSucc b
⊢ Int.ofNat a > Int.negSucc b
state_after: no goals

tactic: simp only [zpow_negSucc, Int.ofNat_eq_coe, zpow_natCast]
state_before: case negSucc.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.ofNat b
⊢ x ^ Int.negSucc a ≤ x ^ Int.ofNat b
state_after: case negSucc.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.ofNat b
⊢ (x ^ (a + 1))⁻¹ ≤ x ^ b

tactic: refine (ENNReal.inv_le_one.2 ?_).trans ?_ <;> exact one_le_pow_of_one_le' hx _
state_before: case negSucc.ofNat
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.ofNat b
⊢ (x ^ (a + 1))⁻¹ ≤ x ^ b
state_after: no goals

tactic: simp only [zpow_negSucc, ENNReal.inv_le_inv]
state_before: case negSucc.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.negSucc b
⊢ x ^ Int.negSucc a ≤ x ^ Int.negSucc b
state_after: case negSucc.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.negSucc b
⊢ x ^ (b + 1) ≤ x ^ (a + 1)

tactic: apply pow_le_pow_right hx
state_before: case negSucc.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.negSucc b
⊢ x ^ (b + 1) ≤ x ^ (a + 1)
state_after: case negSucc.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.negSucc b
⊢ b + 1 ≤ a + 1

tactic: simpa only [← Int.ofNat_le, neg_le_neg_iff, Int.ofNat_add, Int.ofNat_one, Int.negSucc_eq] using
  h
state_before: case negSucc.negSucc
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
hx : 1 ≤ x
a b : ℕ
h : Int.negSucc a ≤ Int.negSucc b
⊢ b + 1 ≤ a + 1
state_after: no goals