Theorem: Nat.getLast_digit_ne_zero
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases b with (_ | _ | b)
state_before: n b m : ℕ
hm : m ≠ 0
⊢ (b.digits m).getLast ⋯ ≠ 0
state_after: case zero
n m : ℕ
hm : m ≠ 0
⊢ (digits 0 m).getLast ⋯ ≠ 0

case succ.zero
n m : ℕ
hm : m ≠ 0
⊢ ((0 + 1).digits m).getLast ⋯ ≠ 0

case succ.succ
n m : ℕ
hm : m ≠ 0
b : ℕ
⊢ ((b + 1 + 1).digits m).getLast ⋯ ≠ 0

tactic: revert hm
state_before: case succ.succ
n m : ℕ
hm : m ≠ 0
b : ℕ
⊢ ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
state_after: case succ.succ
n m b : ℕ
⊢ ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0

tactic: apply Nat.strongInductionOn m
state_before: case succ.succ
n m b : ℕ
⊢ ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
state_after: case succ.succ
n m b : ℕ
⊢ ∀ (n : ℕ),
    (∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0) →
      ∀ (hm : n ≠ 0), ((b + 1 + 1).digits n).getLast ⋯ ≠ 0

tactic: intro n IH hn
state_before: case succ.succ
n m b : ℕ
⊢ ∀ (n : ℕ),
    (∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0) →
      ∀ (hm : n ≠ 0), ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
state_after: case succ.succ
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0

tactic: by_cases hnb : n < b + 2
state_before: case succ.succ
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
state_after: case pos
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : n < b + 2
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0

case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0

tactic: cases m
state_before: case zero
n m : ℕ
hm : m ≠ 0
⊢ (digits 0 m).getLast ⋯ ≠ 0
state_after: case zero.zero
n : ℕ
hm : 0 ≠ 0
⊢ (digits 0 0).getLast ⋯ ≠ 0

case zero.succ
n n✝ : ℕ
hm : n✝ + 1 ≠ 0
⊢ (digits 0 (n✝ + 1)).getLast ⋯ ≠ 0

tactic: cases hm rfl
state_before: case zero.zero
n : ℕ
hm : 0 ≠ 0
⊢ (digits 0 0).getLast ⋯ ≠ 0
state_after: no goals

tactic: simp
state_before: case zero.succ
n n✝ : ℕ
hm : n✝ + 1 ≠ 0
⊢ (digits 0 (n✝ + 1)).getLast ⋯ ≠ 0
state_after: no goals

tactic: cases m
state_before: case succ.zero
n m : ℕ
hm : m ≠ 0
⊢ ((0 + 1).digits m).getLast ⋯ ≠ 0
state_after: case succ.zero.zero
n : ℕ
hm : 0 ≠ 0
⊢ ((0 + 1).digits 0).getLast ⋯ ≠ 0

case succ.zero.succ
n n✝ : ℕ
hm : n✝ + 1 ≠ 0
⊢ ((0 + 1).digits (n✝ + 1)).getLast ⋯ ≠ 0

tactic: rename ℕ => m
state_before: case succ.zero.succ
n n✝ : ℕ
hm : n✝ + 1 ≠ 0
⊢ ((0 + 1).digits (n✝ + 1)).getLast ⋯ ≠ 0
state_after: case succ.zero.succ
n m : ℕ
hm : m + 1 ≠ 0
⊢ ((0 + 1).digits (m + 1)).getLast ⋯ ≠ 0

tactic: simp only [zero_add, digits_one, List.getLast_replicate_succ m 1]
state_before: case succ.zero.succ
n m : ℕ
hm : m + 1 ≠ 0
⊢ ((0 + 1).digits (m + 1)).getLast ⋯ ≠ 0
state_after: case succ.zero.succ
n m : ℕ
hm : m + 1 ≠ 0
⊢ 1 ≠ 0

tactic: exact Nat.one_ne_zero
state_before: case succ.zero.succ
n m : ℕ
hm : m + 1 ≠ 0
⊢ 1 ≠ 0
state_after: no goals

tactic: cases hm rfl
state_before: case succ.zero.zero
n : ℕ
hm : 0 ≠ 0
⊢ ((0 + 1).digits 0).getLast ⋯ ≠ 0
state_after: no goals

tactic: simpa only [digits_of_lt (b + 2) n hn hnb]
state_before: case pos
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : n < b + 2
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
state_after: no goals

tactic: rw [digits_getLast n (le_add_left 2 b)]
state_before: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
state_after: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ ((b + 2).digits (n / (b + 2))).getLast ?neg.q✝ ≠ 0

case neg.q
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ (b + 2).digits (n / (b + 2)) ≠ []

tactic: refine IH _ (Nat.div_lt_self hn.bot_lt (one_lt_succ_succ b)) ?_
state_before: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ ((b + 2).digits (n / (b + 2))).getLast ?neg.q✝ ≠ 0

case neg.q
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ (b + 2).digits (n / (b + 2)) ≠ []
state_after: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ n / b.succ.succ ≠ 0

tactic: rw [← pos_iff_ne_zero]
state_before: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ n / b.succ.succ ≠ 0
state_after: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ 0 < n / b.succ.succ

tactic: exact Nat.div_pos (le_of_not_lt hnb) (zero_lt_succ (succ b))
state_before: case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ 0 < n / b.succ.succ
state_after: no goals