File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

full_name: NNReal.rpow
code: /-- The nonnegative real power function `x^y`, defined for `x : ℝ≥0` and `y : ℝ` as the
restriction of the real power function. For `x > 0`, it is equal to `exp (y log x)`. For `x = 0`,
one sets `0 ^ 0 = 1` and `0 ^ y = 0` for `y ≠ 0`. -/
noncomputable def rpow (x : ℝ≥0) (y : ℝ) : ℝ≥0 
goal: ℝ≥0

full_name: NNReal.instPowReal
code: noncomputable instance : Pow ℝ≥0 ℝ 
goal: Pow ℝ≥0 ℝ

full_name: NNReal.rpow_eq_pow
code: @[simp]
theorem rpow_eq_pow (x : ℝ≥0) (y : ℝ) : rpow x y = x ^ y 
goal: x.rpow y = x ^ y

full_name: NNReal.coe_rpow
code: @[simp, norm_cast]
theorem coe_rpow (x : ℝ≥0) (y : ℝ) : ((x ^ y : ℝ≥0) : ℝ) = (x : ℝ) ^ y 
goal: ↑(x ^ y) = ↑x ^ y

full_name: NNReal.rpow_zero
code: @[simp]
theorem rpow_zero (x : ℝ≥0) : x ^ (0 : ℝ) = 1 
goal: x ^ 0 = 1

full_name: NNReal.rpow_eq_zero_iff
code: @[simp]
theorem rpow_eq_zero_iff {x : ℝ≥0} {y : ℝ} : x ^ y = 0 ↔ x = 0 ∧ y ≠ 0 
goal: x ^ y = 0 ↔ x = 0 ∧ y ≠ 0

full_name: NNReal.zero_rpow
code: @[simp]
theorem zero_rpow {x : ℝ} (h : x ≠ 0) : (0 : ℝ≥0) ^ x = 0 
goal: 0 ^ x = 0

full_name: NNReal.rpow_one
code: @[simp]
theorem rpow_one (x : ℝ≥0) : x ^ (1 : ℝ) = x 
goal: x ^ 1 = x

full_name: NNReal.one_rpow
code: @[simp]
theorem one_rpow (x : ℝ) : (1 : ℝ≥0) ^ x = 1 
goal: 1 ^ x = 1

full_name: NNReal.rpow_add
code: theorem rpow_add {x : ℝ≥0} (hx : x ≠ 0) (y z : ℝ) : x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: NNReal.rpow_add'
code: theorem rpow_add' (x : ℝ≥0) {y z : ℝ} (h : y + z ≠ 0) : x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: NNReal.rpow_add_of_nonneg
code: theorem rpow_add_of_nonneg (x : ℝ≥0) {y z : ℝ} (hy : 0 ≤ y) (hz : 0 ≤ z) :
    x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: NNReal.rpow_of_add_eq
code: /-- Variant of `NNReal.rpow_add'` that avoids having to prove `y + z = w` twice. -/
lemma rpow_of_add_eq (x : ℝ≥0) (hw : w ≠ 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z 
goal: x ^ w = x ^ y * x ^ z

full_name: NNReal.rpow_mul
code: theorem rpow_mul (x : ℝ≥0) (y z : ℝ) : x ^ (y * z) = (x ^ y) ^ z 
goal: x ^ (y * z) = (x ^ y) ^ z

full_name: NNReal.rpow_neg
code: theorem rpow_neg (x : ℝ≥0) (y : ℝ) : x ^ (-y) = (x ^ y)⁻¹ 
goal: x ^ (-y) = (x ^ y)⁻¹

full_name: NNReal.rpow_neg_one
code: theorem rpow_neg_one (x : ℝ≥0) : x ^ (-1 : ℝ) = x⁻¹ 
goal: x ^ (-1) = x⁻¹

full_name: NNReal.rpow_sub
code: theorem rpow_sub {x : ℝ≥0} (hx : x ≠ 0) (y z : ℝ) : x ^ (y - z) = x ^ y / x ^ z 
goal: x ^ (y - z) = x ^ y / x ^ z

full_name: NNReal.rpow_sub'
code: theorem rpow_sub' (x : ℝ≥0) {y z : ℝ} (h : y - z ≠ 0) : x ^ (y - z) = x ^ y / x ^ z 
goal: x ^ (y - z) = x ^ y / x ^ z

full_name: NNReal.rpow_inv_rpow_self
code: theorem rpow_inv_rpow_self {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ y) ^ (1 / y) = x 
goal: (x ^ y) ^ (1 / y) = x

full_name: NNReal.rpow_self_rpow_inv
code: theorem rpow_self_rpow_inv {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ (1 / y)) ^ y = x 
goal: (x ^ (1 / y)) ^ y = x

full_name: NNReal.inv_rpow
code: theorem inv_rpow (x : ℝ≥0) (y : ℝ) : x⁻¹ ^ y = (x ^ y)⁻¹ 
goal: x⁻¹ ^ y = (x ^ y)⁻¹

full_name: NNReal.div_rpow
code: theorem div_rpow (x y : ℝ≥0) (z : ℝ) : (x / y) ^ z = x ^ z / y ^ z 
goal: (x / y) ^ z = x ^ z / y ^ z

full_name: NNReal.sqrt_eq_rpow
code: theorem sqrt_eq_rpow (x : ℝ≥0) : sqrt x = x ^ (1 / (2 : ℝ)) 
goal: NNReal.sqrt x = x ^ (1 / 2)

full_name: NNReal.rpow_natCast
code: @[simp, norm_cast]
theorem rpow_natCast (x : ℝ≥0) (n : ℕ) : x ^ (n : ℝ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: NNReal.rpow_ofNat
code: @[simp]
lemma rpow_ofNat (x : ℝ≥0) (n : ℕ) [n.AtLeastTwo] :
    x ^ (no_index (OfNat.ofNat n) : ℝ) = x ^ (OfNat.ofNat n : ℕ) 
goal: x ^ OfNat.ofNat n = x ^ OfNat.ofNat n

full_name: NNReal.rpow_two
code: theorem rpow_two (x : ℝ≥0) : x ^ (2 : ℝ) = x ^ 2 
goal: x ^ 2 = x ^ 2

full_name: NNReal.mul_rpow
code: theorem mul_rpow {x y : ℝ≥0} {z : ℝ} : (x * y) ^ z = x ^ z * y ^ z 
goal: (x * y) ^ z = x ^ z * y ^ z

full_name: NNReal.rpowMonoidHom_apply
code: /-- `rpow` as a `MonoidHom`-/
@[simps]
def rpowMonoidHom (r : ℝ) : ℝ≥0 →* ℝ≥0 
goal: ∀ (x : ℝ≥0), (NNReal.rpowMonoidHom r) x = x ^ r

full_name: NNReal.rpowMonoidHom
code: /-- `rpow` as a `MonoidHom`-/
@[simps]
def rpowMonoidHom (r : ℝ) : ℝ≥0 →* ℝ≥0 
goal: ℝ≥0 →* ℝ≥0

full_name: NNReal.list_prod_map_rpow
code: /-- `rpow` variant of `List.prod_map_pow` for `ℝ≥0`-/
theorem list_prod_map_rpow (l : List ℝ≥0) (r : ℝ) :
    (l.map (· ^ r)).prod = l.prod ^ r 
goal: (List.map (fun x => x ^ r) l).prod = l.prod ^ r

full_name: NNReal.list_prod_map_rpow'
code: theorem list_prod_map_rpow' {ι} (l : List ι) (f : ι → ℝ≥0) (r : ℝ) :
    (l.map (f · ^ r)).prod = (l.map f).prod ^ r 
goal: (List.map (fun x => f x ^ r) l).prod = (List.map f l).prod ^ r

full_name: NNReal.multiset_prod_map_rpow
code: /-- `rpow` version of `Multiset.prod_map_pow` for `ℝ≥0`. -/
lemma multiset_prod_map_rpow {ι} (s : Multiset ι) (f : ι → ℝ≥0) (r : ℝ) :
    (s.map (f · ^ r)).prod = (s.map f).prod ^ r 
goal: (Multiset.map (fun x => f x ^ r) s).prod = (Multiset.map f s).prod ^ r

full_name: NNReal.finset_prod_rpow
code: /-- `rpow` version of `Finset.prod_pow` for `ℝ≥0`. -/
lemma finset_prod_rpow {ι} (s : Finset ι) (f : ι → ℝ≥0) (r : ℝ) :
    (∏ i ∈ s, f i ^ r) = (∏ i ∈ s, f i) ^ r 
goal: ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r

full_name: Real.list_prod_map_rpow
code: /-- `rpow` version of `List.prod_map_pow` for `Real`. -/
theorem _root_.Real.list_prod_map_rpow (l : List ℝ) (hl : ∀ x ∈ l, (0 : ℝ) ≤ x) (r : ℝ) :
    (l.map (· ^ r)).prod = l.prod ^ r 
goal: (List.map (fun x => x ^ r) l).prod = l.prod ^ r

full_name: Real.list_prod_map_rpow'
code: theorem _root_.Real.list_prod_map_rpow' {ι} (l : List ι) (f : ι → ℝ)
    (hl : ∀ i ∈ l, (0 : ℝ) ≤ f i) (r : ℝ) :
    (l.map (f · ^ r)).prod = (l.map f).prod ^ r 
goal: (List.map (fun x => f x ^ r) l).prod = (List.map f l).prod ^ r

full_name: Real.multiset_prod_map_rpow
code: /-- `rpow` version of `Multiset.prod_map_pow`. -/
theorem _root_.Real.multiset_prod_map_rpow {ι} (s : Multiset ι) (f : ι → ℝ)
    (hs : ∀ i ∈ s, (0 : ℝ) ≤ f i) (r : ℝ) :
    (s.map (f · ^ r)).prod = (s.map f).prod ^ r 
goal: (Multiset.map (fun x => f x ^ r) s).prod = (Multiset.map f s).prod ^ r

full_name: Real.finset_prod_rpow
code: /-- `rpow` version of `Finset.prod_pow`. -/
theorem _root_.Real.finset_prod_rpow
    {ι} (s : Finset ι) (f : ι → ℝ) (hs : ∀ i ∈ s, 0 ≤ f i) (r : ℝ) :
    (∏ i ∈ s, f i ^ r) = (∏ i ∈ s, f i) ^ r 
goal: ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r

full_name: NNReal.rpow_le_rpow
code: @[gcongr] theorem rpow_le_rpow {x y : ℝ≥0} {z : ℝ} (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z 
goal: x ^ z ≤ y ^ z

full_name: NNReal.rpow_lt_rpow
code: @[gcongr] theorem rpow_lt_rpow {x y : ℝ≥0} {z : ℝ} (h₁ : x < y) (h₂ : 0 < z) : x ^ z < y ^ z 
goal: x ^ z < y ^ z

full_name: NNReal.rpow_lt_rpow_iff
code: theorem rpow_lt_rpow_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z < y ^ z ↔ x < y 
goal: x ^ z < y ^ z ↔ x < y

full_name: NNReal.rpow_le_rpow_iff
code: theorem rpow_le_rpow_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z ≤ y ^ z ↔ x ≤ y 
goal: x ^ z ≤ y ^ z ↔ x ≤ y

full_name: NNReal.le_rpow_inv_iff
code: theorem le_rpow_inv_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y 
goal: x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y

full_name: NNReal.le_rpow_one_div_iff
code: @[deprecated le_rpow_inv_iff (since := "2024-07-10")]
theorem le_rpow_one_div_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ≤ y ^ (1 / z) ↔ x ^ z ≤ y 
goal: x ≤ y ^ (1 / z) ↔ x ^ z ≤ y

full_name: NNReal.rpow_inv_le_iff
code: theorem rpow_inv_le_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z 
goal: x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z

full_name: NNReal.rpow_one_div_le_iff
code: @[deprecated rpow_inv_le_iff (since := "2024-07-10")]
theorem rpow_one_div_le_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ (1 / z) ≤ y ↔ x ≤ y ^ z 
goal: x ^ (1 / z) ≤ y ↔ x ≤ y ^ z

full_name: NNReal.lt_rpow_inv_iff
code: theorem lt_rpow_inv_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x < y ^ z⁻¹ ↔ x ^z < y 
goal: x < y ^ z⁻¹ ↔ x ^ z < y

full_name: NNReal.rpow_inv_lt_iff
code: theorem rpow_inv_lt_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z⁻¹ < y ↔ x < y ^ z 
goal: x ^ z⁻¹ < y ↔ x < y ^ z

full_name: NNReal.rpow_lt_rpow_of_exponent_lt
code: @[gcongr] theorem rpow_lt_rpow_of_exponent_lt {x : ℝ≥0} {y z : ℝ} (hx : 1 < x) (hyz : y < z) :
    x ^ y < x ^ z 
goal: x ^ y < x ^ z

full_name: NNReal.rpow_le_rpow_of_exponent_le
code: @[gcongr] theorem rpow_le_rpow_of_exponent_le {x : ℝ≥0} {y z : ℝ} (hx : 1 ≤ x) (hyz : y ≤ z) :
    x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: NNReal.rpow_lt_rpow_of_exponent_gt
code: theorem rpow_lt_rpow_of_exponent_gt {x : ℝ≥0} {y z : ℝ} (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) :
    x ^ y < x ^ z 
goal: x ^ y < x ^ z

full_name: NNReal.rpow_le_rpow_of_exponent_ge
code: theorem rpow_le_rpow_of_exponent_ge {x : ℝ≥0} {y z : ℝ} (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: NNReal.rpow_pos
code: theorem rpow_pos {p : ℝ} {x : ℝ≥0} (hx_pos : 0 < x) : 0 < x ^ p 
goal: 0 < x ^ p

full_name: NNReal.rpow_lt_one
code: theorem rpow_lt_one {x : ℝ≥0} {z : ℝ} (hx1 : x < 1) (hz : 0 < z) : x ^ z < 1 
goal: x ^ z < 1

full_name: NNReal.rpow_le_one
code: theorem rpow_le_one {x : ℝ≥0} {z : ℝ} (hx2 : x ≤ 1) (hz : 0 ≤ z) : x ^ z ≤ 1 
goal: x ^ z ≤ 1

full_name: NNReal.rpow_lt_one_of_one_lt_of_neg
code: theorem rpow_lt_one_of_one_lt_of_neg {x : ℝ≥0} {z : ℝ} (hx : 1 < x) (hz : z < 0) : x ^ z < 1 
goal: x ^ z < 1

full_name: NNReal.rpow_le_one_of_one_le_of_nonpos
code: theorem rpow_le_one_of_one_le_of_nonpos {x : ℝ≥0} {z : ℝ} (hx : 1 ≤ x) (hz : z ≤ 0) : x ^ z ≤ 1 
goal: x ^ z ≤ 1

full_name: NNReal.one_lt_rpow
code: theorem one_lt_rpow {x : ℝ≥0} {z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z 
goal: 1 < x ^ z

full_name: NNReal.one_le_rpow
code: theorem one_le_rpow {x : ℝ≥0} {z : ℝ} (h : 1 ≤ x) (h₁ : 0 ≤ z) : 1 ≤ x ^ z 
goal: 1 ≤ x ^ z

full_name: NNReal.one_lt_rpow_of_pos_of_lt_one_of_neg
code: theorem one_lt_rpow_of_pos_of_lt_one_of_neg {x : ℝ≥0} {z : ℝ} (hx1 : 0 < x) (hx2 : x < 1)
    (hz : z < 0) : 1 < x ^ z 
goal: 1 < x ^ z

full_name: NNReal.one_le_rpow_of_pos_of_le_one_of_nonpos
code: theorem one_le_rpow_of_pos_of_le_one_of_nonpos {x : ℝ≥0} {z : ℝ} (hx1 : 0 < x) (hx2 : x ≤ 1)
    (hz : z ≤ 0) : 1 ≤ x ^ z 
goal: 1 ≤ x ^ z

full_name: NNReal.rpow_le_self_of_le_one
code: theorem rpow_le_self_of_le_one {x : ℝ≥0} {z : ℝ} (hx : x ≤ 1) (h_one_le : 1 ≤ z) : x ^ z ≤ x 
goal: x ^ z ≤ x

full_name: NNReal.rpow_left_injective
code: theorem rpow_left_injective {x : ℝ} (hx : x ≠ 0) : Function.Injective fun y : ℝ≥0 => y ^ x 
goal: Function.Injective fun y => y ^ x

full_name: NNReal.rpow_eq_rpow_iff
code: theorem rpow_eq_rpow_iff {x y : ℝ≥0} {z : ℝ} (hz : z ≠ 0) : x ^ z = y ^ z ↔ x = y 
goal: x ^ z = y ^ z ↔ x = y

full_name: NNReal.rpow_left_surjective
code: theorem rpow_left_surjective {x : ℝ} (hx : x ≠ 0) : Function.Surjective fun y : ℝ≥0 => y ^ x 
goal: Function.Surjective fun y => y ^ x

full_name: NNReal.rpow_left_bijective
code: theorem rpow_left_bijective {x : ℝ} (hx : x ≠ 0) : Function.Bijective fun y : ℝ≥0 => y ^ x 
goal: Function.Bijective fun y => y ^ x

full_name: NNReal.eq_rpow_inv_iff
code: theorem eq_rpow_inv_iff {x y : ℝ≥0} {z : ℝ} (hz : z ≠ 0) : x = y ^ z⁻¹ ↔ x ^ z = y 
goal: x = y ^ z⁻¹ ↔ x ^ z = y

full_name: NNReal.eq_rpow_one_div_iff
code: @[deprecated eq_rpow_inv_iff (since := "2024-07-10")]
theorem eq_rpow_one_div_iff {x y : ℝ≥0} {z : ℝ} (hz : z ≠ 0) : x = y ^ (1 / z) ↔ x ^ z = y 
goal: x = y ^ (1 / z) ↔ x ^ z = y

full_name: NNReal.rpow_inv_eq_iff
code: theorem rpow_inv_eq_iff {x y : ℝ≥0} {z : ℝ} (hz : z ≠ 0) : x ^ z⁻¹ = y ↔ x = y ^ z 
goal: x ^ z⁻¹ = y ↔ x = y ^ z

full_name: NNReal.rpow_one_div_eq_iff
code: @[deprecated rpow_inv_eq_iff (since := "2024-07-10")]
theorem rpow_one_div_eq_iff {x y : ℝ≥0} {z : ℝ} (hz : z ≠ 0) : x ^ (1 / z) = y ↔ x = y ^ z 
goal: x ^ (1 / z) = y ↔ x = y ^ z

full_name: NNReal.rpow_rpow_inv
code: @[simp] lemma rpow_rpow_inv {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ y) ^ y⁻¹ = x 
goal: (x ^ y) ^ y⁻¹ = x

full_name: NNReal.rpow_inv_rpow
code: @[simp] lemma rpow_inv_rpow {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ y⁻¹) ^ y = x 
goal: (x ^ y⁻¹) ^ y = x

full_name: NNReal.pow_rpow_inv_natCast
code: theorem pow_rpow_inv_natCast (x : ℝ≥0) {n : ℕ} (hn : n ≠ 0) : (x ^ n) ^ (n⁻¹ : ℝ) = x 
goal: (x ^ n) ^ (↑n)⁻¹ = x

full_name: NNReal.rpow_inv_natCast_pow
code: theorem rpow_inv_natCast_pow (x : ℝ≥0) {n : ℕ} (hn : n ≠ 0) : (x ^ (n⁻¹ : ℝ)) ^ n = x 
goal: (x ^ (↑n)⁻¹) ^ n = x

full_name: Real.toNNReal_rpow_of_nonneg
code: theorem _root_.Real.toNNReal_rpow_of_nonneg {x y : ℝ} (hx : 0 ≤ x) :
    Real.toNNReal (x ^ y) = Real.toNNReal x ^ y 
goal: (x ^ y).toNNReal = x.toNNReal ^ y

full_name: NNReal.strictMono_rpow_of_pos
code: theorem strictMono_rpow_of_pos {z : ℝ} (h : 0 < z) : StrictMono fun x : ℝ≥0 => x ^ z 
goal: StrictMono fun x => x ^ z

full_name: NNReal.monotone_rpow_of_nonneg
code: theorem monotone_rpow_of_nonneg {z : ℝ} (h : 0 ≤ z) : Monotone fun x : ℝ≥0 => x ^ z 
goal: Monotone fun x => x ^ z

full_name: NNReal.orderIsoRpow_apply
code: /-- Bundles `fun x : ℝ≥0 => x ^ y` into an order isomorphism when `y : ℝ` is positive,
where the inverse is `fun x : ℝ≥0 => x ^ (1 / y)`. -/
@[simps! apply]
def orderIsoRpow (y : ℝ) (hy : 0 < y) : ℝ≥0 ≃o ℝ≥0 
goal: (NNReal.orderIsoRpow y hy) x = x ^ y

full_name: NNReal.orderIsoRpow
code: /-- Bundles `fun x : ℝ≥0 => x ^ y` into an order isomorphism when `y : ℝ` is positive,
where the inverse is `fun x : ℝ≥0 => x ^ (1 / y)`. -/
@[simps! apply]
def orderIsoRpow (y : ℝ) (hy : 0 < y) : ℝ≥0 ≃o ℝ≥0 
goal: ℝ≥0 ≃o ℝ≥0

full_name: NNReal.orderIsoRpow_symm_eq
code: theorem orderIsoRpow_symm_eq (y : ℝ) (hy : 0 < y) :
    (orderIsoRpow y hy).symm = orderIsoRpow (1 / y) (one_div_pos.2 hy) 
goal: (NNReal.orderIsoRpow y hy).symm = NNReal.orderIsoRpow (1 / y) ⋯

full_name: Real.nnnorm_rpow_of_nonneg
code: theorem _root_.Real.nnnorm_rpow_of_nonneg {x y : ℝ} (hx : 0 ≤ x) : ‖x ^ y‖₊ = ‖x‖₊ ^ y 
goal: ‖x ^ y‖₊ = ‖x‖₊ ^ y

full_name: ENNReal.rpow
code: /-- The real power function `x^y` on extended nonnegative reals, defined for `x : ℝ≥0∞` and
`y : ℝ` as the restriction of the real power function if `0 < x < ⊤`, and with the natural values
for `0` and `⊤` (i.e., `0 ^ x = 0` for `x > 0`, `1` for `x = 0` and `⊤` for `x < 0`, and
`⊤ ^ x = 1 / 0 ^ x`). -/
noncomputable def rpow : ℝ≥0∞ → ℝ → ℝ≥0∞
  
goal: ℝ≥0∞ → ℝ → ℝ≥0∞

full_name: ENNReal.instPowReal
code: noncomputable instance : Pow ℝ≥0∞ ℝ 
goal: Pow ℝ≥0∞ ℝ

full_name: ENNReal.rpow_eq_pow
code: @[simp]
theorem rpow_eq_pow (x : ℝ≥0∞) (y : ℝ) : rpow x y = x ^ y 
goal: x.rpow y = x ^ y

full_name: ENNReal.rpow_zero
code: @[simp]
theorem rpow_zero {x : ℝ≥0∞} : x ^ (0 : ℝ) = 1 
goal: x ^ 0 = 1

full_name: ENNReal.top_rpow_def
code: theorem top_rpow_def (y : ℝ) : (⊤ : ℝ≥0∞) ^ y = if 0 < y then ⊤ else if y = 0 then 1 else 0 
goal: ⊤ ^ y = if 0 < y then ⊤ else if y = 0 then 1 else 0

full_name: ENNReal.top_rpow_of_pos
code: @[simp]
theorem top_rpow_of_pos {y : ℝ} (h : 0 < y) : (⊤ : ℝ≥0∞) ^ y = ⊤ 
goal: ⊤ ^ y = ⊤

full_name: ENNReal.top_rpow_of_neg
code: @[simp]
theorem top_rpow_of_neg {y : ℝ} (h : y < 0) : (⊤ : ℝ≥0∞) ^ y = 0 
goal: ⊤ ^ y = 0

full_name: ENNReal.zero_rpow_of_pos
code: @[simp]
theorem zero_rpow_of_pos {y : ℝ} (h : 0 < y) : (0 : ℝ≥0∞) ^ y = 0 
goal: 0 ^ y = 0

full_name: ENNReal.zero_rpow_of_neg
code: @[simp]
theorem zero_rpow_of_neg {y : ℝ} (h : y < 0) : (0 : ℝ≥0∞) ^ y = ⊤ 
goal: 0 ^ y = ⊤

full_name: ENNReal.zero_rpow_def
code: theorem zero_rpow_def (y : ℝ) : (0 : ℝ≥0∞) ^ y = if 0 < y then 0 else if y = 0 then 1 else ⊤ 
goal: 0 ^ y = if 0 < y then 0 else if y = 0 then 1 else ⊤

full_name: ENNReal.zero_rpow_mul_self
code: @[simp]
theorem zero_rpow_mul_self (y : ℝ) : (0 : ℝ≥0∞) ^ y * (0 : ℝ≥0∞) ^ y = (0 : ℝ≥0∞) ^ y 
goal: 0 ^ y * 0 ^ y = 0 ^ y

full_name: ENNReal.coe_rpow_of_ne_zero
code: @[norm_cast]
theorem coe_rpow_of_ne_zero {x : ℝ≥0} (h : x ≠ 0) (y : ℝ) : (x : ℝ≥0∞) ^ y = (x ^ y : ℝ≥0) 
goal: ↑x ^ y = ↑(x ^ y)

full_name: ENNReal.coe_rpow_of_nonneg
code: @[norm_cast]
theorem coe_rpow_of_nonneg (x : ℝ≥0) {y : ℝ} (h : 0 ≤ y) : (x : ℝ≥0∞) ^ y = (x ^ y : ℝ≥0) 
goal: ↑x ^ y = ↑(x ^ y)

full_name: ENNReal.coe_rpow_def
code: theorem coe_rpow_def (x : ℝ≥0) (y : ℝ) :
    (x : ℝ≥0∞) ^ y = if x = 0 ∧ y < 0 then ⊤ else ↑(x ^ y) 
goal: ↑x ^ y = if x = 0 ∧ y < 0 then ⊤ else ↑(x ^ y)

full_name: ENNReal.rpow_one
code: @[simp]
theorem rpow_one (x : ℝ≥0∞) : x ^ (1 : ℝ) = x 
goal: x ^ 1 = x

full_name: ENNReal.one_rpow
code: @[simp]
theorem one_rpow (x : ℝ) : (1 : ℝ≥0∞) ^ x = 1 
goal: 1 ^ x = 1

full_name: ENNReal.rpow_eq_zero_iff
code: @[simp]
theorem rpow_eq_zero_iff {x : ℝ≥0∞} {y : ℝ} : x ^ y = 0 ↔ x = 0 ∧ 0 < y ∨ x = ⊤ ∧ y < 0 
goal: x ^ y = 0 ↔ x = 0 ∧ 0 < y ∨ x = ⊤ ∧ y < 0

full_name: ENNReal.rpow_eq_zero_iff_of_pos
code: lemma rpow_eq_zero_iff_of_pos {x : ℝ≥0∞} {y : ℝ} (hy : 0 < y) : x ^ y = 0 ↔ x = 0 
goal: x ^ y = 0 ↔ x = 0

full_name: ENNReal.rpow_eq_top_iff
code: @[simp]
theorem rpow_eq_top_iff {x : ℝ≥0∞} {y : ℝ} : x ^ y = ⊤ ↔ x = 0 ∧ y < 0 ∨ x = ⊤ ∧ 0 < y 
goal: x ^ y = ⊤ ↔ x = 0 ∧ y < 0 ∨ x = ⊤ ∧ 0 < y

full_name: ENNReal.rpow_eq_top_iff_of_pos
code: theorem rpow_eq_top_iff_of_pos {x : ℝ≥0∞} {y : ℝ} (hy : 0 < y) : x ^ y = ⊤ ↔ x = ⊤ 
goal: x ^ y = ⊤ ↔ x = ⊤

full_name: ENNReal.rpow_lt_top_iff_of_pos
code: lemma rpow_lt_top_iff_of_pos {x : ℝ≥0∞} {y : ℝ} (hy : 0 < y) : x ^ y < ∞ ↔ x < ∞ 
goal: x ^ y < ⊤ ↔ x < ⊤

full_name: ENNReal.rpow_eq_top_of_nonneg
code: theorem rpow_eq_top_of_nonneg (x : ℝ≥0∞) {y : ℝ} (hy0 : 0 ≤ y) : x ^ y = ⊤ → x = ⊤ 
goal: x ^ y = ⊤ → x = ⊤

full_name: ENNReal.rpow_ne_top_of_nonneg
code: theorem rpow_ne_top_of_nonneg {x : ℝ≥0∞} {y : ℝ} (hy0 : 0 ≤ y) (h : x ≠ ⊤) : x ^ y ≠ ⊤ 
goal: x ^ y ≠ ⊤

full_name: ENNReal.rpow_lt_top_of_nonneg
code: theorem rpow_lt_top_of_nonneg {x : ℝ≥0∞} {y : ℝ} (hy0 : 0 ≤ y) (h : x ≠ ⊤) : x ^ y < ⊤ 
goal: x ^ y < ⊤

full_name: ENNReal.rpow_add
code: theorem rpow_add {x : ℝ≥0∞} (y z : ℝ) (hx : x ≠ 0) (h'x : x ≠ ⊤) : x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: ENNReal.rpow_add_of_nonneg
code: theorem rpow_add_of_nonneg {x : ℝ≥0∞} (y z : ℝ) (hy : 0 ≤ y) (hz : 0 ≤ z) :
    x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: ENNReal.rpow_neg
code: theorem rpow_neg (x : ℝ≥0∞) (y : ℝ) : x ^ (-y) = (x ^ y)⁻¹ 
goal: x ^ (-y) = (x ^ y)⁻¹

full_name: ENNReal.rpow_sub
code: theorem rpow_sub {x : ℝ≥0∞} (y z : ℝ) (hx : x ≠ 0) (h'x : x ≠ ⊤) : x ^ (y - z) = x ^ y / x ^ z 
goal: x ^ (y - z) = x ^ y / x ^ z

full_name: ENNReal.rpow_neg_one
code: theorem rpow_neg_one (x : ℝ≥0∞) : x ^ (-1 : ℝ) = x⁻¹ 
goal: x ^ (-1) = x⁻¹

full_name: ENNReal.rpow_mul
code: theorem rpow_mul (x : ℝ≥0∞) (y z : ℝ) : x ^ (y * z) = (x ^ y) ^ z 
goal: x ^ (y * z) = (x ^ y) ^ z

full_name: ENNReal.rpow_natCast
code: @[simp, norm_cast]
theorem rpow_natCast (x : ℝ≥0∞) (n : ℕ) : x ^ (n : ℝ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: ENNReal.rpow_ofNat
code: @[simp]
lemma rpow_ofNat (x : ℝ≥0∞) (n : ℕ) [n.AtLeastTwo] :
    x ^ (no_index (OfNat.ofNat n) : ℝ) = x ^ (OfNat.ofNat n) 
goal: x ^ OfNat.ofNat n = x ^ OfNat.ofNat n

full_name: ENNReal.rpow_intCast
code: @[simp, norm_cast]
lemma rpow_intCast (x : ℝ≥0∞) (n : ℤ) : x ^ (n : ℝ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: ENNReal.rpow_two
code: theorem rpow_two (x : ℝ≥0∞) : x ^ (2 : ℝ) = x ^ 2 
goal: x ^ 2 = x ^ 2

full_name: ENNReal.mul_rpow_eq_ite
code: theorem mul_rpow_eq_ite (x y : ℝ≥0∞) (z : ℝ) :
    (x * y) ^ z = if (x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0) ∧ z < 0 then ⊤ else x ^ z * y ^ z 
goal: (x * y) ^ z = if (x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0) ∧ z < 0 then ⊤ else x ^ z * y ^ z

full_name: ENNReal.mul_rpow_of_ne_top
code: theorem mul_rpow_of_ne_top {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) (z : ℝ) :
    (x * y) ^ z = x ^ z * y ^ z 
goal: (x * y) ^ z = x ^ z * y ^ z

full_name: ENNReal.coe_mul_rpow
code: @[norm_cast]
theorem coe_mul_rpow (x y : ℝ≥0) (z : ℝ) : ((x : ℝ≥0∞) * y) ^ z = (x : ℝ≥0∞) ^ z * (y : ℝ≥0∞) ^ z 
goal: (↑x * ↑y) ^ z = ↑x ^ z * ↑y ^ z

full_name: ENNReal.prod_coe_rpow
code: theorem prod_coe_rpow {ι} (s : Finset ι) (f : ι → ℝ≥0) (r : ℝ) :
    ∏ i ∈ s, (f i : ℝ≥0∞) ^ r = ((∏ i ∈ s, f i : ℝ≥0) : ℝ≥0∞) ^ r 
goal: ∏ i ∈ s, ↑(f i) ^ r = ↑(∏ i ∈ s, f i) ^ r

full_name: ENNReal.mul_rpow_of_ne_zero
code: theorem mul_rpow_of_ne_zero {x y : ℝ≥0∞} (hx : x ≠ 0) (hy : y ≠ 0) (z : ℝ) :
    (x * y) ^ z = x ^ z * y ^ z 
goal: (x * y) ^ z = x ^ z * y ^ z

full_name: ENNReal.mul_rpow_of_nonneg
code: theorem mul_rpow_of_nonneg (x y : ℝ≥0∞) {z : ℝ} (hz : 0 ≤ z) : (x * y) ^ z = x ^ z * y ^ z 
goal: (x * y) ^ z = x ^ z * y ^ z

full_name: ENNReal.prod_rpow_of_ne_top
code: theorem prod_rpow_of_ne_top {ι} {s : Finset ι} {f : ι → ℝ≥0∞} (hf : ∀ i ∈ s, f i ≠ ∞) (r : ℝ) :
    ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r 
goal: ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r

full_name: ENNReal.prod_rpow_of_nonneg
code: theorem prod_rpow_of_nonneg {ι} {s : Finset ι} {f : ι → ℝ≥0∞} {r : ℝ} (hr : 0 ≤ r) :
    ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r 
goal: ∏ i ∈ s, f i ^ r = (∏ i ∈ s, f i) ^ r

full_name: ENNReal.inv_rpow
code: theorem inv_rpow (x : ℝ≥0∞) (y : ℝ) : x⁻¹ ^ y = (x ^ y)⁻¹ 
goal: x⁻¹ ^ y = (x ^ y)⁻¹

full_name: ENNReal.div_rpow_of_nonneg
code: theorem div_rpow_of_nonneg (x y : ℝ≥0∞) {z : ℝ} (hz : 0 ≤ z) : (x / y) ^ z = x ^ z / y ^ z 
goal: (x / y) ^ z = x ^ z / y ^ z

full_name: ENNReal.strictMono_rpow_of_pos
code: theorem strictMono_rpow_of_pos {z : ℝ} (h : 0 < z) : StrictMono fun x : ℝ≥0∞ => x ^ z 
goal: StrictMono fun x => x ^ z

full_name: ENNReal.monotone_rpow_of_nonneg
code: theorem monotone_rpow_of_nonneg {z : ℝ} (h : 0 ≤ z) : Monotone fun x : ℝ≥0∞ => x ^ z 
goal: Monotone fun x => x ^ z

full_name: ENNReal.orderIsoRpow
code: /-- Bundles `fun x : ℝ≥0∞ => x ^ y` into an order isomorphism when `y : ℝ` is positive,
where the inverse is `fun x : ℝ≥0∞ => x ^ (1 / y)`. -/
@[simps! apply]
def orderIsoRpow (y : ℝ) (hy : 0 < y) : ℝ≥0∞ ≃o ℝ≥0∞ 
goal: ℝ≥0∞ ≃o ℝ≥0∞

full_name: ENNReal.orderIsoRpow_apply
code: /-- Bundles `fun x : ℝ≥0∞ => x ^ y` into an order isomorphism when `y : ℝ` is positive,
where the inverse is `fun x : ℝ≥0∞ => x ^ (1 / y)`. -/
@[simps! apply]
def orderIsoRpow (y : ℝ) (hy : 0 < y) : ℝ≥0∞ ≃o ℝ≥0∞ 
goal: (ENNReal.orderIsoRpow y hy) x = x ^ y

full_name: ENNReal.orderIsoRpow_symm_apply
code: theorem orderIsoRpow_symm_apply (y : ℝ) (hy : 0 < y) :
    (orderIsoRpow y hy).symm = orderIsoRpow (1 / y) (one_div_pos.2 hy) 
goal: (ENNReal.orderIsoRpow y hy).symm = ENNReal.orderIsoRpow (1 / y) ⋯

full_name: ENNReal.rpow_le_rpow
code: @[gcongr] theorem rpow_le_rpow {x y : ℝ≥0∞} {z : ℝ} (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z 
goal: x ^ z ≤ y ^ z

full_name: ENNReal.rpow_lt_rpow
code: @[gcongr] theorem rpow_lt_rpow {x y : ℝ≥0∞} {z : ℝ} (h₁ : x < y) (h₂ : 0 < z) : x ^ z < y ^ z 
goal: x ^ z < y ^ z

full_name: ENNReal.rpow_le_rpow_iff
code: theorem rpow_le_rpow_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ^ z ≤ y ^ z ↔ x ≤ y 
goal: x ^ z ≤ y ^ z ↔ x ≤ y

full_name: ENNReal.rpow_lt_rpow_iff
code: theorem rpow_lt_rpow_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ^ z < y ^ z ↔ x < y 
goal: x ^ z < y ^ z ↔ x < y

full_name: ENNReal.le_rpow_inv_iff
code: theorem le_rpow_inv_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y 
goal: x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y

full_name: ENNReal.le_rpow_one_div_iff
code: @[deprecated le_rpow_inv_iff (since := "2024-07-10")]
theorem le_rpow_one_div_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ≤ y ^ (1 / z) ↔ x ^ z ≤ y 
goal: x ≤ y ^ (1 / z) ↔ x ^ z ≤ y

full_name: ENNReal.rpow_inv_lt_iff
code: theorem rpow_inv_lt_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ^ z⁻¹ < y ↔ x < y ^ z 
goal: x ^ z⁻¹ < y ↔ x < y ^ z

full_name: ENNReal.lt_rpow_inv_iff
code: theorem lt_rpow_inv_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x < y ^ z⁻¹ ↔ x ^ z < y 
goal: x < y ^ z⁻¹ ↔ x ^ z < y

full_name: ENNReal.lt_rpow_one_div_iff
code: @[deprecated lt_rpow_inv_iff (since := "2024-07-10")]
theorem lt_rpow_one_div_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x < y ^ (1 / z) ↔ x ^ z < y 
goal: x < y ^ (1 / z) ↔ x ^ z < y

full_name: ENNReal.rpow_inv_le_iff
code: theorem rpow_inv_le_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z 
goal: x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z

full_name: ENNReal.rpow_one_div_le_iff
code: @[deprecated rpow_inv_le_iff (since := "2024-07-10")]
theorem rpow_one_div_le_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ^ (1 / z) ≤ y ↔ x ≤ y ^ z 
goal: x ^ (1 / z) ≤ y ↔ x ≤ y ^ z

full_name: ENNReal.rpow_lt_rpow_of_exponent_lt
code: theorem rpow_lt_rpow_of_exponent_lt {x : ℝ≥0∞} {y z : ℝ} (hx : 1 < x) (hx' : x ≠ ⊤) (hyz : y < z) :
    x ^ y < x ^ z 
goal: x ^ y < x ^ z

full_name: ENNReal.rpow_le_rpow_of_exponent_le
code: @[gcongr] theorem rpow_le_rpow_of_exponent_le {x : ℝ≥0∞} {y z : ℝ} (hx : 1 ≤ x) (hyz : y ≤ z) :
    x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: ENNReal.rpow_lt_rpow_of_exponent_gt
code: theorem rpow_lt_rpow_of_exponent_gt {x : ℝ≥0∞} {y z : ℝ} (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) :
    x ^ y < x ^ z 
goal: x ^ y < x ^ z

full_name: ENNReal.rpow_le_rpow_of_exponent_ge
code: theorem rpow_le_rpow_of_exponent_ge {x : ℝ≥0∞} {y z : ℝ} (hx1 : x ≤ 1) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: ENNReal.rpow_le_self_of_le_one
code: theorem rpow_le_self_of_le_one {x : ℝ≥0∞} {z : ℝ} (hx : x ≤ 1) (h_one_le : 1 ≤ z) : x ^ z ≤ x 
goal: x ^ z ≤ x

full_name: ENNReal.le_rpow_self_of_one_le
code: theorem le_rpow_self_of_one_le {x : ℝ≥0∞} {z : ℝ} (hx : 1 ≤ x) (h_one_le : 1 ≤ z) : x ≤ x ^ z 
goal: x ≤ x ^ z

full_name: ENNReal.rpow_pos_of_nonneg
code: theorem rpow_pos_of_nonneg {p : ℝ} {x : ℝ≥0∞} (hx_pos : 0 < x) (hp_nonneg : 0 ≤ p) : 0 < x ^ p 
goal: 0 < x ^ p

full_name: ENNReal.rpow_pos
code: theorem rpow_pos {p : ℝ} {x : ℝ≥0∞} (hx_pos : 0 < x) (hx_ne_top : x ≠ ⊤) : 0 < x ^ p 
goal: 0 < x ^ p

full_name: ENNReal.rpow_lt_one
code: theorem rpow_lt_one {x : ℝ≥0∞} {z : ℝ} (hx : x < 1) (hz : 0 < z) : x ^ z < 1 
goal: x ^ z < 1

full_name: ENNReal.rpow_le_one
code: theorem rpow_le_one {x : ℝ≥0∞} {z : ℝ} (hx : x ≤ 1) (hz : 0 ≤ z) : x ^ z ≤ 1 
goal: x ^ z ≤ 1

full_name: ENNReal.rpow_lt_one_of_one_lt_of_neg
code: theorem rpow_lt_one_of_one_lt_of_neg {x : ℝ≥0∞} {z : ℝ} (hx : 1 < x) (hz : z < 0) : x ^ z < 1 
goal: x ^ z < 1

full_name: ENNReal.rpow_le_one_of_one_le_of_neg
code: theorem rpow_le_one_of_one_le_of_neg {x : ℝ≥0∞} {z : ℝ} (hx : 1 ≤ x) (hz : z < 0) : x ^ z ≤ 1 
goal: x ^ z ≤ 1

full_name: ENNReal.one_lt_rpow
code: theorem one_lt_rpow {x : ℝ≥0∞} {z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z 
goal: 1 < x ^ z

full_name: ENNReal.one_le_rpow
code: theorem one_le_rpow {x : ℝ≥0∞} {z : ℝ} (hx : 1 ≤ x) (hz : 0 < z) : 1 ≤ x ^ z 
goal: 1 ≤ x ^ z

full_name: ENNReal.one_lt_rpow_of_pos_of_lt_one_of_neg
code: theorem one_lt_rpow_of_pos_of_lt_one_of_neg {x : ℝ≥0∞} {z : ℝ} (hx1 : 0 < x) (hx2 : x < 1)
    (hz : z < 0) : 1 < x ^ z 
goal: 1 < x ^ z

full_name: ENNReal.one_le_rpow_of_pos_of_le_one_of_neg
code: theorem one_le_rpow_of_pos_of_le_one_of_neg {x : ℝ≥0∞} {z : ℝ} (hx1 : 0 < x) (hx2 : x ≤ 1)
    (hz : z < 0) : 1 ≤ x ^ z 
goal: 1 ≤ x ^ z

full_name: ENNReal.toNNReal_rpow
code: theorem toNNReal_rpow (x : ℝ≥0∞) (z : ℝ) : x.toNNReal ^ z = (x ^ z).toNNReal 
goal: x.toNNReal ^ z = (x ^ z).toNNReal

full_name: ENNReal.toReal_rpow
code: theorem toReal_rpow (x : ℝ≥0∞) (z : ℝ) : x.toReal ^ z = (x ^ z).toReal 
goal: x.toReal ^ z = (x ^ z).toReal

full_name: ENNReal.ofReal_rpow_of_pos
code: theorem ofReal_rpow_of_pos {x p : ℝ} (hx_pos : 0 < x) :
    ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p) 
goal: ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

full_name: ENNReal.ofReal_rpow_of_nonneg
code: theorem ofReal_rpow_of_nonneg {x p : ℝ} (hx_nonneg : 0 ≤ x) (hp_nonneg : 0 ≤ p) :
    ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p) 
goal: ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

full_name: ENNReal.rpow_rpow_inv
code: @[simp] lemma rpow_rpow_inv {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0∞) : (x ^ y) ^ y⁻¹ = x 
goal: (x ^ y) ^ y⁻¹ = x

full_name: ENNReal.rpow_inv_rpow
code: @[simp] lemma rpow_inv_rpow {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0∞) : (x ^ y⁻¹) ^ y = x 
goal: (x ^ y⁻¹) ^ y = x

full_name: ENNReal.pow_rpow_inv_natCast
code: lemma pow_rpow_inv_natCast {n : ℕ} (hn : n ≠ 0) (x : ℝ≥0∞) : (x ^ n) ^ (n⁻¹ : ℝ) = x 
goal: (x ^ n) ^ (↑n)⁻¹ = x

full_name: ENNReal.rpow_inv_natCast_pow
code: lemma rpow_inv_natCast_pow {n : ℕ} (hn : n ≠ 0) (x : ℝ≥0∞) : (x ^ (n⁻¹ : ℝ)) ^ n = x 
goal: (x ^ (↑n)⁻¹) ^ n = x

full_name: ENNReal.rpow_natCast_mul
code: lemma rpow_natCast_mul (x : ℝ≥0∞) (n : ℕ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z 
goal: x ^ (↑n * z) = (x ^ n) ^ z

full_name: ENNReal.rpow_mul_natCast
code: lemma rpow_mul_natCast (x : ℝ≥0∞) (y : ℝ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n 
goal: x ^ (y * ↑n) = (x ^ y) ^ n

full_name: ENNReal.rpow_intCast_mul
code: lemma rpow_intCast_mul (x : ℝ≥0∞) (n : ℤ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z 
goal: x ^ (↑n * z) = (x ^ n) ^ z

full_name: ENNReal.rpow_mul_intCast
code: lemma rpow_mul_intCast (x : ℝ≥0∞) (y : ℝ) (n : ℤ) : x ^ (y * n) = (x ^ y) ^ n 
goal: x ^ (y * ↑n) = (x ^ y) ^ n

full_name: ENNReal.rpow_left_injective
code: lemma rpow_left_injective {x : ℝ} (hx : x ≠ 0) : Injective fun y : ℝ≥0∞ ↦ y ^ x 
goal: Function.Injective fun y => y ^ x

full_name: ENNReal.rpow_left_surjective
code: theorem rpow_left_surjective {x : ℝ} (hx : x ≠ 0) : Function.Surjective fun y : ℝ≥0∞ => y ^ x 
goal: Function.Surjective fun y => y ^ x

full_name: ENNReal.rpow_left_bijective
code: theorem rpow_left_bijective {x : ℝ} (hx : x ≠ 0) : Function.Bijective fun y : ℝ≥0∞ => y ^ x 
goal: Function.Bijective fun y => y ^ x