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_length_prefix_is_prefix | [822, 1] | [829, 13] | exact ih | case cons
α : Type u_1
ys : List α
x : α
xs : List α
ih : take (length xs) (xs ++ ys) = xs
⊢ take (length xs) (xs ++ ys) = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
ys : List α
x : α
xs : List α
ih : take (length xs) (xs ++ ys) = xs
⊢ take (length xs) (xs ++ ys) = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_length_leq | [831, 1] | [836, 15] | intro xs ys zs xsyszs | α : Type u_1
⊢ ∀ (xs ys zs : List α), xs ++ ys = zs → length xs ≤ length zs | α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ length xs ≤ length zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (xs ys zs : List α), xs ++ ys = zs → length xs ≤ length zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_length_leq | [831, 1] | [836, 15] | apply (list_prefix_leq_length zs xs ys) | α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ length xs ≤ length zs | α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ zs = xs ++ ys | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ length xs ≤ length zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_length_leq | [831, 1] | [836, 15] | apply Eq.symm | α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ zs = xs ++ ys | case h
α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ xs ++ ys = zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ zs = xs ++ ys
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_length_leq | [831, 1] | [836, 15] | exact xsyszs | case h
α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ xs ++ ys = zs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
xs ys zs : List α
xsyszs : xs ++ ys = zs
⊢ xs ++ ys = zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | intro xs | α : Type u_1
⊢ ∀ (xs : List α), xs ≠ [] → 0 < length xs | α : Type u_1
xs : List α
⊢ xs ≠ [] → 0 < length xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (xs : List α), xs ≠ [] → 0 < length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | cases xs with
| nil =>
intro h
contradiction
| cons x xs =>
intro _
rw [length]
apply Nat.zero_lt_succ | α : Type u_1
xs : List α
⊢ xs ≠ [] → 0 < length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ xs ≠ [] → 0 < length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | intro h | case nil
α : Type u_1
⊢ [] ≠ [] → 0 < length [] | case nil
α : Type u_1
h : [] ≠ []
⊢ 0 < length [] | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
⊢ [] ≠ [] → 0 < length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | contradiction | case nil
α : Type u_1
h : [] ≠ []
⊢ 0 < length [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
h : [] ≠ []
⊢ 0 < length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | intro _ | case cons
α : Type u_1
x : α
xs : List α
⊢ x :: xs ≠ [] → 0 < length (x :: xs) | case cons
α : Type u_1
x : α
xs : List α
a✝ : x :: xs ≠ []
⊢ 0 < length (x :: xs) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
x : α
xs : List α
⊢ x :: xs ≠ [] → 0 < length (x :: xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | rw [length] | case cons
α : Type u_1
x : α
xs : List α
a✝ : x :: xs ≠ []
⊢ 0 < length (x :: xs) | case cons
α : Type u_1
x : α
xs : List α
a✝ : x :: xs ≠ []
⊢ 0 < length xs + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
x : α
xs : List α
a✝ : x :: xs ≠ []
⊢ 0 < length (x :: xs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_length_gt_zero | [838, 1] | [848, 27] | apply Nat.zero_lt_succ | case cons
α : Type u_1
x : α
xs : List α
a✝ : x :: xs ≠ []
⊢ 0 < length xs + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
x : α
xs : List α
a✝ : x :: xs ≠ []
⊢ 0 < length xs + 1
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | intro xs ys zs | α : Type u_1
⊢ ∀ (xs ys zs : List α), xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs | α : Type u_1
xs ys zs : List α
⊢ xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (xs ys zs : List α), xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | revert xs ys | α : Type u_1
xs ys zs : List α
⊢ xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs | α : Type u_1
zs : List α
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
⊢ xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | cases zs with
| nil =>
intro xs ys hneq ha
rw [list_app_nil_nil] at ha
cases ha with
| intro hxs hys =>
contradiction
| cons z zs =>
intro xs ys hneq ha
have hl := list_length_gt_zero _ hneq
rw [<- ha]
apply And.intro
case left =>
exact hl
case right =>
rw [list_app_length]
apply Nat.le_add_right | α : Type u_1
zs : List α
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
zs : List α
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = zs → 0 < length xs ∧ length xs ≤ length zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | intro xs ys hneq ha | case nil
α : Type u_1
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = [] → 0 < length xs ∧ length xs ≤ length [] | case nil
α : Type u_1
xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = []
⊢ 0 < length xs ∧ length xs ≤ length [] | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = [] → 0 < length xs ∧ length xs ≤ length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | rw [list_app_nil_nil] at ha | case nil
α : Type u_1
xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = []
⊢ 0 < length xs ∧ length xs ≤ length [] | case nil
α : Type u_1
xs ys : List α
hneq : xs ≠ []
ha : xs = [] ∧ ys = []
⊢ 0 < length xs ∧ length xs ≤ length [] | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = []
⊢ 0 < length xs ∧ length xs ≤ length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | cases ha with
| intro hxs hys =>
contradiction | case nil
α : Type u_1
xs ys : List α
hneq : xs ≠ []
ha : xs = [] ∧ ys = []
⊢ 0 < length xs ∧ length xs ≤ length [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
xs ys : List α
hneq : xs ≠ []
ha : xs = [] ∧ ys = []
⊢ 0 < length xs ∧ length xs ≤ length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | contradiction | case nil.intro
α : Type u_1
xs ys : List α
hneq : xs ≠ []
hxs : xs = []
hys : ys = []
⊢ 0 < length xs ∧ length xs ≤ length [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.intro
α : Type u_1
xs ys : List α
hneq : xs ≠ []
hxs : xs = []
hys : ys = []
⊢ 0 < length xs ∧ length xs ≤ length []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | intro xs ys hneq ha | case cons
α : Type u_1
z : α
zs : List α
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = z :: zs → 0 < length xs ∧ length xs ≤ length (z :: zs) | case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
⊢ 0 < length xs ∧ length xs ≤ length (z :: zs) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
z : α
zs : List α
⊢ ∀ (xs ys : List α), xs ≠ [] → xs ++ ys = z :: zs → 0 < length xs ∧ length xs ≤ length (z :: zs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | have hl := list_length_gt_zero _ hneq | case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
⊢ 0 < length xs ∧ length xs ≤ length (z :: zs) | case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs ∧ length xs ≤ length (z :: zs) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
⊢ 0 < length xs ∧ length xs ≤ length (z :: zs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | rw [<- ha] | case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs ∧ length xs ≤ length (z :: zs) | case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs ∧ length xs ≤ length (xs ++ ys) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs ∧ length xs ≤ length (z :: zs)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | apply And.intro | case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs ∧ length xs ≤ length (xs ++ ys) | case cons.left
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs
case cons.right
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length (xs ++ ys) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs ∧ length xs ≤ length (xs ++ ys)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | case left =>
exact hl | α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | case right =>
rw [list_app_length]
apply Nat.le_add_right | α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length (xs ++ ys) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length (xs ++ ys)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | exact hl | α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ 0 < length xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | rw [list_app_length] | α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length (xs ++ ys) | α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length xs + length ys | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length (xs ++ ys)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_gt_zero_and_leq | [850, 1] | [872, 29] | apply Nat.le_add_right | α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length xs + length ys | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
z : α
zs xs ys : List α
hneq : xs ≠ []
ha : xs ++ ys = z :: zs
hl : 0 < length xs
⊢ length xs ≤ length xs + length ys
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | intro xs n range h | α : Type u_1
⊢ ∀ (xs : List α) (n : ℕ), 0 < n ∧ n ≤ length xs → take n xs ≠ [] | α : Type u_1
xs : List α
n : ℕ
range : 0 < n ∧ n ≤ length xs
h : take n xs = []
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (xs : List α) (n : ℕ), 0 < n ∧ n ≤ length xs → take n xs ≠ []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | cases range with
| intro notzero max =>
cases n with
| zero =>
contradiction
| succ n =>
cases xs with
| nil =>
contradiction
| cons x xs =>
simp only [succ_pos', take] at * | α : Type u_1
xs : List α
n : ℕ
range : 0 < n ∧ n ≤ length xs
h : take n xs = []
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
n : ℕ
range : 0 < n ∧ n ≤ length xs
h : take n xs = []
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | cases n with
| zero =>
contradiction
| succ n =>
cases xs with
| nil =>
contradiction
| cons x xs =>
simp only [succ_pos', take] at * | case intro
α : Type u_1
xs : List α
n : ℕ
h : take n xs = []
notzero : 0 < n
max : n ≤ length xs
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
α : Type u_1
xs : List α
n : ℕ
h : take n xs = []
notzero : 0 < n
max : n ≤ length xs
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | contradiction | case intro.zero
α : Type u_1
xs : List α
h : take zero xs = []
notzero : 0 < zero
max : zero ≤ length xs
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.zero
α : Type u_1
xs : List α
h : take zero xs = []
notzero : 0 < zero
max : zero ≤ length xs
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | cases xs with
| nil =>
contradiction
| cons x xs =>
simp only [succ_pos', take] at * | case intro.succ
α : Type u_1
xs : List α
n : ℕ
h : take (succ n) xs = []
notzero : 0 < succ n
max : succ n ≤ length xs
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.succ
α : Type u_1
xs : List α
n : ℕ
h : take (succ n) xs = []
notzero : 0 < succ n
max : succ n ≤ length xs
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | contradiction | case intro.succ.nil
α : Type u_1
n : ℕ
notzero : 0 < succ n
h : take (succ n) [] = []
max : succ n ≤ length []
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.succ.nil
α : Type u_1
n : ℕ
notzero : 0 < succ n
h : take (succ n) [] = []
max : succ n ≤ length []
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_prefix_is_not_empty_with_index_gt_zero | [874, 1] | [888, 41] | simp only [succ_pos', take] at * | case intro.succ.cons
α : Type u_1
n : ℕ
notzero : 0 < succ n
x : α
xs : List α
h : take (succ n) (x :: xs) = []
max : succ n ≤ length (x :: xs)
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.succ.cons
α : Type u_1
n : ℕ
notzero : 0 < succ n
x : α
xs : List α
h : take (succ n) (x :: xs) = []
max : succ n ≤ length (x :: xs)
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | intro x xs ys zs H | α : Type u_1
⊢ ∀ {x : α} {xs ys zs : List α},
ys ++ zs = x :: xs → ys = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : ys = x :: ys'), ys' ++ zs = xs | α : Type u_1
x : α
xs ys zs : List α
H : ys ++ zs = x :: xs
⊢ ys = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : ys = x :: ys'), ys' ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ {x : α} {xs ys zs : List α},
ys ++ zs = x :: xs → ys = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : ys = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | apply Or.inl | case nil
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : [] = x :: ys'), ys' ++ zs = xs | case nil.h
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = [] ∧ zs = x :: xs | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : [] = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | apply And.intro | case nil.h
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = [] ∧ zs = x :: xs | case nil.h.left
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = []
case nil.h.right
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ zs = x :: xs | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.h
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = [] ∧ zs = x :: xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | rfl | case nil.h.left
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.h.left
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | simp only [nil_append] at H | case nil.h.right
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ zs = x :: xs | case nil.h.right
α : Type u_1
x : α
xs zs : List α
H : zs = x :: xs
⊢ zs = x :: xs | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.h.right
α : Type u_1
x : α
xs zs : List α
H : [] ++ zs = x :: xs
⊢ zs = x :: xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | assumption | case nil.h.right
α : Type u_1
x : α
xs zs : List α
H : zs = x :: xs
⊢ zs = x :: xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil.h.right
α : Type u_1
x : α
xs zs : List α
H : zs = x :: xs
⊢ zs = x :: xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | apply Or.inr | case cons
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
⊢ y_ :: ys_ = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
⊢ y_ :: ys_ = [] ∧ zs = x :: xs ∨ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | have H' := list_cons_eq.mp H | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | have HR := H'.right | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | have HL := H'.left | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | apply Exists.intro ys_ | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ (_ : y_ :: ys_ = x :: ys_), ys_ ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ ys', ∃ (_ : y_ :: ys_ = x :: ys'), ys' ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | rw [HL] | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ (_ : y_ :: ys_ = x :: ys_), ys_ ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ (_ : x :: ys_ = x :: ys_), ys_ ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ (_ : y_ :: ys_ = x :: ys_), ys_ ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | apply Exists.intro rfl | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ (_ : x :: ys_ = x :: ys_), ys_ ++ zs = xs | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ys_ ++ zs = xs | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ∃ (_ : x :: ys_ = x :: ys_), ys_ ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_uncons | [890, 1] | [918, 13] | exact HR | case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ys_ ++ zs = xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h
α : Type u_1
x : α
xs zs : List α
y_ : α
ys_ : List α
H : y_ :: ys_ ++ zs = x :: xs
H' : y_ = x ∧ List.append ys_ zs = xs
HR : List.append ys_ zs = xs
HL : y_ = x
⊢ ys_ ++ zs = xs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_head | [920, 1] | [924, 13] | intro xs ys zs H | α : Type u_1
⊢ ∀ {xs ys zs : List α}, xs ++ ys = xs ++ zs → ys = zs | α : Type u_1
xs ys zs : List α
H : xs ++ ys = xs ++ zs
⊢ ys = zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ {xs ys zs : List α}, xs ++ ys = xs ++ zs → ys = zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_head | [920, 1] | [924, 13] | simp only [append_cancel_left_eq] at H | α : Type u_1
xs ys zs : List α
H : xs ++ ys = xs ++ zs
⊢ ys = zs | α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ ys = zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : xs ++ ys = xs ++ zs
⊢ ys = zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_head | [920, 1] | [924, 13] | assumption | α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ ys = zs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ ys = zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_head_reverse | [926, 1] | [930, 13] | intro xs ys zs H | α : Type u_1
⊢ ∀ {xs ys zs : List α}, ys = zs → xs ++ ys = xs ++ zs | α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ xs ++ ys = xs ++ zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ {xs ys zs : List α}, ys = zs → xs ++ ys = xs ++ zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_head_reverse | [926, 1] | [930, 13] | simp only [append_cancel_left_eq] | α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ xs ++ ys = xs ++ zs | α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ ys = zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ xs ++ ys = xs ++ zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_head_reverse | [926, 1] | [930, 13] | assumption | α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ ys = zs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : ys = zs
⊢ ys = zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_tail | [932, 1] | [936, 13] | intro xs ys zs H | α : Type u_1
⊢ ∀ {xs ys zs : List α}, xs ++ zs = ys ++ zs → xs = ys | α : Type u_1
xs ys zs : List α
H : xs ++ zs = ys ++ zs
⊢ xs = ys | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ {xs ys zs : List α}, xs ++ zs = ys ++ zs → xs = ys
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_tail | [932, 1] | [936, 13] | simp only [append_cancel_right_eq] at H | α : Type u_1
xs ys zs : List α
H : xs ++ zs = ys ++ zs
⊢ xs = ys | α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs = ys | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : xs ++ zs = ys ++ zs
⊢ xs = ys
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_tail | [932, 1] | [936, 13] | assumption | α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs = ys | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs = ys
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_tail_reverse | [938, 1] | [942, 13] | intro xs ys zs H | α : Type u_1
⊢ ∀ {xs ys zs : List α}, xs = ys → xs ++ zs = ys ++ zs | α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs ++ zs = ys ++ zs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ {xs ys zs : List α}, xs = ys → xs ++ zs = ys ++ zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_tail_reverse | [938, 1] | [942, 13] | simp only [append_cancel_right_eq] | α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs ++ zs = ys ++ zs | α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs = ys | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs ++ zs = ys ++ zs
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | list_app_inv_tail_reverse | [938, 1] | [942, 13] | assumption | α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs = ys | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs ys zs : List α
H : xs = ys
⊢ xs = ys
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Simp.lean | nat_min_zero | [5, 9] | [9, 7] | unfold min | n : Nat
⊢ min 0 n = 0 | n : Nat
⊢ instMinNat.1 0 n = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
⊢ min 0 n = 0
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Simp.lean | nat_min_zero | [5, 9] | [9, 7] | unfold instMinNat | n : Nat
⊢ instMinNat.1 0 n = 0 | n : Nat
⊢ minOfLe.1 0 n = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
⊢ instMinNat.1 0 n = 0
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Simp.lean | nat_min_zero | [5, 9] | [9, 7] | unfold minOfLe | n : Nat
⊢ minOfLe.1 0 n = 0 | n : Nat
⊢ { min := fun x y => if x ≤ y then x else y }.1 0 n = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
⊢ minOfLe.1 0 n = 0
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Simp.lean | nat_min_zero | [5, 9] | [9, 7] | simp | n : Nat
⊢ { min := fun x y => if x ≤ y then x else y }.1 0 n = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
⊢ { min := fun x y => if x ≤ y then x else y }.1 0 n = 0
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Simp.lean | nat_min_zero' | [11, 1] | [12, 7] | simp | n : Nat
⊢ min 0 n = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
⊢ min 0 n = 0
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptySet | [69, 1] | [74, 6] | intro α | ⊢ (α : Type) → ν' ∅ ≡ PEmpty.{1} | α : Type
⊢ ν' ∅ ≡ PEmpty.{1} | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ (α : Type) → ν' ∅ ≡ PEmpty.{1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptySet | [69, 1] | [74, 6] | constructor | α : Type
⊢ ν' ∅ ≡ PEmpty.{1} | case a
α : Type
⊢ ν' ∅ = PEmpty.{1} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ ν' ∅ ≡ PEmpty.{1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptySet | [69, 1] | [74, 6] | rfl | case a
α : Type
⊢ ν' ∅ = PEmpty.{1} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
⊢ ν' ∅ = PEmpty.{1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_universal | [78, 1] | [83, 6] | intro α | ⊢ (α : Type) → ν' 𝒰 ≡ PUnit.{1} | α : Type
⊢ ν' 𝒰 ≡ PUnit.{1} | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ (α : Type) → ν' 𝒰 ≡ PUnit.{1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_universal | [78, 1] | [83, 6] | constructor | α : Type
⊢ ν' 𝒰 ≡ PUnit.{1} | case a
α : Type
⊢ ν' 𝒰 = PUnit.{1} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ ν' 𝒰 ≡ PUnit.{1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_universal | [78, 1] | [83, 6] | rfl | case a
α : Type
⊢ ν' 𝒰 = PUnit.{1} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
⊢ ν' 𝒰 = PUnit.{1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | intro α | ⊢ (α : Type) → ν' ε ≃ PUnit.{u_1} | α : Type
⊢ ν' ε ≃ PUnit.{u_1} | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ (α : Type) → ν' ε ≃ PUnit.{u_1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | refine Equiv.mk ?a ?b ?c ?d | α : Type
⊢ ν' ε ≃ PUnit.{u_1} | case a
α : Type
⊢ ν' ε → PUnit.{u_1}
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b ?a
case d
α : Type
⊢ Function.RightInverse ?b ?a | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ ν' ε ≃ PUnit.{u_1}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | intro _ | case a
α : Type
⊢ ν' ε → PUnit.{u_1}
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b ?a
case d
α : Type
⊢ Function.RightInverse ?b ?a | case a
α : Type
a✝ : ν' ε
⊢ PUnit.{u_1}
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b fun a => ?m.3703 a
case d
α : Type
⊢ Function.RightInverse ?b fun a => ?m.3703 a | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
⊢ ν' ε → PUnit.{u_1}
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b ?a
case d
α : Type
⊢ Function.RightInverse ?b ?a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | exact PUnit.unit | case a
α : Type
a✝ : ν' ε
⊢ PUnit.{u_1}
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b fun a => ?m.3703 a
case d
α : Type
⊢ Function.RightInverse ?b fun a => ?m.3703 a | case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse ?b fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
a✝ : ν' ε
⊢ PUnit.{u_1}
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b fun a => ?m.3703 a
case d
α : Type
⊢ Function.RightInverse ?b fun a => ?m.3703 a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | intro _ | case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse ?b fun a => PUnit.unit | case b
α : Type
a✝ : PUnit.{u_1}
⊢ ν' ε
case c
α : Type
⊢ Function.LeftInverse (fun a => ?m.3707 a) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => ?m.3707 a) fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case b
α : Type
⊢ PUnit.{u_1} → ν' ε
case c
α : Type
⊢ Function.LeftInverse ?b fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse ?b fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | constructor | case b
α : Type
a✝ : PUnit.{u_1}
⊢ ν' ε
case c
α : Type
⊢ Function.LeftInverse (fun a => ?m.3707 a) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => ?m.3707 a) fun a => PUnit.unit | case b.a
α : Type
a✝ : PUnit.{u_1}
⊢ [] = []
case c
α : Type
⊢ Function.LeftInverse (fun a => ?m.3707 a) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => ?m.3707 a) fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case b
α : Type
a✝ : PUnit.{u_1}
⊢ ν' ε
case c
α : Type
⊢ Function.LeftInverse (fun a => ?m.3707 a) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => ?m.3707 a) fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | rfl | case b.a
α : Type
a✝ : PUnit.{u_1}
⊢ [] = []
case c
α : Type
⊢ Function.LeftInverse (fun a => ?m.3707 a) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => ?m.3707 a) fun a => PUnit.unit | case c
α : Type
⊢ Function.LeftInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case b.a
α : Type
a✝ : PUnit.{u_1}
⊢ [] = []
case c
α : Type
⊢ Function.LeftInverse (fun a => ?m.3707 a) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => ?m.3707 a) fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | intro c | case c
α : Type
⊢ Function.LeftInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | case c
α : Type
c : ν' ε
⊢ (fun a => TEq.mk (_ : [] = [])) ((fun a => PUnit.unit) c) = c
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case c
α : Type
⊢ Function.LeftInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | simp | case c
α : Type
c : ν' ε
⊢ (fun a => TEq.mk (_ : [] = [])) ((fun a => PUnit.unit) c) = c
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | case c
α : Type
c : ν' ε
⊢ TEq.mk (_ : [] = []) = c
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case c
α : Type
c : ν' ε
⊢ (fun a => TEq.mk (_ : [] = [])) ((fun a => PUnit.unit) c) = c
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | constructor | case c
α : Type
c : ν' ε
⊢ TEq.mk (_ : [] = []) = c
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | Please generate a tactic in lean4 to solve the state.
STATE:
case c
α : Type
c : ν' ε
⊢ TEq.mk (_ : [] = []) = c
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | intro _ | case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit | case d
α : Type
x✝ : PUnit.{u_1}
⊢ (fun a => PUnit.unit) ((fun a => TEq.mk (_ : [] = [])) x✝) = x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case d
α : Type
⊢ Function.RightInverse (fun a => TEq.mk (_ : [] = [])) fun a => PUnit.unit
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr | [91, 1] | [105, 7] | simp | case d
α : Type
x✝ : PUnit.{u_1}
⊢ (fun a => PUnit.unit) ((fun a => TEq.mk (_ : [] = [])) x✝) = x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case d
α : Type
x✝ : PUnit.{u_1}
⊢ (fun a => PUnit.unit) ((fun a => TEq.mk (_ : [] = [])) x✝) = x✝
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr' | [107, 1] | [114, 14] | constructor | x✝¹ : Type
x✝ : PUnit.{u_1}
⊢ ν' ε | case a
x✝¹ : Type
x✝ : PUnit.{u_1}
⊢ [] = [] | Please generate a tactic in lean4 to solve the state.
STATE:
x✝¹ : Type
x✝ : PUnit.{u_1}
⊢ ν' ε
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_emptyStr' | [107, 1] | [114, 14] | rfl | case a
x✝¹ : Type
x✝ : PUnit.{u_1}
⊢ [] = [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
x✝¹ : Type
x✝ : PUnit.{u_1}
⊢ [] = []
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | intro α | α : Type u_1
⊢ (c : α) → ν' (char c) ≃ PEmpty.{u_2} | α✝ : Type u_1
α : α✝
⊢ ν' (char α) ≃ PEmpty.{u_2} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (c : α) → ν' (char c) ≃ PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | simp | α✝ : Type u_1
α : α✝
⊢ ν' (char α) ≃ PEmpty.{u_2} | α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] ≃ PEmpty.{u_2} | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
α : α✝
⊢ ν' (char α) ≃ PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | apply Equiv.mk | α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] ≃ PEmpty.{u_2} | case left_inv
α✝ : Type u_1
α : α✝
⊢ Function.LeftInverse ?invFun ?toFun
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] ≃ PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | intro x | case left_inv
α✝ : Type u_1
α : α✝
⊢ Function.LeftInverse ?invFun ?toFun
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | case left_inv
α✝ : Type u_1
α : α✝
x : [] ≡ [α]
⊢ ?invFun (?toFun x) = x
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | Please generate a tactic in lean4 to solve the state.
STATE:
case left_inv
α✝ : Type u_1
α : α✝
⊢ Function.LeftInverse ?invFun ?toFun
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α]
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | cases x with
| mk x =>
contradiction | case left_inv
α✝ : Type u_1
α : α✝
x : [] ≡ [α]
⊢ ?invFun (?toFun x) = x
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | Please generate a tactic in lean4 to solve the state.
STATE:
case left_inv
α✝ : Type u_1
α : α✝
x : [] ≡ [α]
⊢ ?invFun (?toFun x) = x
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α]
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | intro | case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | case right_inv
α✝ : Type u_1
α : α✝
x✝ : PEmpty.{u_2}
⊢ ?toFun (?invFun x✝) = x✝
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | Please generate a tactic in lean4 to solve the state.
STATE:
case right_inv
α✝ : Type u_1
α : α✝
⊢ Function.RightInverse ?invFun ?toFun
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α]
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | contradiction | case right_inv
α✝ : Type u_1
α : α✝
x✝ : PEmpty.{u_2}
⊢ ?toFun (?invFun x✝) = x✝
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | Please generate a tactic in lean4 to solve the state.
STATE:
case right_inv
α✝ : Type u_1
α : α✝
x✝ : PEmpty.{u_2}
⊢ ?toFun (?invFun x✝) = x✝
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α]
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | sorry | case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | Please generate a tactic in lean4 to solve the state.
STATE:
case toFun
α✝ : Type u_1
α : α✝
⊢ [] ≡ [α] → PEmpty.{u_2}
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α]
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | sorry | case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case invFun
α✝ : Type u_1
α : α✝
⊢ PEmpty.{u_2} → [] ≡ [α]
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char | [118, 1] | [131, 8] | contradiction | case left_inv.mk
α✝ : Type u_1
α : α✝
x : [] = [α]
⊢ ?invFun (?toFun (TEq.mk x)) = TEq.mk x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left_inv.mk
α✝ : Type u_1
α : α✝
x : [] = [α]
⊢ ?invFun (?toFun (TEq.mk x)) = TEq.mk x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char' | [133, 1] | [141, 18] | intro | α : Type u_1
⊢ (c : α) → ν' (char c) → PEmpty.{u_2} | α : Type u_1
c✝ : α
⊢ ν' (char c✝) → PEmpty.{u_2} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (c : α) → ν' (char c) → PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char' | [133, 1] | [141, 18] | refine (fun x => ?c) | α : Type u_1
c✝ : α
⊢ ν' (char c✝) → PEmpty.{u_2} | case c
α : Type u_1
c✝ : α
x : ν' (char c✝)
⊢ PEmpty.{u_2} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
c✝ : α
⊢ ν' (char c✝) → PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char' | [133, 1] | [141, 18] | simp at x | case c
α : Type u_1
c✝ : α
x : ν' (char c✝)
⊢ PEmpty.{u_2} | case c
α : Type u_1
c✝ : α
x : [] ≡ [c✝]
⊢ PEmpty.{u_2} | Please generate a tactic in lean4 to solve the state.
STATE:
case c
α : Type u_1
c✝ : α
x : ν' (char c✝)
⊢ PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char' | [133, 1] | [141, 18] | cases x with
| mk x =>
contradiction | case c
α : Type u_1
c✝ : α
x : [] ≡ [c✝]
⊢ PEmpty.{u_2} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case c
α : Type u_1
c✝ : α
x : [] ≡ [c✝]
⊢ PEmpty.{u_2}
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.