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/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | exists_iff | [183, 1] | [193, 13] | simp [equiv] | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
T : Sort u_1
P Q : T β Prop
equiv : β (t : T), Q t β P t
ex_t : β t, P t
w : T
h : (fun t => P t) w
β’ Q w | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
T : Sort u_1
P Q : T β Prop
equiv : β (t : T), Q t β P t
ex_t : β t, P t
w : T
h : (fun t => P t) w
β’ P w | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
T : Sort u_1
P Q : T β Prop
equiv : β (t : T), Q t β P t
ex_t : β t, P t
w : T
h : (fun t => P t) w
β’ Q w
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | exists_iff | [183, 1] | [193, 13] | exact h | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
T : Sort u_1
P Q : T β Prop
equiv : β (t : T), Q t β P t
ex_t : β t, P t
w : T
h : (fun t => P t) w
β’ P w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
T : Sort u_1
P Q : T β Prop
equiv : β (t : T), Q t β P t
ex_t : β t, P t
w : T
h : (fun t => P t) w
β’ P w
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | intros A f n | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β {A : Sort u_1} (f : A β A) (n : β) (x : A), f^[n + 1] x = f (f^[n] x) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
β’ β (x : A), f^[n + 1] x = f (f^[n] x) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β {A : Sort u_1} (f : A β A) (n : β) (x : A), f^[n + 1] x = f (f^[n] x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | induction' n with n ihn | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
β’ β (x : A), f^[n + 1] x = f (f^[n] x) | case zero
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
β’ β (x : A), f^[Nat.zero + 1] x = f (f^[Nat.zero] x)
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
β’ β (x : A), f^[n + 1] x = f (f^[n] x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | . simp [Nat.iterate] | case zero
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
β’ β (x : A), f^[Nat.zero + 1] x = f (f^[Nat.zero] x)
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x) | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
β’ β (x : A), f^[Nat.zero + 1] x = f (f^[Nat.zero] x)
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | . simp [Nat.add, Nat.iterate]
intros x
apply ihn | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | simp [Nat.iterate] | case zero
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
β’ β (x : A), f^[Nat.zero + 1] x = f (f^[Nat.zero] x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
β’ β (x : A), f^[Nat.zero + 1] x = f (f^[Nat.zero] x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | simp [Nat.add, Nat.iterate] | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x) | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[n] (f (f x)) = f (f^[n] (f x)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[Nat.succ n + 1] x = f (f^[Nat.succ n] x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | intros x | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[n] (f (f x)) = f (f^[n] (f x)) | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
x : A
β’ f^[n] (f (f x)) = f (f^[n] (f x)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
β’ β (x : A), f^[n] (f (f x)) = f (f^[n] (f x))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | iterate_left | [195, 1] | [202, 14] | apply ihn | case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
x : A
β’ f^[n] (f (f x)) = f (f^[n] (f x)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
f : A β A
n : β
ihn : β (x : A), f^[n + 1] x = f (f^[n] x)
x : A
β’ f^[n] (f (f x)) = f (f^[n] (f x))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | intros A Q a forall_exists_Q | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β {A : Sort u_1} (Q : A β A β Prop) (a : A), (β (a : A), β b, Q a b) β β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β {A : Sort u_1} (Q : A β A β Prop) (a : A), (β (a : A), β b, Q a b) β β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | have choice_aut : β f : A β A, β x, Q x (f x) :=
by
apply Classical.axiomOfChoice
exact forall_exists_Q | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | match choice_aut with
| Exists.intro f h =>
exists (Ξ» n β¦ f^[n] a)
apply And.intro
. simp [Nat.iterate]
. intros n
simp
rw [iterate_left]
apply h | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | apply Classical.axiomOfChoice | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, β (x : A), Q x (f x) | case h
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β (x : A), β y, Q x y | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, β (x : A), Q x (f x)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | exact forall_exists_Q | case h
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β (x : A), β y, Q x y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
β’ β (x : A), β y, Q x y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | exists (Ξ» n β¦ f^[n] a) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a β§ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | apply And.intro | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a β§ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | case left
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a β§ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | . simp [Nat.iterate] | case left
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case left
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | . intros n
simp
rw [iterate_left]
apply h | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | simp [Nat.iterate] | case left
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ (fun n => f^[n] a) 0 = a
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | intros n | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
β’ β (n : β), Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | simp | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1)) | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q (f^[n] a) (f^[n + 1] a) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q ((fun n => f^[n] a) n) ((fun n => f^[n] a) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | rw [iterate_left] | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q (f^[n] a) (f^[n + 1] a) | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q (f^[n] a) (f (f^[n] a)) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q (f^[n] a) (f^[n + 1] a)
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice' | [205, 1] | [222, 17] | apply h | case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q (f^[n] a) (f (f^[n] a)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
a : A
forall_exists_Q : β (a : A), β b, Q a b
choice_aut : β f, β (x : A), Q x (f x)
f : A β A
h : (fun f => β (x : A), Q x (f x)) f
n : β
β’ Q (f^[n] a) (f (f^[n] a))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | intros A Q inhab forall_exists_Q | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β {A : Sort u_1} (Q : A β A β Prop), Inhabited A β (β (a : A), β b, Q a b) β β f, β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, β (n : β), Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β {A : Sort u_1} (Q : A β A β Prop), Inhabited A β (β (a : A), β b, Q a b) β β f, β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | have a : A := by match inhab with | Inhabited.mk a => exact a | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
β’ β f, β (n : β), Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
β’ β f, β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | have h := dependent_choice' _ a forall_exists_Q | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
β’ β f, β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
β’ β f, β (n : β), Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
β’ β f, β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | match h with
| Exists.intro f h' =>
exists f
apply h'.2 | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
β’ β f, β (n : β), Q (f n) (f (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
β’ β f, β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | match inhab with | Inhabited.mk a => exact a | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
β’ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
β’ A
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | exact a | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
β’ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
β’ A
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | exists f | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
f : β β A
h' : (fun f => f 0 = a β§ β (n : β), Q (f n) (f (n + 1))) f
β’ β f, β (n : β), Q (f n) (f (n + 1)) | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
f : β β A
h' : (fun f => f 0 = a β§ β (n : β), Q (f n) (f (n + 1))) f
β’ β (n : β), Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
f : β β A
h' : (fun f => f 0 = a β§ β (n : β), Q (f n) (f (n + 1))) f
β’ β f, β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice | [226, 1] | [238, 15] | apply h'.2 | Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
f : β β A
h' : (fun f => f 0 = a β§ β (n : β), Q (f n) (f (n + 1))) f
β’ β (n : β), Q (f n) (f (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Aβ : Type
R : Aβ β Aβ β Prop
inhabited_A : Nonempty Aβ
A : Sort u_1
Q : A β A β Prop
inhab : Inhabited A
forall_exists_Q : β (a : A), β b, Q a b
a : A
h : β f, f 0 = a β§ β (n : β), Q (f n) (f (n + 1))
f : β β A
h' : (fun f => f 0 = a β§ β (n : β), Q (f n) (f (n + 1))) f
β’ β (n : β), Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | intros P Q a pa ex | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (P : A β Prop) (Q : A β A β Prop) (a : A),
P a β (β (a : A), P a β β b, P b β§ Q a b) β β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1)) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (P : A β Prop) (Q : A β A β Prop) (a : A),
P a β (β (a : A), P a β β b, P b β§ Q a b) β β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | have h : β (f : β β {x : A // P x}), f 0 = β¨a, paβ©
β§ β n, P (f n) β§ Q (f n) (f (n+1)) :=
by
apply (@dependent_choice' {x : A // P x} (Ξ» p q => P p β§ Q p q) _)
intros ap
match ap with
| Subtype.mk a' p =>
simp
apply And.intro
. exact p
. match (ex a' p) with
| Exists.intro b β¨pb, qbβ© => exists (Subtype.mk b pb) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1)) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | match h with
| Exists.intro f β¨zf, sfβ© =>
exists (Ξ» n β¦ (f n).val)
simp; rw [zf]; simp
intros n; apply sf | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | apply (@dependent_choice' {x : A // P x} (Ξ» p q => P p β§ Q p q) _) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β (a : { x // P x }), β b, P a.val β§ Q a.val b.val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | intros ap | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β (a : { x // P x }), β b, P a.val β§ Q a.val b.val | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
β’ β b, P ap.val β§ Q ap.val b.val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
β’ β (a : { x // P x }), β b, P a.val β§ Q a.val b.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | match ap with
| Subtype.mk a' p =>
simp
apply And.intro
. exact p
. match (ex a' p) with
| Exists.intro b β¨pb, qbβ© => exists (Subtype.mk b pb) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
β’ β b, P ap.val β§ Q ap.val b.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
β’ β b, P ap.val β§ Q ap.val b.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | simp | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β b, P { val := a', property := p }.val β§ Q { val := a', property := p }.val b.val | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a' β§ β x, Q a' x.val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β b, P { val := a', property := p }.val β§ Q { val := a', property := p }.val b.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | apply And.intro | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a' β§ β x, Q a' x.val | case left
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a'
case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a' β§ β x, Q a' x.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | . exact p | case left
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a'
case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val | case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val | Please generate a tactic in lean4 to solve the state.
STATE:
case left
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a'
case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | . match (ex a' p) with
| Exists.intro b β¨pb, qbβ© => exists (Subtype.mk b pb) | case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | exact p | case left
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ P a'
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | match (ex a' p) with
| Exists.intro b β¨pb, qbβ© => exists (Subtype.mk b pb) | case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
β’ β x, Q a' x.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | exists (Subtype.mk b pb) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
b : A
pb : P b
qb : Q a' b
β’ β x, Q a' x.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
ap : { x // P x }
a' : A
p : (fun x => P x) a'
b : A
pb : P b
qb : Q a' b
β’ β x, Q a' x.val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | exists (Ξ» n β¦ (f n).val) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1)) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ (fun n => (f n).val) 0 = a β§
β (n : β), P ((fun n => (f n).val) n) β§ Q ((fun n => (f n).val) n) ((fun n => (f n).val) (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β f, f 0 = a β§ β (n : β), P (f n) β§ Q (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | simp | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ (fun n => (f n).val) 0 = a β§
β (n : β), P ((fun n => (f n).val) n) β§ Q ((fun n => (f n).val) n) ((fun n => (f n).val) (n + 1)) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ (f 0).val = a β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ (fun n => (f n).val) 0 = a β§
β (n : β), P ((fun n => (f n).val) n) β§ Q ((fun n => (f n).val) n) ((fun n => (f n).val) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | rw [zf] | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ (f 0).val = a β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ { val := a, property := pa }.val = a β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ (f 0).val = a β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | simp | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ { val := a, property := pa }.val = a β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ { val := a, property := pa }.val = a β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | intros n | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
n : β
β’ P (f n).val β§ Q (f n).val (f (n + 1)).val | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
β’ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | dependent_choice'' | [240, 1] | [263, 23] | apply sf | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
n : β
β’ P (f n).val β§ Q (f n).val (f (n + 1)).val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
Q : A β A β Prop
a : A
pa : P a
ex : β (a : A), P a β β b, P b β§ Q a b
h : β f, f 0 = { val := a, property := pa } β§ β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
f : β β { x // P x }
zf : f 0 = { val := a, property := pa }
sf : β (n : β), P (f n).val β§ Q (f n).val (f (n + 1)).val
n : β
β’ P (f n).val β§ Q (f n).val (f (n + 1)).val
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | intros P IH x norm | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), normalizes R x β P x | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
β’ P x | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), normalizes R x β P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply Classical.byContradiction | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
β’ P x | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
β’ Β¬P x β False | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
β’ P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | intro h | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
β’ Β¬P x β False | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
β’ Β¬P x β False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply norm | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ False | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ diverge_from R x | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | have h' : β f : β β A, f 0 = x β§ β n, Β¬ P (f n) β§ f n ~> f (n+1) :=
by
apply (dependent_choice'' (Ξ» a β¦ Β¬ P a))
. exact h
. intros a npa
apply Classical.byContradiction
simp; intros p
apply npa
apply IH; intros y ry
apply Classical.byContradiction; intros npy
apply (p y npy ry) | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ diverge_from R x | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
β’ diverge_from R x | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ diverge_from R x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | rw [diverge_from] | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
β’ diverge_from R x | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
β’ β xs, xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
β’ diverge_from R x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | match h' with
| Exists.intro xs β¨P0, P1β© =>
exists xs; aesop | case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
β’ β xs, xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
β’ β xs, xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply (dependent_choice'' (Ξ» a β¦ Β¬ P a)) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1)) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ Β¬P x
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | . exact h | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ Β¬P x
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ Β¬P x
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | . intros a npa
apply Classical.byContradiction
simp; intros p
apply npa
apply IH; intros y ry
apply Classical.byContradiction; intros npy
apply (p y npy ry) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | exact h | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ Β¬P x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ Β¬P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | intros a npa | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ β b, Β¬P b β§ R a b | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
β’ β (a : A), Β¬P a β β b, Β¬P b β§ R a b
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply Classical.byContradiction | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ β b, Β¬P b β§ R a b | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ (Β¬β b, Β¬P b β§ R a b) β False | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ β b, Β¬P b β§ R a b
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | simp | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ (Β¬β b, Β¬P b β§ R a b) β False | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ (β (x : A), Β¬P x β Β¬R a x) β False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ (Β¬β b, Β¬P b β§ R a b) β False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | intros p | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ (β (x : A), Β¬P x β Β¬R a x) β False | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
β’ (β (x : A), Β¬P x β Β¬R a x) β False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply npa | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ False | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ P a | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply IH | case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ P a | case a.h.a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ β (y : A), R a y β P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ P a
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | intros y ry | case a.h.a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ β (y : A), R a y β P y | case a.h.a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
β’ P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
β’ β (y : A), R a y β P y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply Classical.byContradiction | case a.h.a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
β’ P y | case a.h.a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
β’ Β¬P y β False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
β’ P y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | intros npy | case a.h.a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
β’ Β¬P y β False | case a.h.a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
npy : Β¬P y
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
β’ Β¬P y β False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | apply (p y npy ry) | case a.h.a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
npy : Β¬P y
β’ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.a.h
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
a : A
npa : Β¬P a
p : β (x : A), Β¬P x β Β¬R a x
y : A
ry : R a y
npy : Β¬P y
β’ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | exists xs | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
xs : β β A
P0 : xs 0 = x
P1 : β (n : β), Β¬P (xs n) β§ R (xs n) (xs (n + 1))
β’ β xs, xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1)) | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
xs : β β A
P0 : xs 0 = x
P1 : β (n : β), Β¬P (xs n) β§ R (xs n) (xs (n + 1))
β’ xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
xs : β β A
P0 : xs 0 = x
P1 : β (n : β), Β¬P (xs n) β§ R (xs n) (xs (n + 1))
β’ β xs, xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_ind | [267, 1] | [288, 23] | aesop | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
xs : β β A
P0 : xs 0 = x
P1 : β (n : β), Β¬P (xs n) β§ R (xs n) (xs (n + 1))
β’ xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
x : A
norm : normalizes R x
h : Β¬P x
h' : β f, f 0 = x β§ β (n : β), Β¬P (f n) β§ R (f n) (f (n + 1))
xs : β β A
P0 : xs 0 = x
P1 : β (n : β), Β¬P (xs n) β§ R (xs n) (xs (n + 1))
β’ xs 0 = x β§ β (n : β), R (xs n) (xs (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_ind | [290, 1] | [296, 15] | intros P IH norm x | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β normalizing R β β (x : A), P x | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ P x | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β normalizing R β β (x : A), P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_ind | [290, 1] | [296, 15] | apply normalizes_ind | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ P x | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ β (x : A), (β (y : A), ?R x y β P y) β P x
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes ?R x
case R
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ A β A β Prop | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_ind | [290, 1] | [296, 15] | . apply IH | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ β (x : A), (β (y : A), ?R x y β P y) β P x
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes ?R x
case R
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ A β A β Prop | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes (fun x y => R x y) x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ β (x : A), (β (y : A), ?R x y β P y) β P x
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes ?R x
case R
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ A β A β Prop
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_ind | [290, 1] | [296, 15] | . apply norm | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes (fun x y => R x y) x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes (fun x y => R x y) x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_ind | [290, 1] | [296, 15] | apply IH | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ β (x : A), (β (y : A), ?R x y β P y) β P x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ β (x : A), (β (y : A), ?R x y β P y) β P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_ind | [290, 1] | [296, 15] | apply norm | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes (fun x y => R x y) x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
P : A β Prop
IH : β (x : A), (β (y : A), R x y β P y) β P x
norm : normalizing R
x : A
β’ normalizes (fun x y => R x y) x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | intros ih x | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ (β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x) β normalizing R | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
x : A
β’ normalizes R x | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ (β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x) β normalizing R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | apply ih | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
x : A
β’ normalizes R x | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
x : A
β’ β (x : A), (β (y : A), R x y β normalizes R y) β normalizes R x | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
x : A
β’ normalizes R x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | intros x red_norm div | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
x : A
β’ β (x : A), (β (y : A), R x y β normalizes R y) β normalizes R x | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
div : diverge_from R x
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
x : A
β’ β (x : A), (β (y : A), R x y β normalizes R y) β normalizes R x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | cases div | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
div : diverge_from R x
β’ False | case a.intro
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
wβ : β β A
hβ : wβ 0 = x β§ β (n : β), R (wβ n) (wβ (n + 1))
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
div : diverge_from R x
β’ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | case a.intro f h =>
apply red_norm
. simp [β h.1]
apply h.2 0
. exists (Ξ» n β¦ f (n+1))
simp
intros n; apply h.2 | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | apply red_norm | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ False | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R x ?y
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R ?y
case y
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ A | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | . simp [β h.1]
apply h.2 0 | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R x ?y
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R ?y
case y
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ A | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R (f (0 + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R x ?y
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R ?y
case y
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ A
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | . exists (Ξ» n β¦ f (n+1))
simp
intros n; apply h.2 | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R (f (0 + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R (f (0 + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | simp [β h.1] | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R x ?y | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R (f 0) ?y | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R x ?y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | apply h.2 0 | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R (f 0) ?y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ R (f 0) ?y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | exists (Ξ» n β¦ f (n+1)) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R (f (0 + 1)) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ (fun n => f (n + 1)) 0 = f (0 + 1) β§ β (n : β), R ((fun n => f (n + 1)) n) ((fun n => f (n + 1)) (n + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ diverge_from R (f (0 + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | simp | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ (fun n => f (n + 1)) 0 = f (0 + 1) β§ β (n : β), R ((fun n => f (n + 1)) n) ((fun n => f (n + 1)) (n + 1)) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ β (n : β), R (f (n + 1)) (f (n + 1 + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ (fun n => f (n + 1)) 0 = f (0 + 1) β§ β (n : β), R ((fun n => f (n + 1)) n) ((fun n => f (n + 1)) (n + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | intros n | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ β (n : β), R (f (n + 1)) (f (n + 1 + 1)) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
n : β
β’ R (f (n + 1)) (f (n + 1 + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
β’ β (n : β), R (f (n + 1)) (f (n + 1 + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | ind_normalizing | [299, 1] | [312, 26] | apply h.2 | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
n : β
β’ R (f (n + 1)) (f (n + 1 + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
ih : β (P : A β Prop), (β (x : A), (β (y : A), R x y β P y) β P x) β β (x : A), P x
xβ x : A
red_norm : β (y : A), R x y β normalizes R y
f : β β A
h : f 0 = x β§ β (n : β), R (f n) (f (n + 1))
n : β
β’ R (f (n + 1)) (f (n + 1 + 1))
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | red_ref_trans_clos | [315, 1] | [318, 45] | intros x y z red_x_y h | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (x y z : A), R x y β refl_trans_clos R y z β refl_trans_clos R x z | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x y z : A
red_x_y : R x y
h : refl_trans_clos R y z
β’ refl_trans_clos R x z | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
β’ β (x y z : A), R x y β refl_trans_clos R y z β refl_trans_clos R x z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | red_ref_trans_clos | [315, 1] | [318, 45] | apply refl_trans_clos.step _ _ <;> trivial | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x y z : A
red_x_y : R x y
h : refl_trans_clos R y z
β’ refl_trans_clos R x z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x y z : A
red_x_y : R x y
h : refl_trans_clos R y z
β’ refl_trans_clos R x z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_normal | [320, 1] | [333, 14] | apply normalizes_ind | A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x : A
β’ normalizes R x β β y, refl_trans_clos R x y β§ normal R y | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x : A
β’ β (x : A),
(β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1) β β y, refl_trans_clos R x y β§ normal R y | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x : A
β’ normalizes R x β β y, refl_trans_clos R x y β§ normal R y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_normal | [320, 1] | [333, 14] | intros x h | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x : A
β’ β (x : A),
(β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1) β β y, refl_trans_clos R x y β§ normal R y | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
h : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
β’ β y, refl_trans_clos R x y β§ normal R y | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
x : A
β’ β (x : A),
(β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1) β β y, refl_trans_clos R x y β§ normal R y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_normal | [320, 1] | [333, 14] | by_cases (β y, x ~> y) | case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
h : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
β’ β y, refl_trans_clos R x y β§ normal R y | case pos
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y
case neg
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : Β¬β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
h : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
β’ β y, refl_trans_clos R x y β§ normal R y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizing_normal | [320, 1] | [333, 14] | . cases' h with y h'
cases' h _ h' with z h''
cases h''
exists z
constructor <;> aesop | case pos
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y
case neg
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : Β¬β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y | case neg
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : Β¬β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y
case neg
A : Type
R : A β A β Prop
inhabited_A : Nonempty A
xβ x : A
hβ : β (y : A), R x y β β y_1, refl_trans_clos R y y_1 β§ normal R y_1
h : Β¬β y, R x y
β’ β y, refl_trans_clos R x y β§ normal R y
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.