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/Ltac.lean | anda | [90, 9] | [94, 27] | assumption | a✝ : Prop
a : a✝
⊢ a✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a✝ : Prop
a : a✝
⊢ a✝
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test | [28, 1] | [38, 14] | intro ab bc | α✝ : Type u_1
a b c : α✝
⊢ a ≡ b → b ≡ c → a ≡ c | α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
a b c : α✝
⊢ a ≡ b → b ≡ c → a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test | [28, 1] | [38, 14] | constructor | α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c | case a
α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a = c | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test | [28, 1] | [38, 14] | cases ab with
| mk ab =>
rw [ab]
cases bc with
| mk bc =>
rw [bc] | case a
α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a = c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test | [28, 1] | [38, 14] | rw [ab] | case a.mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ a = c | case a.mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b = c | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ a = c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test | [28, 1] | [38, 14] | cases bc with
| mk bc =>
rw [bc] | case a.mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b = c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test | [28, 1] | [38, 14] | rw [bc] | case a.mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ b = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ b = c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | intro ab bc | α✝ : Type u_1
a b c : α✝
⊢ a ≡ b → b ≡ c → a ≡ c | α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
a b c : α✝
⊢ a ≡ b → b ≡ c → a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | cases ab with
| mk ab =>
rw [ab]
cases bc with
| mk bc =>
rw [bc]
constructor
rfl | α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | rw [ab] | case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ a ≡ c | case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | cases bc with
| mk bc =>
rw [bc]
constructor
rfl | case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b ≡ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | rw [bc] | case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ b ≡ c | case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ b ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | constructor | case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c ≡ c | case mk.mk.a
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test' | [40, 1] | [51, 10] | rfl | case mk.mk.a
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk.a
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c = c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | intro ab bc | α✝ : Type u_1
a b c : α✝
⊢ a ≡ b → b ≡ c → a ≡ c | α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
a b c : α✝
⊢ a ≡ b → b ≡ c → a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | cases ab with
| mk ab =>
rw [ab]
cases bc with
| mk bc =>
rw [bc]
constructor
rfl | α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
a b c : α✝
ab : a ≡ b
bc : b ≡ c
⊢ a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | rw [ab] | case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ a ≡ c | case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ a ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | cases bc with
| mk bc =>
rw [bc]
constructor
rfl | case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b ≡ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
α✝ : Type u_1
a b c : α✝
bc : b ≡ c
ab : a = b
⊢ b ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | rw [bc] | case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ b ≡ c | case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c ≡ c | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ b ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | constructor | case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c ≡ c | case mk.mk.a
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c ≡ c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe2.lean | rewrite_test''' | [58, 1] | [69, 10] | rfl | case mk.mk.a
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk.a
α✝ : Type u_1
a b c : α✝
ab : a = b
bc : b = c
⊢ c = c
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Expr/Desc.lean | cmp_symm | [225, 1] | [228, 8] | sorry | ⊢ ∀ (x y : SmartDesc), Ordering.swap (SmartDesc.compare x y) = SmartDesc.compare y x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (x y : SmartDesc), Ordering.swap (SmartDesc.compare x y) = SmartDesc.compare y x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc | [17, 1] | [20, 25] | intros a b c | ⊢ ∀ (a b c : Ordering), lex (lex a b) c = lex a (lex b c) | a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c) | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (a b c : Ordering), lex (lex a b) c = lex a (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc | [17, 1] | [20, 25] | cases a <;> simp [lex] | a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | cases a | a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c) | case lt
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
case eq
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
case gt
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | {
case lt => rfl
} | case lt
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
case eq
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
case gt
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | case eq
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
case gt
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
case eq
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
case gt
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | case eq => rfl | b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | case gt => rfl | b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | case lt => rfl | b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | rfl | b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | rfl | b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc' | [22, 1] | [29, 17] | rfl | b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc'' | [31, 1] | [36, 14] | cases a with
| eq => rfl
| lt => rfl
| gt => rfl | a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Ordering
⊢ lex (lex a b) c = lex a (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc'' | [31, 1] | [36, 14] | rfl | case eq
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eq
b c : Ordering
⊢ lex (lex eq b) c = lex eq (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc'' | [31, 1] | [36, 14] | rfl | case lt
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc'' | [31, 1] | [36, 14] | rfl | case gt
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case gt
b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc''' | [38, 1] | [43, 26] | rfl | a b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Ordering
⊢ lex (lex lt b) c = lex lt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_assoc''' | [38, 1] | [43, 26] | rfl | a b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Ordering
⊢ lex (lex gt b) c = lex gt (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_left_identity | [45, 1] | [47, 18] | cases a <;> rfl | a : Ordering
⊢ lex eq a = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Ordering
⊢ lex eq a = a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity | [49, 1] | [51, 18] | cases a <;> rfl | a : Ordering
⊢ lex a eq = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Ordering
⊢ lex a eq = a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity' | [53, 1] | [59, 8] | intro x | ⊢ ∀ (x : Ordering), lex x eq = x | x : Ordering
⊢ lex x eq = x | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (x : Ordering), lex x eq = x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity' | [53, 1] | [59, 8] | cases x | x : Ordering
⊢ lex x eq = x | case lt
⊢ lex lt eq = lt
case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt | Please generate a tactic in lean4 to solve the state.
STATE:
x : Ordering
⊢ lex x eq = x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity' | [53, 1] | [59, 8] | rfl | case lt
⊢ lex lt eq = lt | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
⊢ lex lt eq = lt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity' | [53, 1] | [59, 8] | rfl | case eq
⊢ lex eq eq = eq | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eq
⊢ lex eq eq = eq
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity' | [53, 1] | [59, 8] | rfl | case gt
⊢ lex gt eq = gt | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case gt
⊢ lex gt eq = gt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | intro x | ⊢ ∀ (x : Ordering), lex x eq = x | x : Ordering
⊢ lex x eq = x | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (x : Ordering), lex x eq = x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | cases x | x : Ordering
⊢ lex x eq = x | case lt
⊢ lex lt eq = lt
case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt | Please generate a tactic in lean4 to solve the state.
STATE:
x : Ordering
⊢ lex x eq = x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | { rfl } | case lt
⊢ lex lt eq = lt
case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt | case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
⊢ lex lt eq = lt
case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | { rfl } | case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt | case gt
⊢ lex gt eq = gt | Please generate a tactic in lean4 to solve the state.
STATE:
case eq
⊢ lex eq eq = eq
case gt
⊢ lex gt eq = gt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | { rfl } | case gt
⊢ lex gt eq = gt | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case gt
⊢ lex gt eq = gt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | rfl | case lt
⊢ lex lt eq = lt | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
⊢ lex lt eq = lt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | rfl | case eq
⊢ lex eq eq = eq | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eq
⊢ lex eq eq = eq
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Ordering.lean | Ordering.lex_right_identity'' | [61, 1] | [67, 10] | rfl | case gt
⊢ lex gt eq = gt | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case gt
⊢ lex gt eq = gt
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/AlgebraExamples.lean | add_left_identity | [14, 1] | [16, 7] | simp | a : ℕ
⊢ 0 + a = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : ℕ
⊢ 0 + a = a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/AlgebraExamples.lean | add_right_identity | [18, 1] | [20, 7] | simp | a : ℕ
⊢ a + 0 = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : ℕ
⊢ a + 0 = a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/AlgebraExamples.lean | bool_or_assoc | [32, 1] | [38, 9] | intro a b c | ⊢ ∀ (a b c : Bool), (a || b || c) = (a || (b || c)) | a b c : Bool
⊢ (a || b || c) = (a || (b || c)) | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (a b c : Bool), (a || b || c) = (a || (b || c))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/AlgebraExamples.lean | bool_or_assoc | [32, 1] | [38, 9] | cases a with
| false =>
simp
| true =>
simp | a b c : Bool
⊢ (a || b || c) = (a || (b || c)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Bool
⊢ (a || b || c) = (a || (b || c))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/AlgebraExamples.lean | bool_or_assoc | [32, 1] | [38, 9] | simp | case false
b c : Bool
⊢ (false || b || c) = (false || (b || c)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case false
b c : Bool
⊢ (false || b || c) = (false || (b || c))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/AlgebraExamples.lean | bool_or_assoc | [32, 1] | [38, 9] | simp | case true
b c : Bool
⊢ (true || b || c) = (true || (b || c)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case true
b c : Bool
⊢ (true || b || c) = (true || (b || c))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | intros a b c | ⊢ ∀ (a b c : Thunk Ordering), lex (lex a b) c = lex a (lex b c) | a b c : Thunk Ordering
⊢ lex (lex a b) c = lex a (lex b c) | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (a b c : Thunk Ordering), lex (lex a b) c = lex a (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | unfold lex | a b c : Thunk Ordering
⊢ lex (lex a b) c = lex a (lex b c) | a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Thunk.get a with
| Ordering.eq => b
| x => { fn := fun x => Thunk.get a }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Thunk.get a with
| Ordering.eq => b
| x => { fn := fun x => Thunk.get a }) }) =
match Thunk.get a with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Thunk.get a } | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Thunk Ordering
⊢ lex (lex a b) c = lex a (lex b c)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | cases a.get with
| lt => simp only
simp [Thunk.get]
| gt => dsimp
rfl
| eq => dsimp only | a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Thunk.get a with
| Ordering.eq => b
| x => { fn := fun x => Thunk.get a }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Thunk.get a with
| Ordering.eq => b
| x => { fn := fun x => Thunk.get a }) }) =
match Thunk.get a with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Thunk.get a } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Thunk.get a with
| Ordering.eq => b
| x => { fn := fun x => Thunk.get a }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Thunk.get a with
| Ordering.eq => b
| x => { fn := fun x => Thunk.get a }) }) =
match Thunk.get a with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Thunk.get a }
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | simp only | case lt
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Ordering.lt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.lt }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Ordering.lt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.lt }) }) =
match Ordering.lt with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Ordering.lt } | case lt
a b c : Thunk Ordering
⊢ (match Thunk.get { fn := fun x => Ordering.lt } with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get { fn := fun x => Ordering.lt } }) =
{ fn := fun x => Ordering.lt } | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Ordering.lt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.lt }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Ordering.lt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.lt }) }) =
match Ordering.lt with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Ordering.lt }
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | simp [Thunk.get] | case lt
a b c : Thunk Ordering
⊢ (match Thunk.get { fn := fun x => Ordering.lt } with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get { fn := fun x => Ordering.lt } }) =
{ fn := fun x => Ordering.lt } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
a b c : Thunk Ordering
⊢ (match Thunk.get { fn := fun x => Ordering.lt } with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get { fn := fun x => Ordering.lt } }) =
{ fn := fun x => Ordering.lt }
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | dsimp | case gt
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Ordering.gt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.gt }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Ordering.gt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.gt }) }) =
match Ordering.gt with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Ordering.gt } | case gt
a b c : Thunk Ordering
⊢ (match Thunk.get { fn := fun x => Ordering.gt } with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get { fn := fun x => Ordering.gt } }) =
{ fn := fun x => Ordering.gt } | Please generate a tactic in lean4 to solve the state.
STATE:
case gt
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Ordering.gt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.gt }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Ordering.gt with
| Ordering.eq => b
| x => { fn := fun x => Ordering.gt }) }) =
match Ordering.gt with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Ordering.gt }
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | rfl | case gt
a b c : Thunk Ordering
⊢ (match Thunk.get { fn := fun x => Ordering.gt } with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get { fn := fun x => Ordering.gt } }) =
{ fn := fun x => Ordering.gt } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case gt
a b c : Thunk Ordering
⊢ (match Thunk.get { fn := fun x => Ordering.gt } with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get { fn := fun x => Ordering.gt } }) =
{ fn := fun x => Ordering.gt }
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_assoc | [18, 1] | [27, 21] | dsimp only | case eq
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Ordering.eq with
| Ordering.eq => b
| x => { fn := fun x => Ordering.eq }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Ordering.eq with
| Ordering.eq => b
| x => { fn := fun x => Ordering.eq }) }) =
match Ordering.eq with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Ordering.eq } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eq
a b c : Thunk Ordering
⊢ (match
Thunk.get
(match Ordering.eq with
| Ordering.eq => b
| x => { fn := fun x => Ordering.eq }) with
| Ordering.eq => c
| x =>
{
fn := fun x =>
Thunk.get
(match Ordering.eq with
| Ordering.eq => b
| x => { fn := fun x => Ordering.eq }) }) =
match Ordering.eq with
| Ordering.eq =>
match Thunk.get b with
| Ordering.eq => c
| x => { fn := fun x => Thunk.get b }
| x => { fn := fun x => Ordering.eq }
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_left_identity | [29, 1] | [31, 18] | cases a <;> rfl | a : Thunk Ordering
⊢ lex { fn := fun x => Ordering.eq } a = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Thunk Ordering
⊢ lex { fn := fun x => Ordering.eq } a = a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_right_identity | [33, 1] | [39, 8] | unfold lex | a : Thunk Ordering
⊢ lex a { fn := fun x => Ordering.eq } = a | a : Thunk Ordering
⊢ (match Thunk.get a with
| Ordering.eq => { fn := fun x => Ordering.eq }
| x => { fn := fun x => Thunk.get a }) =
a | Please generate a tactic in lean4 to solve the state.
STATE:
a : Thunk Ordering
⊢ lex a { fn := fun x => Ordering.eq } = a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/ThunkOrdering.lean | ThunkOrdering.lex_right_identity | [33, 1] | [39, 8] | cases h: a.get <;>
simp only <;>
rw [<-h] <;>
rfl | a : Thunk Ordering
⊢ (match Thunk.get a with
| Ordering.eq => { fn := fun x => Ordering.eq }
| x => { fn := fun x => Thunk.get a }) =
a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Thunk Ordering
⊢ (match Thunk.get a with
| Ordering.eq => { fn := fun x => Ordering.eq }
| x => { fn := fun x => Thunk.get a }) =
a
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | Eq.all_tequal | [83, 1] | [86, 13] | cases p | α✝ : Sort u_1
x y : α✝
p q : x = y
⊢ p = q | case refl
α✝ : Sort u_1
x : α✝
q : x = x
⊢ (_ : x = x) = q | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Sort u_1
x y : α✝
p q : x = y
⊢ p = q
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | Eq.all_tequal | [83, 1] | [86, 13] | cases q | case refl
α✝ : Sort u_1
x : α✝
q : x = x
⊢ (_ : x = x) = q | case refl.refl
α✝ : Sort u_1
x : α✝
⊢ (_ : x = x) = (_ : x = x) | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α✝ : Sort u_1
x : α✝
q : x = x
⊢ (_ : x = x) = q
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | Eq.all_tequal | [83, 1] | [86, 13] | apply refl | case refl.refl
α✝ : Sort u_1
x : α✝
⊢ (_ : x = x) = (_ : x = x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refl
α✝ : Sort u_1
x : α✝
⊢ (_ : x = x) = (_ : x = x)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | TEq.all_tequal | [88, 1] | [91, 13] | cases p | α✝ : Type u_1
x y : α✝
p q : x ≡ y
⊢ p ≡ q | case refl
α✝ : Type u_1
x : α✝
q : x ≡ x
⊢ refl x ≡ q | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x y : α✝
p q : x ≡ y
⊢ p ≡ q
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | TEq.all_tequal | [88, 1] | [91, 13] | cases q | case refl
α✝ : Type u_1
x : α✝
q : x ≡ x
⊢ refl x ≡ q | case refl.refl
α✝ : Type u_1
x : α✝
⊢ refl x ≡ refl x | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α✝ : Type u_1
x : α✝
q : x ≡ x
⊢ refl x ≡ q
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | TEq.all_tequal | [88, 1] | [91, 13] | apply refl | case refl.refl
α✝ : Type u_1
x : α✝
⊢ refl x ≡ refl x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refl
α✝ : Type u_1
x : α✝
⊢ refl x ≡ refl x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | TEq.all_equal | [93, 1] | [96, 6] | cases p | α✝ : Type u_1
x y : α✝
p q : x ≡ y
⊢ p = q | case refl
α✝ : Type u_1
x : α✝
q : x ≡ x
⊢ refl x = q | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
x y : α✝
p q : x ≡ y
⊢ p = q
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | TEq.all_equal | [93, 1] | [96, 6] | cases q | case refl
α✝ : Type u_1
x : α✝
q : x ≡ x
⊢ refl x = q | case refl.refl
α✝ : Type u_1
x : α✝
⊢ refl x = refl x | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
α✝ : Type u_1
x : α✝
q : x ≡ x
⊢ refl x = q
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | TEq.all_equal | [93, 1] | [96, 6] | rfl | case refl.refl
α✝ : Type u_1
x : α✝
⊢ refl x = refl x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refl
α✝ : Type u_1
x : α✝
⊢ refl x = refl x
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | t | [124, 1] | [126, 16] | intro x | ⊢ 1 ≡ 2 → False | x : 1 ≡ 2
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ 1 ≡ 2 → False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | t | [124, 1] | [126, 16] | contradiction | x : 1 ≡ 2
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x : 1 ≡ 2
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | t'' | [128, 1] | [130, 16] | intro | ⊢ 1 = 2 → False | a✝ : 1 = 2
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ 1 = 2 → False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Tipe.lean | t'' | [128, 1] | [130, 16] | contradiction | a✝ : 1 = 2
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a✝ : 1 = 2
⊢ False
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_le_succ_iff | [15, 1] | [21, 27] | apply Iff.intro | x y : ℕ
⊢ succ x ≤ succ y ↔ x ≤ y | case mp
x y : ℕ
⊢ succ x ≤ succ y → x ≤ y
case mpr
x y : ℕ
⊢ x ≤ y → succ x ≤ succ y | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℕ
⊢ succ x ≤ succ y ↔ x ≤ y
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_le_succ_iff | [15, 1] | [21, 27] | case mp =>
apply Nat.le_of_succ_le_succ | x y : ℕ
⊢ succ x ≤ succ y → x ≤ y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℕ
⊢ succ x ≤ succ y → x ≤ y
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_le_succ_iff | [15, 1] | [21, 27] | case mpr =>
apply Nat.succ_le_succ | x y : ℕ
⊢ x ≤ y → succ x ≤ succ y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℕ
⊢ x ≤ y → succ x ≤ succ y
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_le_succ_iff | [15, 1] | [21, 27] | apply Nat.le_of_succ_le_succ | x y : ℕ
⊢ succ x ≤ succ y → x ≤ y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℕ
⊢ succ x ≤ succ y → x ≤ y
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_le_succ_iff | [15, 1] | [21, 27] | apply Nat.succ_le_succ | x y : ℕ
⊢ x ≤ y → succ x ≤ succ y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℕ
⊢ x ≤ y → succ x ≤ succ y
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_succ_eq_plus_one | [23, 1] | [24, 12] | simp only | n : ℕ
⊢ succ n = n + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ
⊢ succ n = n + 1
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | intro n m h | ⊢ ∀ {n m : ℕ}, Nat.le n (succ m) → Nat.le (pred n) m | n m : ℕ
h : Nat.le n (succ m)
⊢ Nat.le (pred n) m | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ {n m : ℕ}, Nat.le n (succ m) → Nat.le (pred n) m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | cases h with
| refl =>
constructor
| step h =>
cases n with
| zero =>
dsimp only [zero_eq, Nat.pred_zero, le_eq]
exact h
| succ n =>
dsimp only [Nat.pred_succ, le_eq]
have h_n_le_succ_n := Nat.le_succ n
exact (Nat.le_trans h_n_le_succ_n h) | n m : ℕ
h : Nat.le n (succ m)
⊢ Nat.le (pred n) m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : ℕ
h : Nat.le n (succ m)
⊢ Nat.le (pred n) m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | constructor | case refl
m : ℕ
⊢ Nat.le (pred (succ m)) m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
m : ℕ
⊢ Nat.le (pred (succ m)) m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | cases n with
| zero =>
dsimp only [zero_eq, Nat.pred_zero, le_eq]
exact h
| succ n =>
dsimp only [Nat.pred_succ, le_eq]
have h_n_le_succ_n := Nat.le_succ n
exact (Nat.le_trans h_n_le_succ_n h) | case step
n m : ℕ
h : Nat.le n m
⊢ Nat.le (pred n) m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case step
n m : ℕ
h : Nat.le n m
⊢ Nat.le (pred n) m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | dsimp only [zero_eq, Nat.pred_zero, le_eq] | case step.zero
m : ℕ
h : Nat.le zero m
⊢ Nat.le (pred zero) m | case step.zero
m : ℕ
h : Nat.le zero m
⊢ 0 ≤ m | Please generate a tactic in lean4 to solve the state.
STATE:
case step.zero
m : ℕ
h : Nat.le zero m
⊢ Nat.le (pred zero) m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | exact h | case step.zero
m : ℕ
h : Nat.le zero m
⊢ 0 ≤ m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case step.zero
m : ℕ
h : Nat.le zero m
⊢ 0 ≤ m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | dsimp only [Nat.pred_succ, le_eq] | case step.succ
m n : ℕ
h : Nat.le (succ n) m
⊢ Nat.le (pred (succ n)) m | case step.succ
m n : ℕ
h : Nat.le (succ n) m
⊢ n ≤ m | Please generate a tactic in lean4 to solve the state.
STATE:
case step.succ
m n : ℕ
h : Nat.le (succ n) m
⊢ Nat.le (pred (succ n)) m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | have h_n_le_succ_n := Nat.le_succ n | case step.succ
m n : ℕ
h : Nat.le (succ n) m
⊢ n ≤ m | case step.succ
m n : ℕ
h : Nat.le (succ n) m
h_n_le_succ_n : n ≤ succ n
⊢ n ≤ m | Please generate a tactic in lean4 to solve the state.
STATE:
case step.succ
m n : ℕ
h : Nat.le (succ n) m
⊢ n ≤ m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_pred_le_succ' | [32, 1] | [45, 43] | exact (Nat.le_trans h_n_le_succ_n h) | case step.succ
m n : ℕ
h : Nat.le (succ n) m
h_n_le_succ_n : n ≤ succ n
⊢ n ≤ m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case step.succ
m n : ℕ
h : Nat.le (succ n) m
h_n_le_succ_n : n ≤ succ n
⊢ n ≤ m
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_min_zero | [47, 1] | [51, 7] | unfold min | n : ℕ
⊢ min 0 n = 0 | n : ℕ
⊢ instMinNat.1 0 n = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ
⊢ min 0 n = 0
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Std/Lists.lean | nat_min_zero | [47, 1] | [51, 7] | unfold instMinNat | n : ℕ
⊢ instMinNat.1 0 n = 0 | n : ℕ
⊢ minOfLe.1 0 n = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ
⊢ instMinNat.1 0 n = 0
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.