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
⊢ List.getLast (digits b m) (_ : digits b m ≠ []) ≠ 0

tactic: revert hm
state_before: case succ.succ
n m : ℕ
hm : m ≠ 0
b : ℕ
⊢ List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0

tactic: apply Nat.strongInductionOn m
state_before: case succ.succ
n m b : ℕ
⊢ ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0

tactic: intro n IH hn
state_before: case succ.succ
n m b : ℕ
⊢ ∀ (n : ℕ),
    (∀ (m : ℕ),
        m < n → ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0) →
      ∀ (hm : n ≠ 0), List.getLast (digits (succ (succ b)) n) (_ : digits (succ (succ b)) n ≠ []) ≠ 0

tactic: by_cases hnb : n < b + 2
state_before: case succ.succ
n✝ m b n : ℕ
IH : ∀ (m : ℕ), m < n → ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0
hn : n ≠ 0
⊢ List.getLast (digits (succ (succ b)) n) (_ : digits (succ (succ b)) n ≠ []) ≠ 0

tactic: cases m
state_before: case zero
n m : ℕ
hm : m ≠ 0
⊢ List.getLast (digits zero m) (_ : digits zero m ≠ []) ≠ 0

tactic: cases hm rfl
state_before: case zero.zero
n : ℕ
hm : zero ≠ 0
⊢ List.getLast (digits zero zero) (_ : digits zero zero ≠ []) ≠ 0

tactic: simp
state_before: case zero.succ
n n✝ : ℕ
hm : succ n✝ ≠ 0
⊢ List.getLast (digits zero (succ n✝)) (_ : digits zero (succ n✝) ≠ []) ≠ 0

tactic: cases m
state_before: case succ.zero
n m : ℕ
hm : m ≠ 0
⊢ List.getLast (digits (succ zero) m) (_ : digits (succ zero) m ≠ []) ≠ 0

tactic: rename ℕ => m
state_before: case succ.zero.succ
n n✝ : ℕ
hm : succ n✝ ≠ 0
⊢ List.getLast (digits (succ zero) (succ n✝)) (_ : digits (succ zero) (succ n✝) ≠ []) ≠ 0

tactic: have : ∀ v, List.getLast (digits (succ zero) (succ v)) (by simp [digits, digitsAux1]) = 1 := by
  intros v; induction v <;> simp; assumption
state_before: case succ.zero.succ
n m : ℕ
hm : succ m ≠ 0
⊢ List.getLast (digits (succ zero) (succ m)) (_ : digits (succ zero) (succ m) ≠ []) ≠ 0

tactic: simp only [digits_one, List.getLast_replicate_succ m 1, this]
state_before: case succ.zero.succ
n m : ℕ
hm : succ m ≠ 0
this : ∀ (v : ℕ), List.getLast (digits (succ zero) (succ v)) (_ : ¬1 :: List.replicate v 1 = []) = 1
⊢ List.getLast (digits (succ zero) (succ m)) (_ : digits (succ zero) (succ m) ≠ []) ≠ 0

tactic: cases hm rfl
state_before: case succ.zero.zero
n : ℕ
hm : zero ≠ 0
⊢ List.getLast (digits (succ zero) zero) (_ : digits (succ zero) zero ≠ []) ≠ 0

tactic: simp [digits, digitsAux1]
state_before: n m : ℕ
hm : succ m ≠ 0
v : ℕ
⊢ digits (succ zero) (succ v) ≠ []

tactic: intros v
state_before: n m : ℕ
hm : succ m ≠ 0
⊢ ∀ (v : ℕ), List.getLast (digits (succ zero) (succ v)) (_ : ¬1 :: List.replicate v 1 = []) = 1

tactic: induction v <;> simp
state_before: n m : ℕ
hm : succ m ≠ 0
v : ℕ
⊢ List.getLast (digits (succ zero) (succ v)) (_ : ¬1 :: List.replicate v 1 = []) = 1

tactic: assumption
state_before: case succ
n m : ℕ
hm : succ m ≠ 0
n✝ : ℕ
n_ih✝ : List.getLast (digits (succ zero) (succ n✝)) (_ : ¬1 :: List.replicate n✝ 1 = []) = 1
⊢ List.getLast (digits (succ 0) (succ (succ n✝))) (_ : ¬1 :: List.replicate (succ n✝) 1 = []) = 1

tactic: simpa only [digits_of_lt (b + 2) n hn hnb]
state_before: case pos
n✝ m b n : ℕ
IH : ∀ (m : ℕ), m < n → ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0
hn : n ≠ 0
hnb : n < b + 2
⊢ List.getLast (digits (succ (succ b)) n) (_ : digits (succ (succ b)) n ≠ []) ≠ 0

tactic: rw [digits_getLast n (le_add_left 2 b)]
state_before: case neg
n✝ m b n : ℕ
IH : ∀ (m : ℕ), m < n → ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ List.getLast (digits (succ (succ b)) n) (_ : digits (succ (succ b)) n ≠ []) ≠ 0

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 : ℕ), m < n → ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ List.getLast (digits (b + 2) (n / (b + 2))) ?neg.q✝ ≠ 0

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

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

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 : ℕ), m < n → ∀ (hm : m ≠ 0), List.getLast (digits (succ (succ b)) m) (_ : digits (succ (succ b)) m ≠ []) ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ 0 < n / succ (succ b)