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

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

case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
⊢ b ^ succ (log b a) ≤ a * b

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

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

tactic: intro c hcb
state_before: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
⊢ ∀ i < b, a * i ≤ b ^ succ (log b a)
state_after: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
⊢ a * c ≤ 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.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
⊢ a * c ≤ b ^ succ (log b a)
state_after: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
hb₁ : 1 < 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.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
hb₁ : 1 < b
⊢ a * c ≤ b ^ succ (log b a)
state_after: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ 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.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ a * c ≤ b ^ succ (log b a)
state_after: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
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: rw [mul_assoc, opow_succ]
state_before: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
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)
state_after: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
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: refine mul_le_mul_left' (le_of_lt (hb (hbl.2 _ ?_) hcb)) _
state_before: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
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
state_after: case a
a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
hb₁ : 1 < b
hbo₀ : b ^ log b a ≠ 0
⊢ a / b ^ log b a < b

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

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

tactic: simpa using hb₂
state_before: a b : Ordinal.{u}
ha : a ≠ 0
hb : Principal (fun x x_1 => x * x_1) b
hb₂ : 2 < b
hbl : b.IsLimit
c : Ordinal.{u}
hcb : c < b
⊢ succ 1 < b
state_after: no goals

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

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