Theorem: Ordinal.mul_eq_opow_log_succ
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: apply le_antisymm
state_before: a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
⊢ a * b = b ^ succ (log b a)

tactic: have hbl := principal_mul_isLimit hb₂ hb
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
⊢ a * b ≤ b ^ succ (log b a)

tactic: have := IsNormal.bsup_eq.{u, u} (mul_isNormal (Ordinal.pos_iff_ne_zero.2 ha)) hbl
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
⊢ a * b ≤ b ^ succ (log b a)

tactic: dsimp at this
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => (fun x x_2 => x * x_2) a x) = (fun x x_1 => x * x_1) a b
⊢ a * b ≤ b ^ succ (log b a)

tactic: rw [← this, bsup_le_iff]
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
⊢ a * b ≤ b ^ succ (log b a)

tactic: intro c hcb
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
⊢ ∀ (i : Ordinal), i < b → a * i ≤ b ^ succ (log b a)

tactic: have hb₁ : 1 < b := (lt_succ 1).trans (by simpa using hb₂)
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
⊢ a * c ≤ b ^ succ (log b a)

tactic: have hbo₀ : (b^b.log a) ≠ 0 := Ordinal.pos_iff_ne_zero.1 (opow_pos _ (zero_lt_one.trans hb₁))
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
hb₁ : 1 < b
⊢ a * c ≤ b ^ succ (log b a)

tactic: apply le_trans (mul_le_mul_right' (le_of_lt (lt_mul_succ_div a hbo₀)) c)
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ a * c ≤ b ^ succ (log b a)

tactic: rw [mul_assoc, opow_succ]
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ b ^ log b a * succ (a / b ^ log b a) * c ≤ b ^ succ (log b a)

tactic: refine' mul_le_mul_left' (le_of_lt (hb (hbl.2 _ _) hcb)) _
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ b ^ log b a * (succ (a / b ^ log b a) * c) ≤ b ^ log b a * b

tactic: rw [div_lt hbo₀, ← opow_succ]
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ a / b ^ log b a < b

tactic: exact lt_opow_succ_log_self hb₁ _
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ a < b ^ succ (log b a)

tactic: simpa using hb₂
state_before: a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : IsLimit b
this : (bsup b fun x x_1 => a * x) = a * b
c : Ordinal
hcb : c < b
⊢ succ 1 < b

tactic: rw [opow_succ]
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
⊢ b ^ succ (log b a) ≤ a * b

tactic: exact mul_le_mul_right' (opow_log_le_self b ha) b
state_before: case a
a b : Ordinal
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
⊢ b ^ log b a * b ≤ a * b