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 | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | right | case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ ?inl.inr.left.a.b = X.b ∨ ?inl.inr.left.a.b = X.d
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a... | case inl.inr.left.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ ?inl.inr.left.a.b = X.d
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x... | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ ?inl.inr.left.a.b = X.b ∨ ?inl.inr.left.a.b = X.d
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | trivial | case inl.inr.left.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ ?inl.inr.left.a.b = X.d
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x... | case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.left.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ ?inl.inr.left.a.b = X.d
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_tra... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.left.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inl.inr.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.b
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | exists X.d | case inr.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ joins (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.b | case inr.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d ∧
refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ joins (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.b
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inr.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d ∧
refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ... | case inr.inl.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d ∧
refl_trans_clos (fun x y => x = X.b... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | . constructor | case inr.inl.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝... | case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.b X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
case inr.inl.right
A : Type
R : A →... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | . constructor; simp [RX]; right; trivial
constructor; simp [RX]; right; trivial
constructor | case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.b X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.b X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inr.inl.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.b X.d | case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ X.b = X.b ∧ ?inr.inl.right.b = X.a ∨
X.b = X.b ∧ ?inr.inl.right.b = X.c ∨ X.b = X.c ∧ ?inr.inl.right.b = X.b ∨ X.b = X.c ∧ ?inr.inl.right.b = X.d
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.b X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | simp [RX] | case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ X.b = X.b ∧ ?inr.inl.right.b = X.a ∨
X.b = X.b ∧ ?inr.inl.right.b = X.c ∨ X.b = X.c ∧ ?inr.inl.right.b = X.b ∨ X.b = X.c ∧ ?inr.inl.right.b = X.d
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A... | case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.b = X.a ∨ ?inr.inl.right.b = X.c
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ X.b = X.b ∧ ?inr.inl.right.b = X.a ∨
X.b = X.b ∧ ?inr.inl.right.b = X.c ∨ X.b = X.c ∧ ?inr.inl.right.b = X.b ∨ X.b = X.c ∧ ?inr.inl.right.b = X.... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | right | case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.b = X.a ∨ ?inr.inl.right.b = X.c
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x... | case inr.inl.right.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.b = X.c
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = ... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.b = X.a ∨ ?inr.inl.right.b = X.c
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | trivial | case inr.inl.right.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.b = X.c
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = ... | case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.c X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.b = X.c
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.c X.d | case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ X.c = X.b ∧ ?inr.inl.right.a.b = X.a ∨
X.c = X.b ∧ ?inr.inl.right.a.b = X.c ∨ X.c = X.c ∧ ?inr.inl.right.a.b = X.b ∨ X.c = X.c ∧ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.c X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | simp [RX] | case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ X.c = X.b ∧ ?inr.inl.right.a.b = X.a ∨
X.c = X.b ∧ ?inr.inl.right.a.b = X.c ∨ X.c = X.c ∧ ?inr.inl.right.a.b = X.b ∨ X.c = X.c ∧ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop... | case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.a.b = X.b ∨ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y =... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ X.c = X.b ∧ ?inr.inl.right.a.b = X.a ∨
X.c = X.b ∧ ?inr.inl.right.a.b = X.c ∨ X.c = X.c ∧ ?inr.inl.right.a.b = X.b ∨ X.c = X.c ∧ ?inr.inl.righ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | right | case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.a.b = X.b ∨ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y =... | case inr.inl.right.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.a.b = X.b ∨ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y =... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | trivial | case inr.inl.right.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ... | case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ ?inr.inl.right.a.b = X.d
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.b
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | exists X.d | case inr.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ joins (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | case inr.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d ∧
refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ... | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ joins (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | repeat constructor | case inr.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d ∧
refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ... | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d ∧
refl_trans_clos (fun x y => x = X.b... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case inr.inr.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
x y z : X
h✝¹ : y = X.d
h✝ : z = X.d
⊢ refl_trans_clos (fun x y => x = X.b ∧ y = X.a ∨ x = X.b ∧ y = X.c ∨ x = X.c ∧ y = X.b ∨ x = X.c ∧ y = X.d) X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | intros h | case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ ¬confluent RX | case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ ¬confluent RX
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | apply not_joins_a_d | case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ False | case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ joins RX X.a X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ False
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | apply h | case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ joins RX X.a X.d | case right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ wedge RX X.a X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ joins RX X.a X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | exists X.b | case right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ wedge RX X.a X.d | case right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a ∧ refl_trans_clos RX X.b X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ wedge RX X.a X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a ∧ refl_trans_clos RX X.b X.d | case right.a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a
case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a ∧ refl_trans_clos RX X.b X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | . constructor
simp [RX]
left; trivial
constructor | case right.a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a
case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d | case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a
case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | . constructor
simp [RX]
right; trivial
constructor
. simp [RX]; right; trivial
. constructor | case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case right.a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a | case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.b ?right.a.left.b
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.left.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : c... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.a
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | simp [RX] | case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.b ?right.a.left.b
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.left.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : c... | case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.left.b = X.a ∨ ?right.a.left.b = X.c
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.left.b
A : Type
R : A → A → Prop
inhabit... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.b ?right.a.left.b
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.le... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | left | case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.left.b = X.a ∨ ?right.a.left.b = X.c
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.left.b
A : Type
R : A → A → Prop
inhabit... | case right.a.left.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.left.b = X.a
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.left.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : ... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.left.b = X.a ∨ ?right.a.left.b = X.c
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | trivial | case right.a.left.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.left.b = X.a
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.left.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : ... | case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.a X.a | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.left.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.left.b = X.a
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.left.b X.a
case right.a.l... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.a X.a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.a X.a
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d | case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.b ?right.a.right.b
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.a.right.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.b X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | simp [RX] | case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.b ?right.a.right.b
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.a.right.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
... | case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.b = X.a ∨ ?right.a.right.b = X.c
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.a.right.b
A : Type
R : A → A → Prop
i... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.b ?right.a.right.b
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | right | case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.b = X.a ∨ ?right.a.right.b = X.c
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.a.right.b
A : Type
R : A → A → Prop
i... | case right.a.right.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.b = X.c
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.a.right.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.b = X.a ∨ ?right.a.right.b = X.c
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | trivial | case right.a.right.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.b = X.c
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right.a.right.b
A : Type
R : A → A → Prop
inhabited_A : Nonempty A... | case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.c X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.b = X.c
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.b X.d
case right... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.c X.d | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.c ?right.a.right.a.b
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.a.b X.d
case right.a.right.a.b
A : Type
R : A → A → Prop
inhabited_A : N... | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.c X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | . simp [RX]; right; trivial | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.c ?right.a.right.a.b
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.a.b X.d
case right.a.right.a.b
A : Type
R : A → A → Prop
inhabited_A : N... | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.d X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.c ?right.a.right.a.b
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX ?right.a.right.a.b X.d
cas... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | . constructor | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | simp [RX] | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.c ?right.a.right.a.b | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.a.b = X.b ∨ ?right.a.right.a.b = X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ RX X.c ?right.a.right.a.b
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | right | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.a.b = X.b ∨ ?right.a.right.a.b = X.d | case right.a.right.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.a.b = X.d | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.a.b = X.b ∨ ?right.a.right.a.b = X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | trivial | case right.a.right.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.a.b = X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.a.h
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ ?right.a.right.a.b = X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | weakly_confluent_does_not_imply_confluent | [532, 1] | [582, 20] | constructor | case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.d X.d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right.a.right.a.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
h : confluent RX
⊢ refl_trans_clos RX X.d X.d
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros norm | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ normalizing R → normalizing fun x x_1 => trans_clos R x x_1 | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
⊢ normalizing fun x x_1 => trans_clos R x x_1 | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ normalizing R → normalizing fun x x_1 => trans_clos R x x_1
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply ind_normalizing | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
⊢ normalizing fun x x_1 => trans_clos R x x_1 | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
⊢ ∀ (P : A → Prop), (∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x) → ∀ (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
norm : normalizing R
⊢ normalizing fun x x_1 => trans_clos R x x_1
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros P ih | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
⊢ ∀ (P : A → Prop), (∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x) → ∀ (x : A), P x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
⊢ ∀ (x : A), P x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
⊢ ∀ (P : A → Prop), (∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x) → ∀ (x : A), P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | let Q := λ x ↦ P x ∧ ∀ y, x ~>+ y → P y | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
⊢ ∀ (x : A), P x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
⊢ ∀ (x : A), P x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
⊢ ∀ (x : A), P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | have h : ∀ x, Q x :=
by
intros x
apply normalizing_ind R
. intros x ih'
constructor
. apply ih
intros y red_x_y
cases red_x_y
. apply (ih' _ _).1; trivial
. apply (ih' _ _).2 <;> trivial
. intros y red_x_y
cases red_x_y
. apply (ih' _ _).1; trivial
. apply (ih... | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
⊢ ∀ (x : A), P x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
h : ∀ (x : A), Q x
⊢ ∀ (x : A), P x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
⊢ ∀ (x : A), P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
h : ∀ (x : A), Q x
⊢ ∀ (x : A), P x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
h : ∀ (x : A), Q x
x : A
⊢ P x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
h : ∀ (x : A), Q x
⊢ ∀ (x : A), P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply (h x).1 | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
h : ∀ (x : A), Q x
x : A
⊢ 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
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
h : ∀ (x : A), Q x
x : A
⊢ P x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros x | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
⊢ ∀ (x : A), Q x | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ Q x | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
⊢ ∀ (x : A), Q x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply normalizing_ind R | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ Q x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ ∀ (x : A), (∀ (y : A), R x y → Q y) → Q x
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempt... | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ Q x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . intros x ih'
constructor
. apply ih
intros y red_x_y
cases red_x_y
. apply (ih' _ _).1; trivial
. apply (ih' _ _).2 <;> trivial
. intros y red_x_y
cases red_x_y
. apply (ih' _ _).1; trivial
. apply (ih' _ _).2 <;> trivial | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ ∀ (x : A), (∀ (y : A), R x y → Q y) → Q x
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempt... | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ normalizing R | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ ∀ (x : A), (∀ (y : A), R x y → Q y) ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . trivial | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ normalizing R | 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
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ normalizing R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros x ih' | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ ∀ (x : A), (∀ (y : A), R x y → Q y) → Q x | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ Q x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ ∀ (x : A), (∀ (y : A), R x y → Q y) ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | constructor | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ Q x | case a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ P x
case a.right
A : Type
R : A → A → Prop
inhabited_A : No... | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ Q x
... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . apply ih
intros y red_x_y
cases red_x_y
. apply (ih' _ _).1; trivial
. apply (ih' _ _).2 <;> trivial | case a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ P x
case a.right
A : Type
R : A → A → Prop
inhabited_A : No... | case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ ∀ (y : A), trans_clos R x y → P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . intros y red_x_y
cases red_x_y
. apply (ih' _ _).1; trivial
. apply (ih' _ _).2 <;> trivial | case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ ∀ (y : A), trans_clos R x y → P y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply ih | case a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ P x | case a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ ∀ (y : A), trans_clos R x y → P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros y red_x_y | case a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ ∀ (y : A), trans_clos R x y → P y | case a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
red_x_y : trans_clos R x y
⊢ P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | cases red_x_y | case a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
red_x_y : trans_clos R x y
⊢ P y | case a.left.a.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ P y
case a.left.a.step
A : Type
R :... | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left.a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . apply (ih' _ _).1; trivial | case a.left.a.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ P y
case a.left.a.step
A : Type
R :... | case a.left.a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y b✝ : A
a✝¹ : R x b✝
a✝ : trans_clos R b✝ y
⊢ P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left.a.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . apply (ih' _ _).2 <;> trivial | case a.left.a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y b✝ : A
a✝¹ : R x b✝
a✝ : trans_clos R b✝ y
⊢ P y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left.a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply (ih' _ _).1 | case a.left.a.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ P y | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ R x y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left.a.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | trivial | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ R x y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply (ih' _ _).2 <;> trivial | case a.left.a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y b✝ : A
a✝¹ : R x b✝
a✝ : trans_clos R b✝ y
⊢ P y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.left.a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | intros y red_x_y | case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
⊢ ∀ (y : A), trans_clos R x y → P y | case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
red_x_y : trans_clos R x y
⊢ P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | cases red_x_y | case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
red_x_y : trans_clos R x y
⊢ P y | case a.right.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ P y
case a.right.step
A : Type
R : A... | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . apply (ih' _ _).1; trivial | case a.right.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ P y
case a.right.step
A : Type
R : A... | case a.right.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y b✝ : A
a✝¹ : R x b✝
a✝ : trans_clos R b✝ y
⊢ P y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y →... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | . apply (ih' _ _).2 <;> trivial | case a.right.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y b✝ : A
a✝¹ : R x b✝
a✝ : trans_clos R b✝ y
⊢ P y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y →... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply (ih' _ _).1 | case a.right.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ P y | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y : A
a✝ : R x y
⊢ R x y | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right.base
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y →... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | apply (ih' _ _).2 <;> trivial | case a.right.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y → Q y
y b✝ : A
a✝¹ : R x b✝
a✝ : trans_clos R b✝ y
⊢ P y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.right.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x✝ x : A
ih' : ∀ (y : A), R x y →... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | normalizes_trans | [585, 1] | [608, 26] | trivial | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ normalizing R | 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
norm : normalizing R
P : A → Prop
ih : ∀ (x : A), (∀ (y : A), trans_clos R x y → P y) → P x
Q : A → Prop := fun x => P x ∧ ∀ (y : A), trans_clos R x y → P y
x : A
⊢ normalizing R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | intros conf' | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ confluent' R → confluent R | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
⊢ confluent R | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ confluent' R → confluent R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | apply semi_confluent_implies_confluent | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
⊢ confluent R | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
⊢ semi_confluent R | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
⊢ confluent R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | intros x y z red_x_y red_x_z | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
⊢ semi_confluent R | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
⊢ joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
⊢ semi_confluent R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | have h := refl_trans_is_trans_or_eq _ red_x_z | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
⊢ joins R y z | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z ∨ trans_clos R x z
⊢ joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | cases h | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z ∨ trans_clos R x z
⊢ joins R y z | case a.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : x = z
⊢ joins R y z
case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_c... | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z ∨ trans_clos R x z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | . case a.inl h =>
simp [← h]
exists y; aesop | case a.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : x = z
⊢ joins R y z
case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_c... | case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_clos R x z
⊢ joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
case a.inl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : x = z
⊢ joins R y z
case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | . apply conf' <;> aesop | case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_clos R x z
⊢ joins R y z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_clos R x z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | case a.inl h =>
simp [← h]
exists y; aesop | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | simp [← h] | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y z | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y x | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | exists y | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y x | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ refl_trans_clos R y y ∧ refl_trans_clos R x y | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ joins R y x
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | aesop | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ refl_trans_clos R y y ∧ refl_trans_clos R x y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h : x = z
⊢ refl_trans_clos R y y ∧ refl_trans_clos R x y
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | confluent'_implies_confluent | [613, 1] | [623, 26] | apply conf' <;> aesop | case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_clos R x z
⊢ joins R y z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.inr
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
conf' : confluent' R
x y z : A
red_x_y : R x y
red_x_z : refl_trans_clos R x z
h✝ : trans_clos R x z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | intros norm_R weak | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ normalizing R → weakly_confluent R → confluent R | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
⊢ confluent R | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
⊢ normalizing R → weakly_confluent R → confluent R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | intros y z wedge | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
⊢ confluent R | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z : A
wedge : _root_.wedge R y z
⊢ joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
⊢ confluent R
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | cases wedge | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z : A
wedge : _root_.wedge R y z
⊢ joins R y z | case intro
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z w✝ : A
h✝ : refl_trans_clos R w✝ y ∧ refl_trans_clos R w✝ z
⊢ joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z : A
wedge : _root_.wedge R y z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | case intro x h =>
revert h z y
have norm_trans := normalizes_trans _ norm_R
have h :=
normalizes_ind (. ~>+ .)
(λ x ↦ ∀ y z, x ~>* y ∧ x ~>* z → y ~>*.*<~ z)
intros y z wedge
(apply h <;> try trivial) <;> try apply norm_trans
clear h
intros x ih y z wedge
cases wedge.1
. exists z; aesop
. case a.step y' red_x_y' re... | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z x : A
h : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ joins R y z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z x : A
h : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | revert h z y | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z x : A
h : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ joins R y z | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
⊢ ∀ (y z : A), refl_trans_clos R x y ∧ refl_trans_clos R x z → joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
y z x : A
h : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | have norm_trans := normalizes_trans _ norm_R | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
⊢ ∀ (y z : A), refl_trans_clos R x y ∧ refl_trans_clos R x z → joins R y z | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
⊢ ∀ (y z : A), refl_trans_clos R x y ∧ refl_trans_clos R x z → joins R y z | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
⊢ ∀ (y z : A), refl_trans_clos R x y ∧ refl_trans_clos R x z → joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | have h :=
normalizes_ind (. ~>+ .)
(λ x ↦ ∀ y z, x ~>* y ∧ x ~>* z → y ~>*.*<~ z) | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
⊢ ∀ (y z : A), refl_trans_clos R x y ∧ refl_trans_clos R x z → joins R y z | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ refl_trans_clos R y z → joins R y_1 z) →
∀ (y z : A),... | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
⊢ ∀ (y z : A), refl_trans_clos R x y ∧ refl_trans_clos R x z → joins R y z
TACTIC:
|
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | intros y z wedge | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ refl_trans_clos R y z → joins R y_1 z) →
∀ (y z : A),... | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ refl_trans_clos R y z → joins R y_1 z) →
∀ (y z : A),... | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | (apply h <;> try trivial) <;> try apply norm_trans | A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ refl_trans_clos R y z → joins R y_1 z) →
∀ (y z : A),... | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ refl_trans_clos R y z → joins R y_1 z) →
∀ (y ... | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | clear h | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧ refl_trans_clos R y z → joins R y_1 z) →
∀ (y ... | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y z : A
wedge : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ ∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧... | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
h :
(∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | intros x ih y z wedge | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y z : A
wedge : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ ∀ (x : A),
(∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ∧... | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y✝ z✝ : A
wedge✝ : refl_trans_clos R x✝ y✝ ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ... | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y z : A
wedge : refl_trans_clos R x y ∧ refl_trans_clos R x z
⊢ ∀ (x : A),
(∀ (y : A)... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | cases wedge.1 | case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y✝ z✝ : A
wedge✝ : refl_trans_clos R x✝ y✝ ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y_1 ... | case a.refl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y z✝ : A
wedge✝ : refl_trans_clos R x✝ y ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y... | Please generate a tactic in lean4 to solve the state.
STATE:
case a
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y✝ z✝ : A
wedge✝ : refl_trans_clos R x✝ y✝ ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | . exists z; aesop | case a.refl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y z✝ : A
wedge✝ : refl_trans_clos R x✝ y ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y y... | case a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y✝ z✝ : A
wedge✝ : refl_trans_clos R x✝ y✝ ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y... | Please generate a tactic in lean4 to solve the state.
STATE:
case a.refl
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y z✝ : A
wedge✝ : refl_trans_clos R x✝ y ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y ... |
https://github.com/codyroux/traat-lean.git | f2babab84f81d4003446f476790022ac175d7236 | Traat/chapter1.lean | newmans_lemma | [626, 1] | [685, 21] | . case a.step y' red_x_y' red_y'_y =>
cases wedge.2
. exists y; aesop
. case step z' red_x_z' red_z'_z =>
have join1 := weak _ _ _ red_x_y' red_x_z'
cases' join1 with w h'
have join2 : y ~>*.*<~ w :=
by
apply ih
. apply trans_clos.base
apply red_x_y'
. aesop
have join... | case a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y✝ z✝ : A
wedge✝ : refl_trans_clos R x✝ y✝ ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (y : A), trans_clos R x y → ∀ (y_1 z : A), refl_trans_clos R y... | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.step
A : Type
R : A → A → Prop
inhabited_A : Nonempty A
norm_R : normalizing R
weak : weakly_confluent R
x✝ : A
norm_trans : normalizing fun x x_1 => trans_clos R x x_1
y✝ z✝ : A
wedge✝ : refl_trans_clos R x✝ y✝ ∧ refl_trans_clos R x✝ z✝
x : A
ih : ∀ (... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.