url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | apply Nat.div_lt_self | b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ n / b + 1 β€ n | case hLtN
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 0 < n
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 1 < b | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ n / b + 1 β€ n
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | . apply Nat.pos_of_ne_zero; intro h; simp only [gt_iff_lt, h, Nat.zero_div, not_true] at * | case hLtN
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 0 < n
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 1 < b | case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 1 < b | Please generate a tactic in lean4 to solve the state.
STATE:
case hLtN
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 0 < n
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 1 < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | . exact Q | case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 1 < b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
β’ 1 < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | exfalso | case false.P.inl
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ n / b + 1 β€ n | case false.P.inl.h
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
case false.P.inl
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ n / b + 1 β€ n
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | apply h | case false.P.inl.h
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ False | case false.P.inl.h
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ n = n / b + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case false.P.inl.h
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | simp only [hβ] | case false.P.inl.h
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ n = n / b + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case false.P.inl.h
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 = n
β’ n = n / b + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | exact hβ | case false.P.inr
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 < n
β’ n / b + 1 β€ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case false.P.inr
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : Β¬n = n / b + 1
hβ : n / b + 1 β€ n
hβ : n / b + 1 < n
β’ n / b + 1 β€ n
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | simp at h | case true
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : (n == n / b + 1) = true
β’ toDigitsCore b (n / b + 1) (n / b) [] = toDigitsCore b n (n / b) [] | case true
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : n = n / b + 1
β’ toDigitsCore b (n / b + 1) (n / b) [] = toDigitsCore b n (n / b) [] | Please generate a tactic in lean4 to solve the state.
STATE:
case true
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : (n == n / b + 1) = true
β’ toDigitsCore b (n / b + 1) (n / b) [] = toDigitsCore b n (n / b) []
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | rw [β h] | case true
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : n = n / b + 1
β’ toDigitsCore b (n / b + 1) (n / b) [] = toDigitsCore b n (n / b) [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case true
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
P : succ n' β₯ n + 1
hβ : Β¬n / b = 0
h : n = n / b + 1
β’ toDigitsCore b (n / b + 1) (n / b) [] = toDigitsCore b n (n / b) []
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | apply Nat.div_lt_self | b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ n β₯ n / b + 1 | case hLtN
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 0 < n
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ n β₯ n / b + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | apply Nat.pos_of_ne_zero | case hLtN
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 0 < n
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | case hLtN.a
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ n β 0
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | Please generate a tactic in lean4 to solve the state.
STATE:
case hLtN
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 0 < n
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | intro h | case hLtN.a
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ n β 0
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | case hLtN.a
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
h : n = 0
β’ False
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | Please generate a tactic in lean4 to solve the state.
STATE:
case hLtN.a
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ n β 0
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | simp only [gt_iff_lt, h, Nat.zero_div, not_true] at * | case hLtN.a
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
h : n = 0
β’ False
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | Please generate a tactic in lean4 to solve the state.
STATE:
case hLtN.a
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
h : n = 0
β’ False
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_fuel_irrelevant | [185, 1] | [229, 187] | apply Q | case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hLtK
b : β
Q : b > 1
n : β
rest : List Char
xβΒ² xβΒΉ : β
xβ : List Char
n' : β
ih :
β (m : β),
m < succ n' β β {n : β} {rest : List Char}, m β₯ n + 1 β toDigitsCore b m n rest = toDigitsCore b (n + 1) n rest
hβ : Β¬n / b = 0
P : n β€ n'
β’ 1 < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | let h: β c, c β Nat.toDigitsCore b (n+1) n [] β Char.isDigit c = true β¨ c β [] := by
intro c
apply Nat.toDigitsCore_digits _ _ P Q | b n : β
P : b β€ 10
Q : b > 1
β’ (List.all (toDigits b n) Char.isDigit == true) = true | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] :=
fun c => toDigitsCore_digits b n P Q
β’ (List.all (toDigits b n) Char.isDigit == true) = true | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
β’ (List.all (toDigits b n) Char.isDigit == true) = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | simp | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] :=
fun c => toDigitsCore_digits b n P Q
β’ (List.all (toDigits b n) Char.isDigit == true) = true | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] :=
fun c => toDigitsCore_digits b n P Q
β’ β (x : Char), x β toDigits b n β Char.isDigit x = true | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] :=
fun c => toDigitsCore_digits b n P Q
β’ (List.all (toDigits b n) Char.isDigit == true) = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | simp at h | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] :=
fun c => toDigitsCore_digits b n P Q
β’ β (x : Char), x β toDigits b n β Char.isDigit x = true | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true
β’ β (x : Char), x β toDigits b n β Char.isDigit x = true | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] :=
fun c => toDigitsCore_digits b n P Q
β’ β (x : Char), x β toDigits b n β Char.isDigit x = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | unfold Nat.toDigits | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true
β’ β (x : Char), x β toDigits b n β Char.isDigit x = true | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true
β’ β (x : Char), x β toDigitsCore b (n + 1) n [] β Char.isDigit x = true | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true
β’ β (x : Char), x β toDigits b n β Char.isDigit x = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | apply h | b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true
β’ β (x : Char), x β toDigitsCore b (n + 1) n [] β Char.isDigit x = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
h : β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true
β’ β (x : Char), x β toDigitsCore b (n + 1) n [] β Char.isDigit x = true
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | intro c | b n : β
P : b β€ 10
Q : b > 1
β’ β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] | b n : β
P : b β€ 10
Q : b > 1
c : Char
β’ c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
β’ β (c : Char), c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β []
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_digits | [232, 1] | [239, 10] | apply Nat.toDigitsCore_digits _ _ P Q | b n : β
P : b β€ 10
Q : b > 1
c : Char
β’ c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b β€ 10
Q : b > 1
c : Char
β’ c β toDigitsCore b (n + 1) n [] β Char.isDigit c = true β¨ c β []
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.get?_cons | [241, 1] | [245, 93] | conv => left; unfold List.get? | Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : n > 0
β’ get? (h :: tail) n = get? tail (n - 1) | Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : n > 0
β’ (match h :: tail, n with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (n - 1) | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : n > 0
β’ get? (h :: tail) n = get? tail (n - 1)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.get?_cons | [241, 1] | [245, 93] | cases n with
| zero => simp only at hn
| succ n => simp only [ge_iff_le, Nat.succ_sub_succ_eq_sub, nonpos_iff_eq_zero, tsub_zero] | Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : n > 0
β’ (match h :: tail, n with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (n - 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : n > 0
β’ (match h :: tail, n with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (n - 1)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.get?_cons | [241, 1] | [245, 93] | simp only at hn | case zero
Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
hn : Nat.zero > 0
β’ (match h :: tail, Nat.zero with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (Nat.zero - 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
hn : Nat.zero > 0
β’ (match h :: tail, Nat.zero with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (Nat.zero - 1)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | List.get?_cons | [241, 1] | [245, 93] | simp only [ge_iff_le, Nat.succ_sub_succ_eq_sub, nonpos_iff_eq_zero, tsub_zero] | case succ
Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : Nat.succ n > 0
β’ (match h :: tail, Nat.succ n with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (Nat.succ n - 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Ξ± : Type u_1
h : Ξ±
tail : List Ξ±
n : β
hn : Nat.succ n > 0
β’ (match h :: tail, Nat.succ n with
| a :: tail, 0 => some a
| head :: as, Nat.succ n => get? as n
| x, x_1 => none) =
get? tail (Nat.succ n - 1)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | intro i | b n : β
P : b > 1
β’ β (i : β),
List.getD (List.reverse (toDigits b n)) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
β’ β (i : β),
List.getD (List.reverse (toDigits b n)) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | rw [toDigits, toDigitsCore] | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
β’ List.getD
(List.reverse
(let d := digitChar (n % b);
let n' := n / b;
if n' = 0 then [d] else toDigitsCore b n n' [d]))
(i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | simp only [add_eq, add_zero] | b n : β
P : b > 1
i : β
β’ List.getD
(List.reverse
(let d := digitChar (n % b);
let n' := n / b;
if n' = 0 then [d] else toDigitsCore b n n' [d]))
(i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (if n / b = 0 then [digitChar (n % b)] else toDigitsCore b n (n / b) [digitChar (n % b)]))
(i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
β’ List.getD
(List.reverse
(let d := digitChar (n % b);
let n' := n / b;
if n' = 0 then [d] else toDigitsCore b n n' [d]))
(i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | split | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (if n / b = 0 then [digitChar (n % b)] else toDigitsCore b n (n / b) [digitChar (n % b)]))
(i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | case inl
b n : β
P : b > 1
i : β
hβ : n / b = 0
β’ List.getD (List.reverse [digitChar (n % b)]) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
case inr
b n : β
P : b > 1
i : β
hβ : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (if n / b = 0 then [digitChar (n % b)] else toDigitsCore b n (n / b) [digitChar (n % b)]))
(i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | . next heq =>
conv => left; unfold List.getD
simp only [List.get?, Option.getD_none]
rw [heq]
unfold toDigits toDigitsCore digitChar
simp only [Nat.zero_div, zero_mod, zero_ne_one, ite_false, ite_true, List.reverse_cons, List.reverse_nil,
List.nil_append, List.getD_singleton_default_eq] | case inl
b n : β
P : b > 1
i : β
hβ : n / b = 0
β’ List.getD (List.reverse [digitChar (n % b)]) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
case inr
b n : β
P : b > 1
i : β
hβ : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | case inr
b n : β
P : b > 1
i : β
hβ : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
b n : β
P : b > 1
i : β
hβ : n / b = 0
β’ List.getD (List.reverse [digitChar (n % b)]) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
case inr
b n : β
P : b > 1
i : β
hβ : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | . next heq =>
rw [Nat.todigitsCore_accumulates_suffix]
rw [List.getD, List.getD]
congr 1
simp only [List.reverse_append, List.reverse_cons, List.reverse_nil, List.nil_append, List.singleton_append,
List.cons.injEq, succ.injEq, and_imp, forall_apply_eq_imp_iffβ, forall_apply_eq_imp_iff', forall_eq',
List.get?, add_eq, add_zero]
rw [Nat.toDigitsCore_fuel_irrelevant, β Nat.toDigits]
. simp only [ge_iff_le]
have h: n β 0 := by
simp only [ne_eq]
intro h
rw [h] at heq
simp only [Nat.zero_div] at heq
apply Nat.div_lt_self
. simp only [ne_eq, h, not_false_iff, Nat.pos_of_ne_zero]
. exact P
. exact P | case inr
b n : β
P : b > 1
i : β
hβ : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
b n : β
P : b > 1
i : β
hβ : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | conv => left; unfold List.getD | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ List.getD (List.reverse [digitChar (n % b)]) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Option.getD (List.get? (List.reverse [digitChar (n % b)]) (i + 1)) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : n / b = 0
β’ List.getD (List.reverse [digitChar (n % b)]) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | simp only [List.get?, Option.getD_none] | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Option.getD (List.get? (List.reverse [digitChar (n % b)]) (i + 1)) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 = List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Option.getD (List.get? (List.reverse [digitChar (n % b)]) (i + 1)) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | rw [heq] | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 = List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 = List.getD (List.reverse (toDigits b 0)) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 = List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | unfold toDigits toDigitsCore digitChar | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 = List.getD (List.reverse (toDigits b 0)) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 =
List.getD
(List.reverse
(let d :=
if 0 % b = 0 then Char.ofNat 48
else
if 0 % b = 1 then Char.ofNat 49
else
if 0 % b = 2 then Char.ofNat 50
else
if 0 % b = 3 then Char.ofNat 51
else
if 0 % b = 4 then Char.ofNat 52
else
if 0 % b = 5 then Char.ofNat 53
else
if 0 % b = 6 then Char.ofNat 54
else
if 0 % b = 7 then Char.ofNat 55
else
if 0 % b = 8 then Char.ofNat 56
else
if 0 % b = 9 then Char.ofNat 57
else
if 0 % b = 10 then Char.ofNat 97
else
if 0 % b = 11 then Char.ofNat 98
else
if 0 % b = 12 then Char.ofNat 99
else
if 0 % b = 13 then Char.ofNat 100
else
if 0 % b = 14 then Char.ofNat 101
else if 0 % b = 15 then Char.ofNat 102 else Char.ofNat 42;
let n' := 0 / b;
if n' = 0 then [d] else toDigitsCore b 0 n' [d]))
i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 = List.getD (List.reverse (toDigits b 0)) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | simp only [Nat.zero_div, zero_mod, zero_ne_one, ite_false, ite_true, List.reverse_cons, List.reverse_nil,
List.nil_append, List.getD_singleton_default_eq] | b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 =
List.getD
(List.reverse
(let d :=
if 0 % b = 0 then Char.ofNat 48
else
if 0 % b = 1 then Char.ofNat 49
else
if 0 % b = 2 then Char.ofNat 50
else
if 0 % b = 3 then Char.ofNat 51
else
if 0 % b = 4 then Char.ofNat 52
else
if 0 % b = 5 then Char.ofNat 53
else
if 0 % b = 6 then Char.ofNat 54
else
if 0 % b = 7 then Char.ofNat 55
else
if 0 % b = 8 then Char.ofNat 56
else
if 0 % b = 9 then Char.ofNat 57
else
if 0 % b = 10 then Char.ofNat 97
else
if 0 % b = 11 then Char.ofNat 98
else
if 0 % b = 12 then Char.ofNat 99
else
if 0 % b = 13 then Char.ofNat 100
else
if 0 % b = 14 then Char.ofNat 101
else if 0 % b = 15 then Char.ofNat 102 else Char.ofNat 42;
let n' := 0 / b;
if n' = 0 then [d] else toDigitsCore b 0 n' [d]))
i (Char.ofNat 48) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : n / b = 0
β’ Char.ofNat 48 =
List.getD
(List.reverse
(let d :=
if 0 % b = 0 then Char.ofNat 48
else
if 0 % b = 1 then Char.ofNat 49
else
if 0 % b = 2 then Char.ofNat 50
else
if 0 % b = 3 then Char.ofNat 51
else
if 0 % b = 4 then Char.ofNat 52
else
if 0 % b = 5 then Char.ofNat 53
else
if 0 % b = 6 then Char.ofNat 54
else
if 0 % b = 7 then Char.ofNat 55
else
if 0 % b = 8 then Char.ofNat 56
else
if 0 % b = 9 then Char.ofNat 57
else
if 0 % b = 10 then Char.ofNat 97
else
if 0 % b = 11 then Char.ofNat 98
else
if 0 % b = 12 then Char.ofNat 99
else
if 0 % b = 13 then Char.ofNat 100
else
if 0 % b = 14 then Char.ofNat 101
else if 0 % b = 15 then Char.ofNat 102 else Char.ofNat 42;
let n' := 0 / b;
if n' = 0 then [d] else toDigitsCore b 0 n' [d]))
i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | rw [Nat.todigitsCore_accumulates_suffix] | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | rw [List.getD, List.getD] | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48) | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ Option.getD (List.get? (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1)) (Char.ofNat 48) =
Option.getD (List.get? (List.reverse (toDigits b (n / b))) i) (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.getD (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) i (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | congr 1 | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ Option.getD (List.get? (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1)) (Char.ofNat 48) =
Option.getD (List.get? (List.reverse (toDigits b (n / b))) i) (Char.ofNat 48) | case e_a
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.get? (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1) =
List.get? (List.reverse (toDigits b (n / b))) i | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ Option.getD (List.get? (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1)) (Char.ofNat 48) =
Option.getD (List.get? (List.reverse (toDigits b (n / b))) i) (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | simp only [List.reverse_append, List.reverse_cons, List.reverse_nil, List.nil_append, List.singleton_append,
List.cons.injEq, succ.injEq, and_imp, forall_apply_eq_imp_iffβ, forall_apply_eq_imp_iff', forall_eq',
List.get?, add_eq, add_zero] | case e_a
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.get? (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1) =
List.get? (List.reverse (toDigits b (n / b))) i | case e_a
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.get? (List.reverse (toDigitsCore b n (n / b) [])) i = List.get? (List.reverse (toDigits b (n / b))) i | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.get? (List.reverse (toDigitsCore b n (n / b) [] ++ [digitChar (n % b)])) (i + 1) =
List.get? (List.reverse (toDigits b (n / b))) i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | rw [Nat.toDigitsCore_fuel_irrelevant, β Nat.toDigits] | case e_a
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.get? (List.reverse (toDigitsCore b n (n / b) [])) i = List.get? (List.reverse (toDigits b (n / b))) i | case e_a.P
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ n β₯ n / b + 1
case e_a.Q
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ b > 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ List.get? (List.reverse (toDigitsCore b n (n / b) [])) i = List.get? (List.reverse (toDigits b (n / b))) i
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | . simp only [ge_iff_le]
have h: n β 0 := by
simp only [ne_eq]
intro h
rw [h] at heq
simp only [Nat.zero_div] at heq
apply Nat.div_lt_self
. simp only [ne_eq, h, not_false_iff, Nat.pos_of_ne_zero]
. exact P | case e_a.P
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ n β₯ n / b + 1
case e_a.Q
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ b > 1 | case e_a.Q
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ b > 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.P
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ n β₯ n / b + 1
case e_a.Q
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ b > 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | . exact P | case e_a.Q
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ b > 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.Q
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ b > 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | simp only [ne_eq] | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ n β 0 | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ Β¬n = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ n β 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | intro h | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ Β¬n = 0 | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
h : n = 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
β’ Β¬n = 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | rw [h] at heq | b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
h : n = 0
β’ False | b n : β
P : b > 1
i : β
heq : Β¬0 / b = 0
h : n = 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b = 0
h : n = 0
β’ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift' | [248, 1] | [280, 14] | simp only [Nat.zero_div] at heq | b n : β
P : b > 1
i : β
heq : Β¬0 / b = 0
h : n = 0
β’ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬0 / b = 0
h : n = 0
β’ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | intro i igt | b n : β
P : b > 1
β’ β (i : β),
i > 0 β
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) (i - 1) (Char.ofNat 48) | b n : β
P : b > 1
i : β
igt : i > 0
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) (i - 1) (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
β’ β (i : β),
i > 0 β
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) (i - 1) (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | generalize h: i - 1 = p | b n : β
P : b > 1
i : β
igt : i > 0
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) (i - 1) (Char.ofNat 48) | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
igt : i > 0
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) (i - 1) (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | have heq: i = p + 1 := by cases i with | zero => contradiction | succ n => simp at h; rw [h] | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48) | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | rw [heq] | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48) | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ List.getD (List.reverse (toDigits b n)) (p + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | apply Nat.toDigitsCore_shift' | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ List.getD (List.reverse (toDigits b n)) (p + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48) | case P
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ b > 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ List.getD (List.reverse (toDigits b n)) (p + 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b))) p (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | exact P | case P
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ b > 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case P
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
heq : i = p + 1
β’ b > 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | cases i with | zero => contradiction | succ n => simp at h; rw [h] | b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
β’ i = p + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
igt : i > 0
p : β
h : i - 1 = p
β’ i = p + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | contradiction | case zero
b n : β
P : b > 1
p : β
igt : zero > 0
h : zero - 1 = p
β’ zero = p + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
b n : β
P : b > 1
p : β
igt : zero > 0
h : zero - 1 = p
β’ zero = p + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | simp at h | case succ
b nβ : β
P : b > 1
p n : β
igt : succ n > 0
h : succ n - 1 = p
β’ succ n = p + 1 | case succ
b nβ : β
P : b > 1
p n : β
igt : succ n > 0
h : n = p
β’ succ n = p + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
b nβ : β
P : b > 1
p n : β
igt : succ n > 0
h : succ n - 1 = p
β’ succ n = p + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift | [282, 1] | [288, 10] | rw [h] | case succ
b nβ : β
P : b > 1
p n : β
igt : succ n > 0
h : n = p
β’ succ n = p + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
b nβ : β
P : b > 1
p n : β
igt : succ n > 0
h : n = p
β’ succ n = p + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | intro i | b n : β
P : b > 1
β’ β (i : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48) | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
β’ β (i : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | induction i generalizing n with
| zero =>
simp only [zero_eq, pow_zero, Nat.div_one]
| succ i ih =>
rw [Nat.toDigitsCore_shift]
. simp
rw [ih]
congr 3
rw [Nat.div_div_eq_div_mul]
congr 1
rw [Nat.pow_succ']
. exact P
. simp | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | simp only [zero_eq, pow_zero, Nat.div_one] | case zero
b : β
P : b > 1
n : β
β’ List.getD (List.reverse (toDigits b n)) zero (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ zero))) 0 (Char.ofNat 48) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
b : β
P : b > 1
n : β
β’ List.getD (List.reverse (toDigits b n)) zero (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ zero))) 0 (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | rw [Nat.toDigitsCore_shift] | case succ
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ List.getD (List.reverse (toDigits b n)) (succ i) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ succ i))) 0 (Char.ofNat 48) | case succ
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ List.getD (List.reverse (toDigits b (n / b))) (succ i - 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ succ i))) 0 (Char.ofNat 48)
case succ.P
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ b > 1
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ List.getD (List.reverse (toDigits b n)) (succ i) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ succ i))) 0 (Char.ofNat 48)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | . simp
rw [ih]
congr 3
rw [Nat.div_div_eq_div_mul]
congr 1
rw [Nat.pow_succ'] | case succ
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ List.getD (List.reverse (toDigits b (n / b))) (succ i - 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ succ i))) 0 (Char.ofNat 48)
case succ.P
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ b > 1
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0 | case succ.P
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ b > 1
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ List.getD (List.reverse (toDigits b (n / b))) (succ i - 1) (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ succ i))) 0 (Char.ofNat 48)
case succ.P
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ b > 1
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | . exact P | case succ.P
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ b > 1
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0 | case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.P
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ b > 1
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_shift_full | [290, 1] | [304, 11] | . simp | case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.a
b : β
P : b > 1
i : β
ih :
β (n : β),
List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) =
List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48)
n : β
β’ succ i > 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.digit_lt_base | [309, 1] | [311, 23] | unfold Nat.digit | base n index : β
P : base > 0
β’ digit base n index < base | base n index : β
P : base > 0
β’ n / base ^ index % base < base | Please generate a tactic in lean4 to solve the state.
STATE:
base n index : β
P : base > 0
β’ digit base n index < base
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.digit_lt_base | [309, 1] | [311, 23] | apply Nat.mod_lt _ P | base n index : β
P : base > 0
β’ n / base ^ index % base < base | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
base n index : β
P : base > 0
β’ n / base ^ index % base < base
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | intro i | b n : β
P : b > 1
β’ β (i : β), List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) = digitChar (digit b n i) | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) = digitChar (digit b n i) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
β’ β (i : β), List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) = digitChar (digit b n i)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | rw [Nat.toDigitsCore_shift_full] | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) = digitChar (digit b n i) | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48) = digitChar (digit b n i)
case P
b n : β
P : b > 1
i : β
β’ b > 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b n)) i (Char.ofNat 48) = digitChar (digit b n i)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | . unfold toDigits toDigitsCore digit
simp only [add_eq, add_zero]
split
. next heq =>
simp only [List.reverse_cons, List.reverse_nil, List.nil_append, List.getD._eq_1, List.get?, Option.getD_some]
. next heq =>
rw [Nat.todigitsCore_accumulates_suffix]
simp only [List.reverse_append, List.reverse_cons, List.reverse_nil, List.nil_append, List.singleton_append,
List.getD._eq_1, List.get?, Option.getD_some] | b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48) = digitChar (digit b n i)
case P
b n : β
P : b > 1
i : β
β’ b > 1 | case P
b n : β
P : b > 1
i : β
β’ b > 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
β’ List.getD (List.reverse (toDigits b (n / b ^ i))) 0 (Char.ofNat 48) = digitChar (digit b n i)
case P
b n : β
P : b > 1
i : β
β’ b > 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | . exact P | case P
b n : β
P : b > 1
i : β
β’ b > 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case P
b n : β
P : b > 1
i : β
β’ b > 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | simp only [List.reverse_cons, List.reverse_nil, List.nil_append, List.getD._eq_1, List.get?, Option.getD_some] | b n : β
P : b > 1
i : β
heq : n / b ^ i / b = 0
β’ List.getD (List.reverse [digitChar (n / b ^ i % b)]) 0 (Char.ofNat 48) = digitChar (n / b ^ i % b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : n / b ^ i / b = 0
β’ List.getD (List.reverse [digitChar (n / b ^ i % b)]) 0 (Char.ofNat 48) = digitChar (n / b ^ i % b)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | rw [Nat.todigitsCore_accumulates_suffix] | b n : β
P : b > 1
i : β
heq : Β¬n / b ^ i / b = 0
β’ List.getD (List.reverse (toDigitsCore b (n / b ^ i) (n / b ^ i / b) [digitChar (n / b ^ i % b)])) 0 (Char.ofNat 48) =
digitChar (n / b ^ i % b) | b n : β
P : b > 1
i : β
heq : Β¬n / b ^ i / b = 0
β’ List.getD (List.reverse (toDigitsCore b (n / b ^ i) (n / b ^ i / b) [] ++ [digitChar (n / b ^ i % b)])) 0
(Char.ofNat 48) =
digitChar (n / b ^ i % b) | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b ^ i / b = 0
β’ List.getD (List.reverse (toDigitsCore b (n / b ^ i) (n / b ^ i / b) [digitChar (n / b ^ i % b)])) 0 (Char.ofNat 48) =
digitChar (n / b ^ i % b)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigits_eq_digit_rev | [315, 1] | [328, 12] | simp only [List.reverse_append, List.reverse_cons, List.reverse_nil, List.nil_append, List.singleton_append,
List.getD._eq_1, List.get?, Option.getD_some] | b n : β
P : b > 1
i : β
heq : Β¬n / b ^ i / b = 0
β’ List.getD (List.reverse (toDigitsCore b (n / b ^ i) (n / b ^ i / b) [] ++ [digitChar (n / b ^ i % b)])) 0
(Char.ofNat 48) =
digitChar (n / b ^ i % b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b n : β
P : b > 1
i : β
heq : Β¬n / b ^ i / b = 0
β’ List.getD (List.reverse (toDigitsCore b (n / b ^ i) (n / b ^ i / b) [] ++ [digitChar (n / b ^ i % b)])) 0
(Char.ofNat 48) =
digitChar (n / b ^ i % b)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | have heq: accum = [] ++ accum := by simp only [List.nil_append] | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
β’ List.length (toDigitsCore b fuel n accum) = log b n + 1 + List.length accum | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n accum) = log b n + 1 + List.length accum | Please generate a tactic in lean4 to solve the state.
STATE:
accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
β’ List.length (toDigitsCore b fuel n accum) = log b n + 1 + List.length accum
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | rw [heq, Nat.toDigitsCore_accumulates] | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n accum) = log b n + 1 + List.length accum | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n [] ++ accum) = log b n + 1 + List.length ([] ++ accum) | Please generate a tactic in lean4 to solve the state.
STATE:
accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n accum) = log b n + 1 + List.length accum
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | simp only [List.length_append, List.nil_append, add_left_inj] | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n [] ++ accum) = log b n + 1 + List.length ([] ++ accum) | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n [] ++ accum) = log b n + 1 + List.length ([] ++ accum)
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | induction n using Nat.strong_induction_on generalizing fuel accum | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1 | case h
b : β
P : b > 1
nβ : β
aβ :
β (m : β),
m < nβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > nβ
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel nβ []) = log b nβ + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | case h n ih =>
unfold toDigitsCore
split
. next i _ _ _=>
exfalso
apply Nat.not_lt_of_le (Nat.zero_le i)
apply R
. next w y p l =>
simp; split
. next i hβ=>
simp
left
have h: b > 0 := pos_of_gt P
apply (Nat.div_lt_one_iff h).1
simp only [hβ, zero_lt_one]
. next n heq =>
rw [Nat.todigitsCore_accumulates_suffix]
simp only [List.length_append, List.length_singleton, add_left_inj]
have h: n/b<n := by
apply Nat.div_lt_self
. apply Nat.pos_of_ne_zero
intro h
simp only [h, Nat.zero_div, not_true] at heq
. apply P
rw [ih]
. rw [Nat.log_div_base, Nat.sub_add_cancel]
apply Nat.log_pos
. apply P
. apply (Nat.one_le_div_iff (Nat.lt_of_succ_lt P)).1
apply Nat.succ_le_iff.2
apply Nat.pos_of_ne_zero
apply heq
. exact h
. exact []
. calc
l β₯ n := by exact le_of_lt_succ R
_ > n/b := h
. simp | b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | simp only [List.nil_append] | accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
β’ accum = [] ++ accum | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
accum : List Char
b fuel n : β
P : b > 1
R : fuel > n
β’ accum = [] ++ accum
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | unfold toDigitsCore | b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1 | b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length
(match fuel, n, [] with
| 0, x, ds => ds
| succ fuel, n, ds =>
let d := digitChar (n % b);
let n' := n / b;
if n' = 0 then d :: ds else toDigitsCore b fuel n' (d :: ds)) =
log b n + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length (toDigitsCore b fuel n []) = log b n + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | split | b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length
(match fuel, n, [] with
| 0, x, ds => ds
| succ fuel, n, ds =>
let d := digitChar (n % b);
let n' := n / b;
if n' = 0 then d :: ds else toDigitsCore b fuel n' (d :: ds)) =
log b n + 1 | case h_1
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > xβΒ³
β’ List.length [] = log b xβΒ³ + 1
case h_2
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
fuelβ : β
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ fuelβ > xβΒ³
β’ List.length
(let d := digitChar (xβΒ³ % b);
let n' := xβΒ³ / b;
if n' = 0 then [d] else toDigitsCore b fuelβ n' [d]) =
log b xβΒ³ + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
n : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
accum : List Char
fuel : β
R : fuel > n
heq : accum = [] ++ accum
β’ List.length
(match fuel, n, [] with
| 0, x, ds => ds
| succ fuel, n, ds =>
let d := digitChar (n % b);
let n' := n / b;
if n' = 0 then d :: ds else toDigitsCore b fuel n' (d :: ds)) =
log b n + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | . next i _ _ _=>
exfalso
apply Nat.not_lt_of_le (Nat.zero_le i)
apply R | case h_1
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > xβΒ³
β’ List.length [] = log b xβΒ³ + 1
case h_2
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
fuelβ : β
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ fuelβ > xβΒ³
β’ List.length
(let d := digitChar (xβΒ³ % b);
let n' := xβΒ³ / b;
if n' = 0 then [d] else toDigitsCore b fuelβ n' [d]) =
log b xβΒ³ + 1 | case h_2
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
fuelβ : β
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ fuelβ > xβΒ³
β’ List.length
(let d := digitChar (xβΒ³ % b);
let n' := xβΒ³ / b;
if n' = 0 then [d] else toDigitsCore b fuelβ n' [d]) =
log b xβΒ³ + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > xβΒ³
β’ List.length [] = log b xβΒ³ + 1
case h_2
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
fuelβ : β
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ fuelβ > xβΒ³
β’ List.length
(let d := digitChar (xβΒ³ % b);
let n' := xβΒ³ / b;
if n' = 0 then [d] else toDigitsCore b fuelβ n' [d]) =
log b xβΒ³ + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | . next w y p l =>
simp; split
. next i hβ=>
simp
left
have h: b > 0 := pos_of_gt P
apply (Nat.div_lt_one_iff h).1
simp only [hβ, zero_lt_one]
. next n heq =>
rw [Nat.todigitsCore_accumulates_suffix]
simp only [List.length_append, List.length_singleton, add_left_inj]
have h: n/b<n := by
apply Nat.div_lt_self
. apply Nat.pos_of_ne_zero
intro h
simp only [h, Nat.zero_div, not_true] at heq
. apply P
rw [ih]
. rw [Nat.log_div_base, Nat.sub_add_cancel]
apply Nat.log_pos
. apply P
. apply (Nat.one_le_div_iff (Nat.lt_of_succ_lt P)).1
apply Nat.succ_le_iff.2
apply Nat.pos_of_ne_zero
apply heq
. exact h
. exact []
. calc
l β₯ n := by exact le_of_lt_succ R
_ > n/b := h
. simp | case h_2
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
fuelβ : β
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ fuelβ > xβΒ³
β’ List.length
(let d := digitChar (xβΒ³ % b);
let n' := xβΒ³ / b;
if n' = 0 then [d] else toDigitsCore b fuelβ n' [d]) =
log b xβΒ³ + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβΒ³ xβΒ² xβΒΉ : β
xβ : List Char
fuelβ : β
ih :
β (m : β),
m < xβΒ³ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ fuelβ > xβΒ³
β’ List.length
(let d := digitChar (xβΒ³ % b);
let n' := xβΒ³ / b;
if n' = 0 then [d] else toDigitsCore b fuelβ n' [d]) =
log b xβΒ³ + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | exfalso | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ List.length [] = log b i + 1 | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ List.length [] = log b i + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | apply Nat.not_lt_of_le (Nat.zero_le i) | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ False | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ i < 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ False
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | apply R | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ i < 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i xβΒ² xβΒΉ : β
xβ : List Char
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : 0 > i
β’ i < 0
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | simp | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
β’ List.length
(let d := digitChar (xβ % b);
let n' := xβ / b;
if n' = 0 then [d] else toDigitsCore b l n' [d]) =
log b xβ + 1 | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
β’ List.length (if xβ / b = 0 then [digitChar (xβ % b)] else toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) =
log b xβ + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
β’ List.length
(let d := digitChar (xβ % b);
let n' := xβ / b;
if n' = 0 then [d] else toDigitsCore b l n' [d]) =
log b xβ + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | split | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
β’ List.length (if xβ / b = 0 then [digitChar (xβ % b)] else toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) =
log b xβ + 1 | case inl
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : xβ / b = 0
β’ List.length [digitChar (xβ % b)] = log b xβ + 1
case inr
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : Β¬xβ / b = 0
β’ List.length (toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) = log b xβ + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
β’ List.length (if xβ / b = 0 then [digitChar (xβ % b)] else toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) =
log b xβ + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | . next i hβ=>
simp
left
have h: b > 0 := pos_of_gt P
apply (Nat.div_lt_one_iff h).1
simp only [hβ, zero_lt_one] | case inl
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : xβ / b = 0
β’ List.length [digitChar (xβ % b)] = log b xβ + 1
case inr
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : Β¬xβ / b = 0
β’ List.length (toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) = log b xβ + 1 | case inr
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : Β¬xβ / b = 0
β’ List.length (toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) = log b xβ + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : xβ / b = 0
β’ List.length [digitChar (xβ % b)] = log b xβ + 1
case inr
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : Β¬xβ / b = 0
β’ List.length (toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) = log b xβ + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | . next n heq =>
rw [Nat.todigitsCore_accumulates_suffix]
simp only [List.length_append, List.length_singleton, add_left_inj]
have h: n/b<n := by
apply Nat.div_lt_self
. apply Nat.pos_of_ne_zero
intro h
simp only [h, Nat.zero_div, not_true] at heq
. apply P
rw [ih]
. rw [Nat.log_div_base, Nat.sub_add_cancel]
apply Nat.log_pos
. apply P
. apply (Nat.one_le_div_iff (Nat.lt_of_succ_lt P)).1
apply Nat.succ_le_iff.2
apply Nat.pos_of_ne_zero
apply heq
. exact h
. exact []
. calc
l β₯ n := by exact le_of_lt_succ R
_ > n/b := h
. simp | case inr
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : Β¬xβ / b = 0
β’ List.length (toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) = log b xβ + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
xβ w y : β
p : List Char
l : β
ih :
β (m : β),
m < xβ β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > xβ
hβ : Β¬xβ / b = 0
β’ List.length (toDigitsCore b l (xβ / b) [digitChar (xβ % b)]) = log b xβ + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | simp | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ List.length [digitChar (i % b)] = log b i + 1 | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ i < b β¨ b β€ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ List.length [digitChar (i % b)] = log b i + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | left | b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ i < b β¨ b β€ 1 | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ i < b | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ i < b β¨ b β€ 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | have h: b > 0 := pos_of_gt P | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ i < b | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
h : b > 0
β’ i < b | Please generate a tactic in lean4 to solve the state.
STATE:
case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
β’ i < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | apply (Nat.div_lt_one_iff h).1 | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
h : b > 0
β’ i < b | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
h : b > 0
β’ i / b < 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
h : b > 0
β’ i < b
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | simp only [hβ, zero_lt_one] | case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
h : b > 0
β’ i / b < 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
b : β
P : b > 1
accum : List Char
heq : accum = [] ++ accum
i w y : β
p : List Char
l : β
ih :
β (m : β),
m < i β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > i
hβ : i / b = 0
h : b > 0
β’ i / b < 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | rw [Nat.todigitsCore_accumulates_suffix] | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) [digitChar (n % b)]) = log b n + 1 | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) [] ++ [digitChar (n % b)]) = log b n + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) [digitChar (n % b)]) = log b n + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | simp only [List.length_append, List.length_singleton, add_left_inj] | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) [] ++ [digitChar (n % b)]) = log b n + 1 | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) []) = log b n | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) [] ++ [digitChar (n % b)]) = log b n + 1
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | have h: n/b<n := by
apply Nat.div_lt_self
. apply Nat.pos_of_ne_zero
intro h
simp only [h, Nat.zero_div, not_true] at heq
. apply P | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) []) = log b n | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List.length (toDigitsCore b l (n / b) []) = log b n | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
β’ List.length (toDigitsCore b l (n / b) []) = log b n
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | rw [ih] | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List.length (toDigitsCore b l (n / b) []) = log b n | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ log b (n / b) + 1 = log b n
case a
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ n / b < n
case accum
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List Char
case R
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ l > n / b
case heq
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ ?accum = [] ++ ?accum | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List.length (toDigitsCore b l (n / b) []) = log b n
TACTIC:
|
https://github.com/jeremysalwen/advent_of_lean_2022.git | 96035d07c4f9f133fe79fe02cdf5792b597881c0 | One.lean | Nat.toDigitsCore_length_eq_log | [330, 1] | [372, 15] | . rw [Nat.log_div_base, Nat.sub_add_cancel]
apply Nat.log_pos
. apply P
. apply (Nat.one_le_div_iff (Nat.lt_of_succ_lt P)).1
apply Nat.succ_le_iff.2
apply Nat.pos_of_ne_zero
apply heq | b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ log b (n / b) + 1 = log b n
case a
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ n / b < n
case accum
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List Char
case R
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ l > n / b
case heq
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ ?accum = [] ++ ?accum | case a
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ n / b < n
case accum
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List Char
case R
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ l > n / b
case heq
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ ?accum = [] ++ ?accum | Please generate a tactic in lean4 to solve the state.
STATE:
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ log b (n / b) + 1 = log b n
case a
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ n / b < n
case accum
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ List Char
case R
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ l > n / b
case heq
b : β
P : b > 1
accum : List Char
heqβ : accum = [] ++ accum
n w y : β
p : List Char
l : β
ih :
β (m : β),
m < n β
β {accum : List Char} (fuel : β),
fuel > m β accum = [] ++ accum β List.length (toDigitsCore b fuel m []) = log b m + 1
R : succ l > n
heq : Β¬n / b = 0
h : n / b < n
β’ ?accum = [] ++ ?accum
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.