File: Mathlib/SetTheory/Ordinal/Exponential.lean

full_name: Ordinal.pow
code: /-- The ordinal exponential, defined by transfinite recursion. -/
instance pow : Pow Ordinal Ordinal 
goal: Pow Ordinal.{u} Ordinal.{u}

full_name: Ordinal.opow_def
code: theorem opow_def (a b : Ordinal) :
    a ^ b = if a = 0 then 1 - b else limitRecOn b 1 (fun _ IH => IH * a) fun b _ => bsup.{u, u} b 
goal: a ^ b = if a = 0 then 1 - b else b.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup

full_name: Ordinal.zero_opow'
code: theorem zero_opow' (a : Ordinal) : 0 ^ a = 1 - a 
goal: 0 ^ a = 1 - a

full_name: Ordinal.zero_opow
code: @[simp]
theorem zero_opow {a : Ordinal} (a0 : a ≠ 0) : (0 : Ordinal) ^ a = 0 
goal: 0 ^ a = 0

full_name: Ordinal.opow_zero
code: @[simp]
theorem opow_zero (a : Ordinal) : a ^ (0 : Ordinal) = 1 
goal: a ^ 0 = 1

full_name: Ordinal.opow_succ
code: @[simp]
theorem opow_succ (a b : Ordinal) : a ^ succ b = a ^ b * a 
goal: a ^ Order.succ b = a ^ b * a

full_name: Ordinal.opow_limit
code: theorem opow_limit {a b : Ordinal} (a0 : a ≠ 0) (h : IsLimit b) :
    a ^ b = bsup.{u, u} b fun c _ => a ^ c 
goal: a ^ b = b.bsup fun c x => a ^ c

full_name: Ordinal.opow_le_of_limit
code: theorem opow_le_of_limit {a b c : Ordinal} (a0 : a ≠ 0) (h : IsLimit b) :
    a ^ b ≤ c ↔ ∀ b' < b, a ^ b' ≤ c 
goal: a ^ b ≤ c ↔ ∀ b' < b, a ^ b' ≤ c

full_name: Ordinal.lt_opow_of_limit
code: theorem lt_opow_of_limit {a b c : Ordinal} (b0 : b ≠ 0) (h : IsLimit c) :
    a < b ^ c ↔ ∃ c' < c, a < b ^ c' 
goal: a < b ^ c ↔ ∃ c' < c, a < b ^ c'

full_name: Ordinal.opow_one
code: @[simp]
theorem opow_one (a : Ordinal) : a ^ (1 : Ordinal) = a 
goal: a ^ 1 = a

full_name: Ordinal.one_opow
code: @[simp]
theorem one_opow (a : Ordinal) : (1 : Ordinal) ^ a = 1 
goal: 1 ^ a = 1

full_name: Ordinal.opow_pos
code: theorem opow_pos {a : Ordinal} (b : Ordinal) (a0 : 0 < a) : 0 < a ^ b 
goal: 0 < a ^ b

full_name: Ordinal.opow_ne_zero
code: theorem opow_ne_zero {a : Ordinal} (b : Ordinal) (a0 : a ≠ 0) : a ^ b ≠ 0 
goal: a ^ b ≠ 0

full_name: Ordinal.opow_isNormal
code: theorem opow_isNormal {a : Ordinal} (h : 1 < a) : IsNormal (a ^ ·) 
goal: Ordinal.IsNormal fun x => a ^ x

full_name: Ordinal.opow_lt_opow_iff_right
code: theorem opow_lt_opow_iff_right {a b c : Ordinal} (a1 : 1 < a) : a ^ b < a ^ c ↔ b < c 
goal: a ^ b < a ^ c ↔ b < c

full_name: Ordinal.opow_le_opow_iff_right
code: theorem opow_le_opow_iff_right {a b c : Ordinal} (a1 : 1 < a) : a ^ b ≤ a ^ c ↔ b ≤ c 
goal: a ^ b ≤ a ^ c ↔ b ≤ c

full_name: Ordinal.opow_right_inj
code: theorem opow_right_inj {a b c : Ordinal} (a1 : 1 < a) : a ^ b = a ^ c ↔ b = c 
goal: a ^ b = a ^ c ↔ b = c

full_name: Ordinal.opow_isLimit
code: theorem opow_isLimit {a b : Ordinal} (a1 : 1 < a) : IsLimit b → IsLimit (a ^ b) 
goal: b.IsLimit → (a ^ b).IsLimit

full_name: Ordinal.opow_isLimit_left
code: theorem opow_isLimit_left {a b : Ordinal} (l : IsLimit a) (hb : b ≠ 0) : IsLimit (a ^ b) 
goal: (a ^ b).IsLimit

full_name: Ordinal.opow_le_opow_right
code: theorem opow_le_opow_right {a b c : Ordinal} (h₁ : 0 < a) (h₂ : b ≤ c) : a ^ b ≤ a ^ c 
goal: a ^ b ≤ a ^ c

full_name: Ordinal.opow_le_opow_left
code: theorem opow_le_opow_left {a b : Ordinal} (c : Ordinal) (ab : a ≤ b) : a ^ c ≤ b ^ c 
goal: a ^ c ≤ b ^ c

full_name: Ordinal.left_le_opow
code: theorem left_le_opow (a : Ordinal) {b : Ordinal} (b1 : 0 < b) : a ≤ a ^ b 
goal: a ≤ a ^ b

full_name: Ordinal.right_le_opow
code: theorem right_le_opow {a : Ordinal} (b : Ordinal) (a1 : 1 < a) : b ≤ a ^ b 
goal: b ≤ a ^ b

full_name: Ordinal.opow_lt_opow_left_of_succ
code: theorem opow_lt_opow_left_of_succ {a b c : Ordinal} (ab : a < b) : a ^ succ c < b ^ succ c 
goal: a ^ Order.succ c < b ^ Order.succ c

full_name: Ordinal.opow_add
code: theorem opow_add (a b c : Ordinal) : a ^ (b + c) = a ^ b * a ^ c 
goal: a ^ (b + c) = a ^ b * a ^ c

full_name: Ordinal.opow_one_add
code: theorem opow_one_add (a b : Ordinal) : a ^ (1 + b) = a * a ^ b 
goal: a ^ (1 + b) = a * a ^ b

full_name: Ordinal.opow_dvd_opow
code: theorem opow_dvd_opow (a : Ordinal) {b c : Ordinal} (h : b ≤ c) : a ^ b ∣ a ^ c 
goal: a ^ b ∣ a ^ c

full_name: Ordinal.opow_dvd_opow_iff
code: theorem opow_dvd_opow_iff {a b c : Ordinal} (a1 : 1 < a) : a ^ b ∣ a ^ c ↔ b ≤ c 
goal: a ^ b ∣ a ^ c ↔ b ≤ c

full_name: Ordinal.opow_mul
code: theorem opow_mul (a b c : Ordinal) : a ^ (b * c) = (a ^ b) ^ c 
goal: a ^ (b * c) = (a ^ b) ^ c

full_name: Ordinal.log
code: /-- The ordinal logarithm is the solution `u` to the equation `x = b ^ u * v + w` where `v < b` and
    `w < b ^ u`. -/
@[pp_nodot]
def log (b : Ordinal) (x : Ordinal) : Ordinal 
goal: Ordinal.{u_1}

full_name: Ordinal.log_nonempty
code: /-- The set in the definition of `log` is nonempty. -/
theorem log_nonempty {b x : Ordinal} (h : 1 < b) : { o : Ordinal | x < b ^ o }.Nonempty 
goal: {o | x < b ^ o}.Nonempty

full_name: Ordinal.log_def
code: theorem log_def {b : Ordinal} (h : 1 < b) (x : Ordinal) :
    log b x = pred (sInf { o | x < b ^ o }) 
goal: Ordinal.log b x = (sInf {o | x < b ^ o}).pred

full_name: Ordinal.log_of_not_one_lt_left
code: theorem log_of_not_one_lt_left {b : Ordinal} (h : ¬1 < b) (x : Ordinal) : log b x = 0 
goal: Ordinal.log b x = 0

full_name: Ordinal.log_of_left_le_one
code: theorem log_of_left_le_one {b : Ordinal} (h : b ≤ 1) : ∀ x, log b x = 0 
goal: Ordinal.log b x = 0

full_name: Ordinal.log_zero_left
code: @[simp]
theorem log_zero_left : ∀ b, log 0 b = 0 
goal: Ordinal.log 0 b = 0

full_name: Ordinal.log_zero_right
code: @[simp]
theorem log_zero_right (b : Ordinal) : log b 0 = 0 
goal: Ordinal.log b 0 = 0

full_name: Ordinal.log_one_left
code: @[simp]
theorem log_one_left : ∀ b, log 1 b = 0 
goal: Ordinal.log 1 b = 0

full_name: Ordinal.succ_log_def
code: theorem succ_log_def {b x : Ordinal} (hb : 1 < b) (hx : x ≠ 0) :
    succ (log b x) = sInf { o : Ordinal | x < b ^ o } 
goal: Order.succ (Ordinal.log b x) = sInf {o | x < b ^ o}

full_name: Ordinal.lt_opow_succ_log_self
code: theorem lt_opow_succ_log_self {b : Ordinal} (hb : 1 < b) (x : Ordinal) :
    x < b ^ succ (log b x) 
goal: x < b ^ Order.succ (Ordinal.log b x)

full_name: Ordinal.opow_log_le_self
code: theorem opow_log_le_self (b : Ordinal) {x : Ordinal} (hx : x ≠ 0) : b ^ log b x ≤ x 
goal: b ^ Ordinal.log b x ≤ x

full_name: Ordinal.opow_le_iff_le_log
code: /-- `opow b` and `log b` (almost) form a Galois connection. -/
theorem opow_le_iff_le_log {b x c : Ordinal} (hb : 1 < b) (hx : x ≠ 0) : b ^ c ≤ x ↔ c ≤ log b x 
goal: b ^ c ≤ x ↔ c ≤ Ordinal.log b x

full_name: Ordinal.lt_opow_iff_log_lt
code: theorem lt_opow_iff_log_lt {b x c : Ordinal} (hb : 1 < b) (hx : x ≠ 0) : x < b ^ c ↔ log b x < c 
goal: x < b ^ c ↔ Ordinal.log b x < c

full_name: Ordinal.log_pos
code: theorem log_pos {b o : Ordinal} (hb : 1 < b) (ho : o ≠ 0) (hbo : b ≤ o) : 0 < log b o 
goal: 0 < Ordinal.log b o

full_name: Ordinal.log_eq_zero
code: theorem log_eq_zero {b o : Ordinal} (hbo : o < b) : log b o = 0 
goal: Ordinal.log b o = 0

full_name: Ordinal.log_mono_right
code: @[mono]
theorem log_mono_right (b : Ordinal) {x y : Ordinal} (xy : x ≤ y) : log b x ≤ log b y 
goal: Ordinal.log b x ≤ Ordinal.log b y

full_name: Ordinal.log_le_self
code: theorem log_le_self (b x : Ordinal) : log b x ≤ x 
goal: Ordinal.log b x ≤ x

full_name: Ordinal.log_one_right
code: @[simp]
theorem log_one_right (b : Ordinal) : log b 1 = 0 
goal: Ordinal.log b 1 = 0

full_name: Ordinal.mod_opow_log_lt_self
code: theorem mod_opow_log_lt_self (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : o % (b ^ log b o) < o 
goal: o % b ^ Ordinal.log b o < o

full_name: Ordinal.log_mod_opow_log_lt_log_self
code: theorem log_mod_opow_log_lt_log_self {b o : Ordinal} (hb : 1 < b) (ho : o ≠ 0) (hbo : b ≤ o) :
    log b (o % (b ^ log b o)) < log b o 
goal: Ordinal.log b (o % b ^ Ordinal.log b o) < Ordinal.log b o

full_name: Ordinal.opow_mul_add_pos
code: theorem opow_mul_add_pos {b v : Ordinal} (hb : b ≠ 0) (u : Ordinal) (hv : v ≠ 0) (w : Ordinal) :
    0 < b ^ u * v + w 
goal: 0 < b ^ u * v + w

full_name: Ordinal.opow_mul_add_lt_opow_mul_succ
code: theorem opow_mul_add_lt_opow_mul_succ {b u w : Ordinal} (v : Ordinal) (hw : w < b ^ u) :
    b ^ u * v + w < b ^ u * succ v 
goal: b ^ u * v + w < b ^ u * Order.succ v

full_name: Ordinal.opow_mul_add_lt_opow_succ
code: theorem opow_mul_add_lt_opow_succ {b u v w : Ordinal} (hvb : v < b) (hw : w < b ^ u) :
    b ^ u * v + w < b ^ succ u 
goal: b ^ u * v + w < b ^ Order.succ u

full_name: Ordinal.log_opow_mul_add
code: theorem log_opow_mul_add {b u v w : Ordinal} (hb : 1 < b) (hv : v ≠ 0) (hvb : v < b)
    (hw : w < b ^ u) : log b (b ^ u * v + w) = u 
goal: Ordinal.log b (b ^ u * v + w) = u

full_name: Ordinal.log_opow
code: theorem log_opow {b : Ordinal} (hb : 1 < b) (x : Ordinal) : log b (b ^ x) = x 
goal: Ordinal.log b (b ^ x) = x

full_name: Ordinal.div_opow_log_pos
code: theorem div_opow_log_pos (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : 0 < o / (b ^ log b o) 
goal: 0 < o / b ^ Ordinal.log b o

full_name: Ordinal.div_opow_log_lt
code: theorem div_opow_log_lt {b : Ordinal} (o : Ordinal) (hb : 1 < b) : o / (b ^ log b o) < b 
goal: o / b ^ Ordinal.log b o < b

full_name: Ordinal.add_log_le_log_mul
code: theorem add_log_le_log_mul {x y : Ordinal} (b : Ordinal) (hx : x ≠ 0) (hy : y ≠ 0) :
    log b x + log b y ≤ log b (x * y) 
goal: Ordinal.log b x + Ordinal.log b y ≤ Ordinal.log b (x * y)

full_name: Ordinal.natCast_opow
code: @[simp, norm_cast]
theorem natCast_opow (m : ℕ) : ∀ n : ℕ, ↑(m ^ n : ℕ) = (m : Ordinal) ^ (n : Ordinal)
  
goal: ↑(m ^ n) = ↑m ^ ↑n

full_name: Ordinal.sup_opow_nat
code: theorem sup_opow_nat {o : Ordinal} (ho : 0 < o) : (sup fun n : ℕ => o ^ (n : Ordinal)) = o ^ ω 
goal: (Ordinal.sup fun n => o ^ ↑n) = o ^ ω