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/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_take | [468, 1] | [527, 21] | unfold minOfLe | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ minOfLe.1 n m = m | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ { min := fun x y => if x ≤ y then x else y }.1 n m = m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ minOfLe.1 n m = m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_take | [468, 1] | [527, 21] | simp only [ite_eq_right_iff] | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ { min := fun x y => if x ≤ y then x else y }.1 n m = m | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ n ≤ m → n = m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ { min := fun x y => if x ≤ y then x else y }.1 n m = m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_take | [468, 1] | [527, 21] | intro hless | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ n ≤ m → n = m | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
hless : n ≤ m
⊢ n = m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
⊢ n ≤ m → n = m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_take | [468, 1] | [527, 21] | linarith | α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
hless : n ≤ m
⊢ n = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n✝ n : ℕ
ihn : ∀ {m : ℕ} (xs : List α), take n (take m xs) = take (min n m) xs
m : ℕ
h : ¬n ≤ m
x : α
xs : List α
hless : n ≤ m
⊢ n = m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_O | [529, 1] | [531, 12] | rw [drop] | α : Type u_1
xs : List α
⊢ drop 0 xs = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ drop 0 xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_zero | [533, 1] | [535, 12] | rw [drop] | α : Type u_1
xs : List α
⊢ drop zero xs = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ drop zero xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_nil | [537, 1] | [541, 25] | cases n with
| zero => rw [drop]
| succ n' => rw [drop] | α : Type u
n : ℕ
⊢ drop n [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u
n : ℕ
⊢ drop n [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_nil | [537, 1] | [541, 25] | rw [drop] | case zero
α : Type u
⊢ drop zero [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u
⊢ drop zero [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_nil | [537, 1] | [541, 25] | rw [drop] | case succ
α : Type u
n' : ℕ
⊢ drop (succ n') [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u
n' : ℕ
⊢ drop (succ n') [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | revert m xs | α : Type u_1
n m : ℕ
xs : List α
⊢ take m (drop n xs) = drop n (take (n + m) xs) | α : Type u_1
n : ℕ
⊢ ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n m : ℕ
xs : List α
⊢ take m (drop n xs) = drop n (take (n + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | induction n with
| zero =>
intro m xs
rw [Nat.zero_add]
repeat rw [list_drop_zero]
| succ n ih =>
intro m xs
cases xs with
| nil =>
rw [list_drop_nil, list_take_nil, list_take_nil, list_drop_nil]
| cons x xs =>
rw [drop]
rw [nat_add_succ_is_succ_add]
rw [take]
rw [drop]
apply ih | α : Type u_1
n : ℕ
⊢ ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
⊢ ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | intro m xs | case zero
α : Type u_1
⊢ ∀ (m : ℕ) (xs : List α), take m (drop zero xs) = drop zero (take (zero + m) xs) | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m (drop zero xs) = drop zero (take (zero + m) xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
⊢ ∀ (m : ℕ) (xs : List α), take m (drop zero xs) = drop zero (take (zero + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [Nat.zero_add] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m (drop zero xs) = drop zero (take (zero + m) xs) | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m (drop zero xs) = drop zero (take m xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m (drop zero xs) = drop zero (take (zero + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | repeat rw [list_drop_zero] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m (drop zero xs) = drop zero (take m xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m (drop zero xs) = drop zero (take m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [list_drop_zero] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m xs = drop zero (take m xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ take m xs = drop zero (take m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | intro m xs | case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
⊢ ∀ (m : ℕ) (xs : List α), take m (drop (succ n) xs) = drop (succ n) (take (succ n + m) xs) | case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
xs : List α
⊢ take m (drop (succ n) xs) = drop (succ n) (take (succ n + m) xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
⊢ ∀ (m : ℕ) (xs : List α), take m (drop (succ n) xs) = drop (succ n) (take (succ n + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | cases xs with
| nil =>
rw [list_drop_nil, list_take_nil, list_take_nil, list_drop_nil]
| cons x xs =>
rw [drop]
rw [nat_add_succ_is_succ_add]
rw [take]
rw [drop]
apply ih | case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
xs : List α
⊢ take m (drop (succ n) xs) = drop (succ n) (take (succ n + m) xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
xs : List α
⊢ take m (drop (succ n) xs) = drop (succ n) (take (succ n + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [list_drop_nil, list_take_nil, list_take_nil, list_drop_nil] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
⊢ take m (drop (succ n) []) = drop (succ n) (take (succ n + m) []) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
⊢ take m (drop (succ n) []) = drop (succ n) (take (succ n + m) [])
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [drop] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop (succ n) (x :: xs)) = drop (succ n) (take (succ n + m) (x :: xs)) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (take (succ n + m) (x :: xs)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop (succ n) (x :: xs)) = drop (succ n) (take (succ n + m) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [nat_add_succ_is_succ_add] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (take (succ n + m) (x :: xs)) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (take (succ (n + m)) (x :: xs)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (take (succ n + m) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [take] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (take (succ (n + m)) (x :: xs)) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (x :: take (n + m) xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (take (succ (n + m)) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | rw [drop] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (x :: take (n + m) xs) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop n (take (n + m) xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop (succ n) (x :: take (n + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop_comm | [543, 1] | [561, 15] | apply ih | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop n (take (n + m) xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), take m (drop n xs) = drop n (take (n + m) xs)
m : ℕ
x : α
xs : List α
⊢ take m (drop n xs) = drop n (take (n + m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | revert m xs | α : Type u_1
n m : ℕ
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop m xs) | α : Type u_1
n : ℕ
⊢ ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n m : ℕ
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | induction n with
| zero =>
intro m xs
rw [Nat.zero_sub]
repeat rw [list_take_zero]
rw [list_drop_nil]
| succ n ih =>
intro m xs
cases m with
| zero =>
rw [Nat.sub_zero]
repeat rw [list_drop_zero]
| succ m =>
cases xs with
| nil =>
rw [list_take_nil, list_drop_nil, list_take_nil]
| cons x xs =>
rw [take]
rw [drop]
rw [Nat.succ_sub_succ]
rw [drop]
apply ih | α : Type u_1
n : ℕ
⊢ ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
⊢ ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | intro m xs | case zero
α : Type u_1
⊢ ∀ (m : ℕ) (xs : List α), drop m (take zero xs) = take (zero - m) (drop m xs) | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m (take zero xs) = take (zero - m) (drop m xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
⊢ ∀ (m : ℕ) (xs : List α), drop m (take zero xs) = take (zero - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [Nat.zero_sub] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m (take zero xs) = take (zero - m) (drop m xs) | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m (take zero xs) = take 0 (drop m xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m (take zero xs) = take (zero - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | repeat rw [list_take_zero] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m (take zero xs) = take 0 (drop m xs) | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m (take zero xs) = take 0 (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [list_drop_nil] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [list_take_zero] | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m [] = take 0 (drop m xs) | case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
xs : List α
⊢ drop m [] = take 0 (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | intro m xs | case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
⊢ ∀ (m : ℕ) (xs : List α), drop m (take (succ n) xs) = take (succ n - m) (drop m xs) | case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
xs : List α
⊢ drop m (take (succ n) xs) = take (succ n - m) (drop m xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
⊢ ∀ (m : ℕ) (xs : List α), drop m (take (succ n) xs) = take (succ n - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | cases m with
| zero =>
rw [Nat.sub_zero]
repeat rw [list_drop_zero]
| succ m =>
cases xs with
| nil =>
rw [list_take_nil, list_drop_nil, list_take_nil]
| cons x xs =>
rw [take]
rw [drop]
rw [Nat.succ_sub_succ]
rw [drop]
apply ih | case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
xs : List α
⊢ drop m (take (succ n) xs) = take (succ n - m) (drop m xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
xs : List α
⊢ drop m (take (succ n) xs) = take (succ n - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [Nat.sub_zero] | case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ drop zero (take (succ n) xs) = take (succ n - zero) (drop zero xs) | case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ drop zero (take (succ n) xs) = take (succ n) (drop zero xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ drop zero (take (succ n) xs) = take (succ n - zero) (drop zero xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | repeat rw [list_drop_zero] | case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ drop zero (take (succ n) xs) = take (succ n) (drop zero xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ drop zero (take (succ n) xs) = take (succ n) (drop zero xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [list_drop_zero] | case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ take (succ n) xs = take (succ n) (drop zero xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
⊢ take (succ n) xs = take (succ n) (drop zero xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | cases xs with
| nil =>
rw [list_take_nil, list_drop_nil, list_take_nil]
| cons x xs =>
rw [take]
rw [drop]
rw [Nat.succ_sub_succ]
rw [drop]
apply ih | case succ.succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
m : ℕ
⊢ drop (succ m) (take (succ n) xs) = take (succ n - succ m) (drop (succ m) xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
xs : List α
m : ℕ
⊢ drop (succ m) (take (succ n) xs) = take (succ n - succ m) (drop (succ m) xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [list_take_nil, list_drop_nil, list_take_nil] | case succ.succ.nil
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
⊢ drop (succ m) (take (succ n) []) = take (succ n - succ m) (drop (succ m) []) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.nil
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
⊢ drop (succ m) (take (succ n) []) = take (succ n - succ m) (drop (succ m) [])
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [take] | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop (succ m) (take (succ n) (x :: xs)) = take (succ n - succ m) (drop (succ m) (x :: xs)) | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop (succ m) (x :: take n xs) = take (succ n - succ m) (drop (succ m) (x :: xs)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop (succ m) (take (succ n) (x :: xs)) = take (succ n - succ m) (drop (succ m) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [drop] | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop (succ m) (x :: take n xs) = take (succ n - succ m) (drop (succ m) (x :: xs)) | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (succ n - succ m) (drop (succ m) (x :: xs)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop (succ m) (x :: take n xs) = take (succ n - succ m) (drop (succ m) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [Nat.succ_sub_succ] | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (succ n - succ m) (drop (succ m) (x :: xs)) | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop (succ m) (x :: xs)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (succ n - succ m) (drop (succ m) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | rw [drop] | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop (succ m) (x :: xs)) | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop m xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop (succ m) (x :: xs))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_take_comm | [563, 1] | [587, 17] | apply ih | case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop m xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.cons
α : Type u_1
n : ℕ
ih : ∀ (m : ℕ) (xs : List α), drop m (take n xs) = take (n - m) (drop m xs)
m : ℕ
x : α
xs : List α
⊢ drop m (take n xs) = take (n - m) (drop m xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_cons | [589, 1] | [591, 12] | rw [drop] | α : Type u_1
n : ℕ
x : α
xs : List α
⊢ drop (n + 1) (x :: xs) = drop n xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
x : α
xs : List α
⊢ drop (n + 1) (x :: xs) = drop n xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all | [593, 1] | [601, 13] | induction xs with
| nil =>
rw [list_drop_nil]
| cons head tail ih =>
rw [length]
rw [drop]
exact ih | α : Type u_1
xs : List α
⊢ drop (length xs) xs = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ drop (length xs) xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all | [593, 1] | [601, 13] | rw [list_drop_nil] | case nil
α : Type u_1
⊢ drop (length []) [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
⊢ drop (length []) [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all | [593, 1] | [601, 13] | rw [length] | case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length (head :: tail)) (head :: tail) = [] | case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length tail + 1) (head :: tail) = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length (head :: tail)) (head :: tail) = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all | [593, 1] | [601, 13] | rw [drop] | case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length tail + 1) (head :: tail) = [] | case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length tail) tail = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length tail + 1) (head :: tail) = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all | [593, 1] | [601, 13] | exact ih | case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length tail) tail = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
head : α
tail : List α
ih : drop (length tail) tail = []
⊢ drop (length tail) tail = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | revert xs | α : Type u_1
n : ℕ
xs : List α
⊢ length xs ≤ n → drop n xs = [] | α : Type u_1
n : ℕ
⊢ ∀ (xs : List α), length xs ≤ n → drop n xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
xs : List α
⊢ length xs ≤ n → drop n xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | induction n with
| zero =>
intro xs
intro h
have empty_list := list_length_zero_or_smaller_is_empty xs h
rw [empty_list]
rw [drop]
| succ n ih =>
intro xs
cases xs with
| nil =>
rw [length]
intro _
rw [drop]
| cons x xs =>
rw [length]
intro h
rw [drop]
rw [nat_succ_le_succ_iff] at h
exact ih xs h | α : Type u_1
n : ℕ
⊢ ∀ (xs : List α), length xs ≤ n → drop n xs = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
⊢ ∀ (xs : List α), length xs ≤ n → drop n xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | intro xs | case zero
α : Type u_1
⊢ ∀ (xs : List α), length xs ≤ zero → drop zero xs = [] | case zero
α : Type u_1
xs : List α
⊢ length xs ≤ zero → drop zero xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
⊢ ∀ (xs : List α), length xs ≤ zero → drop zero xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | intro h | case zero
α : Type u_1
xs : List α
⊢ length xs ≤ zero → drop zero xs = [] | case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
⊢ drop zero xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
⊢ length xs ≤ zero → drop zero xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | have empty_list := list_length_zero_or_smaller_is_empty xs h | case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
⊢ drop zero xs = [] | case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
empty_list : xs = []
⊢ drop zero xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
⊢ drop zero xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [empty_list] | case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
empty_list : xs = []
⊢ drop zero xs = [] | case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
empty_list : xs = []
⊢ drop zero [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
empty_list : xs = []
⊢ drop zero xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [drop] | case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
empty_list : xs = []
⊢ drop zero [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
h : length xs ≤ zero
empty_list : xs = []
⊢ drop zero [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | intro xs | case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ ∀ (xs : List α), length xs ≤ succ n → drop (succ n) xs = [] | case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
xs : List α
⊢ length xs ≤ succ n → drop (succ n) xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ ∀ (xs : List α), length xs ≤ succ n → drop (succ n) xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | cases xs with
| nil =>
rw [length]
intro _
rw [drop]
| cons x xs =>
rw [length]
intro h
rw [drop]
rw [nat_succ_le_succ_iff] at h
exact ih xs h | case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
xs : List α
⊢ length xs ≤ succ n → drop (succ n) xs = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
xs : List α
⊢ length xs ≤ succ n → drop (succ n) xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [length] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ length [] ≤ succ n → drop (succ n) [] = [] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ 0 ≤ succ n → drop (succ n) [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ length [] ≤ succ n → drop (succ n) [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | intro _ | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ 0 ≤ succ n → drop (succ n) [] = [] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
a✝ : 0 ≤ succ n
⊢ drop (succ n) [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
⊢ 0 ≤ succ n → drop (succ n) [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [drop] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
a✝ : 0 ≤ succ n
⊢ drop (succ n) [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
a✝ : 0 ≤ succ n
⊢ drop (succ n) [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [length] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
⊢ length (x :: xs) ≤ succ n → drop (succ n) (x :: xs) = [] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
⊢ length xs + 1 ≤ succ n → drop (succ n) (x :: xs) = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
⊢ length (x :: xs) ≤ succ n → drop (succ n) (x :: xs) = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | intro h | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
⊢ length xs + 1 ≤ succ n → drop (succ n) (x :: xs) = [] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs + 1 ≤ succ n
⊢ drop (succ n) (x :: xs) = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
⊢ length xs + 1 ≤ succ n → drop (succ n) (x :: xs) = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [drop] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs + 1 ≤ succ n
⊢ drop (succ n) (x :: xs) = [] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs + 1 ≤ succ n
⊢ drop n xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs + 1 ≤ succ n
⊢ drop (succ n) (x :: xs) = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | rw [nat_succ_le_succ_iff] at h | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs + 1 ≤ succ n
⊢ drop n xs = [] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs ≤ n
⊢ drop n xs = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs + 1 ≤ succ n
⊢ drop n xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_drop_all2 | [603, 1] | [625, 20] | exact ih xs h | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs ≤ n
⊢ drop n xs = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), length xs ≤ n → drop n xs = []
x : α
xs : List α
h : length xs ≤ n
⊢ drop n xs = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | revert xs | α : Type u_1
n : ℕ
xs : List α
⊢ take n xs ++ drop n xs = xs | α : Type u_1
n : ℕ
⊢ ∀ (xs : List α), take n xs ++ drop n xs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
xs : List α
⊢ take n xs ++ drop n xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | induction n with
| zero =>
intro xs
rw [take]
rw [drop]
rw [list_app_nil_l]
| succ n ih =>
intro xs
cases xs with
| nil =>
rw [take, drop]
simp only [append_nil]
| cons x xs =>
rw [take, drop]
apply (congrArg (cons x))
apply ih | α : Type u_1
n : ℕ
⊢ ∀ (xs : List α), take n xs ++ drop n xs = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
⊢ ∀ (xs : List α), take n xs ++ drop n xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | intro xs | case zero
α : Type u_1
⊢ ∀ (xs : List α), take zero xs ++ drop zero xs = xs | case zero
α : Type u_1
xs : List α
⊢ take zero xs ++ drop zero xs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
⊢ ∀ (xs : List α), take zero xs ++ drop zero xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | rw [take] | case zero
α : Type u_1
xs : List α
⊢ take zero xs ++ drop zero xs = xs | case zero
α : Type u_1
xs : List α
⊢ [] ++ drop zero xs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
⊢ take zero xs ++ drop zero xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | rw [drop] | case zero
α : Type u_1
xs : List α
⊢ [] ++ drop zero xs = xs | case zero
α : Type u_1
xs : List α
⊢ [] ++ xs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
⊢ [] ++ drop zero xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | rw [list_app_nil_l] | case zero
α : Type u_1
xs : List α
⊢ [] ++ xs = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
⊢ [] ++ xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | intro xs | case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ ∀ (xs : List α), take (succ n) xs ++ drop (succ n) xs = xs | case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
xs : List α
⊢ take (succ n) xs ++ drop (succ n) xs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ ∀ (xs : List α), take (succ n) xs ++ drop (succ n) xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | cases xs with
| nil =>
rw [take, drop]
simp only [append_nil]
| cons x xs =>
rw [take, drop]
apply (congrArg (cons x))
apply ih | case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
xs : List α
⊢ take (succ n) xs ++ drop (succ n) xs = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
xs : List α
⊢ take (succ n) xs ++ drop (succ n) xs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | rw [take, drop] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ take (succ n) [] ++ drop (succ n) [] = [] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ [] ++ [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ take (succ n) [] ++ drop (succ n) [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | simp only [append_nil] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ [] ++ [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
⊢ [] ++ [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | rw [take, drop] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ take (succ n) (x :: xs) ++ drop (succ n) (x :: xs) = x :: xs | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ x :: take n xs ++ drop n xs = x :: xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ take (succ n) (x :: xs) ++ drop (succ n) (x :: xs) = x :: xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | apply (congrArg (cons x)) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ x :: take n xs ++ drop n xs = x :: xs | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ List.append (take n xs) (drop n xs) = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ x :: take n xs ++ drop n xs = x :: xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_drop | [627, 1] | [645, 15] | apply ih | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ List.append (take n xs) (drop n xs) = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ (xs : List α), take n xs ++ drop n xs = xs
x : α
xs : List α
⊢ List.append (take n xs) (drop n xs) = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_gt_succ | [647, 1] | [655, 32] | intro h | n m : ℕ
⊢ succ n > succ m → n > m | n m : ℕ
h : succ n > succ m
⊢ n > m | Please generate a tactic in lean4 to solve the state.
STATE:
n m : ℕ
⊢ succ n > succ m → n > m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_gt_succ | [647, 1] | [655, 32] | cases h with
| refl =>
constructor
| step s =>
apply Nat.le_of_succ_le_succ
exact (Nat.le_succ_of_le s) | n m : ℕ
h : succ n > succ m
⊢ n > m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : ℕ
h : succ n > succ m
⊢ n > m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_gt_succ | [647, 1] | [655, 32] | constructor | case refl
m : ℕ
⊢ succ m > m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
m : ℕ
⊢ succ m > m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_gt_succ | [647, 1] | [655, 32] | apply Nat.le_of_succ_le_succ | case step
n m : ℕ
s : Nat.le (succ (succ m)) n
⊢ n > m | case step.a
n m : ℕ
s : Nat.le (succ (succ m)) n
⊢ succ (succ m) ≤ succ n | Please generate a tactic in lean4 to solve the state.
STATE:
case step
n m : ℕ
s : Nat.le (succ (succ m)) n
⊢ n > m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_gt_succ | [647, 1] | [655, 32] | exact (Nat.le_succ_of_le s) | case step.a
n m : ℕ
s : Nat.le (succ (succ m)) n
⊢ succ (succ m) ≤ succ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case step.a
n m : ℕ
s : Nat.le (succ (succ m)) n
⊢ succ (succ m) ≤ succ n
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_gt_succ' | [657, 1] | [659, 31] | apply Nat.le_of_succ_le_succ | n m : ℕ
⊢ succ n > succ m → n > m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : ℕ
⊢ succ n > succ m → n > m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | revert xs | α : Type u_1
n : ℕ
xs : List α
⊢ n > length xs → length (take n xs) = length xs | α : Type u_1
n : ℕ
⊢ ∀ {xs : List α}, n > length xs → length (take n xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
xs : List α
⊢ n > length xs → length (take n xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | induction n with
| zero =>
intro xs
intro h
contradiction
| succ n ih =>
intro xs
intro h
cases xs with
| nil =>
rw [take]
| cons x xs =>
rw [take]
repeat rw [length]
apply congrArg succ
rw [length] at h
have h' := nat_succ_gt_succ h
exact ih h' | α : Type u_1
n : ℕ
⊢ ∀ {xs : List α}, n > length xs → length (take n xs) = length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
⊢ ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | intro xs | case zero
α : Type u_1
⊢ ∀ {xs : List α}, zero > length xs → length (take zero xs) = length xs | case zero
α : Type u_1
xs : List α
⊢ zero > length xs → length (take zero xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
⊢ ∀ {xs : List α}, zero > length xs → length (take zero xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | intro h | case zero
α : Type u_1
xs : List α
⊢ zero > length xs → length (take zero xs) = length xs | case zero
α : Type u_1
xs : List α
h : zero > length xs
⊢ length (take zero xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
⊢ zero > length xs → length (take zero xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | contradiction | case zero
α : Type u_1
xs : List α
h : zero > length xs
⊢ length (take zero xs) = length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
xs : List α
h : zero > length xs
⊢ length (take zero xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | intro xs | case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
⊢ ∀ {xs : List α}, succ n > length xs → length (take (succ n) xs) = length xs | case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
xs : List α
⊢ succ n > length xs → length (take (succ n) xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
⊢ ∀ {xs : List α}, succ n > length xs → length (take (succ n) xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | intro h | case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
xs : List α
⊢ succ n > length xs → length (take (succ n) xs) = length xs | case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
xs : List α
h : succ n > length xs
⊢ length (take (succ n) xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
xs : List α
⊢ succ n > length xs → length (take (succ n) xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | cases xs with
| nil =>
rw [take]
| cons x xs =>
rw [take]
repeat rw [length]
apply congrArg succ
rw [length] at h
have h' := nat_succ_gt_succ h
exact ih h' | case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
xs : List α
h : succ n > length xs
⊢ length (take (succ n) xs) = length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
xs : List α
h : succ n > length xs
⊢ length (take (succ n) xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | rw [take] | case succ.nil
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
h : succ n > length []
⊢ length (take (succ n) []) = length [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.nil
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
h : succ n > length []
⊢ length (take (succ n) []) = length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | rw [take] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take (succ n) (x :: xs)) = length (x :: xs) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (x :: take n xs) = length (x :: xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take (succ n) (x :: xs)) = length (x :: xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | repeat rw [length] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (x :: take n xs) = length (x :: xs) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) + 1 = length xs + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (x :: take n xs) = length (x :: xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | apply congrArg succ | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) + 1 = length xs + 1 | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) + 1 = length xs + 1
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | rw [length] at h | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) = length xs | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length xs + 1
⊢ length (take n xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | have h' := nat_succ_gt_succ h | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length xs + 1
⊢ length (take n xs) = length xs | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length xs + 1
h' : n > length xs
⊢ length (take n xs) = length xs | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length xs + 1
⊢ length (take n xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | exact ih h' | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length xs + 1
h' : n > length xs
⊢ length (take n xs) = length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length xs + 1
h' : n > length xs
⊢ length (take n xs) = length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_take_large_length | [661, 1] | [681, 18] | rw [length] | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) + 1 = length (x :: xs) | case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) + 1 = length xs + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.cons
α : Type u_1
n : ℕ
ih : ∀ {xs : List α}, n > length xs → length (take n xs) = length xs
x : α
xs : List α
h : succ n > length (x :: xs)
⊢ length (take n xs) + 1 = length (x :: xs)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.