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

tactic: induction' L with d L ih
state_before: n b : ℕ
h : 1 < b
L : List ℕ
w₁ : ∀ (l : ℕ), l ∈ L → l < b
w₂ : ∀ (h : L ≠ []), List.getLast L h ≠ 0
⊢ digits b (ofDigits b L) = L

tactic: dsimp [ofDigits]
state_before: case nil
n b : ℕ
h : 1 < b
L : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L → l < b
w₂✝ : ∀ (h : L ≠ []), List.getLast L h ≠ 0
w₁ : ∀ (l : ℕ), l ∈ [] → l < b
w₂ : ∀ (h : [] ≠ []), List.getLast [] h ≠ 0
⊢ digits b (ofDigits b []) = []

tactic: simp
state_before: case nil
n b : ℕ
h : 1 < b
L : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L → l < b
w₂✝ : ∀ (h : L ≠ []), List.getLast L h ≠ 0
w₁ : ∀ (l : ℕ), l ∈ [] → l < b
w₂ : ∀ (h : [] ≠ []), List.getLast [] h ≠ 0
⊢ digits b 0 = []

tactic: dsimp [ofDigits]
state_before: case cons
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : ∀ (h : d :: L ≠ []), List.getLast (d :: L) h ≠ 0
⊢ digits b (ofDigits b (d :: L)) = d :: L

tactic: replace w₂ := w₂ (by simp)
state_before: case cons
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : ∀ (h : d :: L ≠ []), List.getLast (d :: L) h ≠ 0
⊢ digits b (d + b * ofDigits b L) = d :: L

tactic: rw [digits_add b h]
state_before: case cons
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
⊢ digits b (d + b * ofDigits b L) = d :: L

tactic: simp
state_before: n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : ∀ (h : d :: L ≠ []), List.getLast (d :: L) h ≠ 0
⊢ d :: L ≠ []

tactic: rw [ih]
state_before: case cons
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
⊢ d :: digits b (ofDigits b L) = d :: L

tactic: intro l m
state_before: case cons.w₁
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
⊢ ∀ (l : ℕ), l ∈ L → l < b

tactic: apply w₁
state_before: case cons.w₁
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
l : ℕ
m : l ∈ L
⊢ l < b

tactic: exact List.mem_cons_of_mem _ m
state_before: case cons.w₁.a
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
l : ℕ
m : l ∈ L
⊢ l ∈ d :: L

tactic: intro h
state_before: case cons.w₂
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
⊢ ∀ (h : L ≠ []), List.getLast L h ≠ 0

tactic: rw [List.getLast_cons h] at w₂
state_before: case cons.w₂
n b : ℕ
h✝ : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
h : L ≠ []
⊢ List.getLast L h ≠ 0

tactic: convert w₂
state_before: case cons.w₂
n b : ℕ
h✝ : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
h : L ≠ []
w₂ : List.getLast L h ≠ 0
⊢ List.getLast L h ≠ 0

tactic: exact w₁ d (List.mem_cons_self _ _)
state_before: case cons.hxb
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
⊢ d < b

tactic: by_cases h' : L = []
state_before: case cons.hxy
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
⊢ d ≠ 0 ∨ ofDigits b L ≠ 0

tactic: rcases h' with rfl
state_before: case pos
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
h' : L = []
⊢ d ≠ 0 ∨ ofDigits b L ≠ 0

tactic: left
state_before: case pos
n b : ℕ
h : 1 < b
L : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L → l < b
w₂✝ : ∀ (h : L ≠ []), List.getLast L h ≠ 0
d : ℕ
ih : (∀ (l : ℕ), l ∈ [] → l < b) → (∀ (h : [] ≠ []), List.getLast [] h ≠ 0) → digits b (ofDigits b []) = []
w₁ : ∀ (l : ℕ), l ∈ [d] → l < b
w₂ : List.getLast [d] (_ : ¬[d] = []) ≠ 0
⊢ d ≠ 0 ∨ ofDigits b [] ≠ 0

tactic: simpa using w₂
state_before: case pos.h
n b : ℕ
h : 1 < b
L : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L → l < b
w₂✝ : ∀ (h : L ≠ []), List.getLast L h ≠ 0
d : ℕ
ih : (∀ (l : ℕ), l ∈ [] → l < b) → (∀ (h : [] ≠ []), List.getLast [] h ≠ 0) → digits b (ofDigits b []) = []
w₁ : ∀ (l : ℕ), l ∈ [d] → l < b
w₂ : List.getLast [d] (_ : ¬[d] = []) ≠ 0
⊢ d ≠ 0

tactic: right
state_before: case neg
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
h' : ¬L = []
⊢ d ≠ 0 ∨ ofDigits b L ≠ 0

tactic: contrapose! w₂
state_before: case neg.h
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
w₂ : List.getLast (d :: L) (_ : ¬d :: L = []) ≠ 0
h' : ¬L = []
⊢ ofDigits b L ≠ 0

tactic: refine' digits_zero_of_eq_zero h.ne_bot w₂ _ _
state_before: case neg.h
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
h' : ¬L = []
w₂ : ofDigits b L = 0
⊢ List.getLast (d :: L) (_ : ¬d :: L = []) = 0

tactic: rw [List.getLast_cons h']
state_before: case neg.h
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
h' : ¬L = []
w₂ : ofDigits b L = 0
⊢ List.getLast (d :: L) (_ : ¬d :: L = []) ∈ L

tactic: exact List.getLast_mem h'
state_before: case neg.h
n b : ℕ
h : 1 < b
L✝ : List ℕ
w₁✝ : ∀ (l : ℕ), l ∈ L✝ → l < b
w₂✝ : ∀ (h : L✝ ≠ []), List.getLast L✝ h ≠ 0
d : ℕ
L : List ℕ
ih : (∀ (l : ℕ), l ∈ L → l < b) → (∀ (h : L ≠ []), List.getLast L h ≠ 0) → digits b (ofDigits b L) = L
w₁ : ∀ (l : ℕ), l ∈ d :: L → l < b
h' : ¬L = []
w₂ : ofDigits b L = 0
⊢ List.getLast L h' ∈ L