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/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact .defeq (hdf <| .symm <| .forallEDF ihA.2.2 ihB.2.2) <| .lam ihA.2.1 ihb'.2.1 | case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (VExpr.sort u✝)
ihB :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
ihb :
HasType1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasType1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) body✝ body'✝ B✝
ihb' :
HasType1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasType1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEq1 env U hasType defEq (A'✝ :: Γ✝) body✝ body'✝ B✝
⊢ HasType1 env U defEq Γ✝ (lam A'✝ body'✝) (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (VExpr.sort u✝)
ihB :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
ihb :
HasType1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasType1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) body✝ body'✝ B✝
ihb' :
HasType1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasType1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEq1 env U hasType defEq (A'✝ :: Γ✝) body✝ body'✝ B✝
⊢ HasType1 env U defEq Γ✝ (lam A'✝ body'✝) (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact ⟨.forallE ih1.1 ih2.1, .forallE ih1.2.1 ih3.2.1, .forallEDF ih1.2.2 ih2.2.2⟩ | case forallEDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝⁴ : VLevel.WF U u✝
a✝³ : VLevel.WF U v✝
a✝² : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 :
HasType1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih3 :
HasType1 env U defEq (A'✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A'✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (A'✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
⊢ HasType1 env U defEq Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
HasType1 env U defEq Γ✝ (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝)
(VExpr.sort (VLevel.imax u✝ v✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝⁴ : VLevel.WF U u✝
a✝³ : VLevel.WF U v✝
a✝² : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 :
HasType1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih3 :
HasType1 env U defEq (A'✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A'✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (A'✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
⊢ HasType1 env U defEq Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
HasType1 env U defEq Γ✝ (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝)
(VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact ⟨.defeq (hdf ih1.2.2) ih2.1, .defeq (hdf ih1.2.2) ih2.2.1, .defeqDF (hdf ih1.2.2) ih2.2.2⟩ | case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ B✝ (VExpr.sort u✝)
ih2 : HasType1 env U defEq Γ✝ e1✝ A✝ ∧ HasType1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEq1 env U hasType defEq Γ✝ e1✝ e2✝ A✝
⊢ HasType1 env U defEq Γ✝ e1✝ B✝ ∧ HasType1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEq1 env U hasType defEq Γ✝ e1✝ e2✝ B✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ B✝ (VExpr.sort u✝)
ih2 : HasType1 env U defEq Γ✝ e1✝ A✝ ∧ HasType1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEq1 env U hasType defEq Γ✝ e1✝ e2✝ A✝
⊢ HasType1 env U defEq Γ✝ e1✝ B✝ ∧ HasType1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEq1 env U hasType defEq Γ✝ e1✝ e2✝ B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact ⟨.app (.lam ihA.1 ihe.1) ihe'.1, ihee.1, .beta (hty ihe.1) (hty ihe'.1)⟩ | case beta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ e'✝ : VExpr
a✝⁷ : VLevel.WF U u✝
a✝⁶ : VLevel.WF U v✝
a✝⁵ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝⁴ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝² : IsDefEqStrong env U Γ✝ e'✝ e'✝ A✝
a✝¹ : IsDefEqStrong env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (VExpr.sort v✝)
a✝ : IsDefEqStrong env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
ihe :
HasType1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧
HasType1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) e✝ e✝ B✝
ihe' : HasType1 env U defEq Γ✝ e'✝ A✝ ∧ HasType1 env U defEq Γ✝ e'✝ A✝ ∧ IsDefEq1 env U hasType defEq Γ✝ e'✝ e'✝ A✝
a_ih✝ :
HasType1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧
HasType1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (VExpr.sort v✝)
ihee :
HasType1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
HasType1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
⊢ HasType1 env U defEq Γ✝ (app (lam A✝ e✝) e'✝) (inst B✝ e'✝) ∧
HasType1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ e'✝ : VExpr
a✝⁷ : VLevel.WF U u✝
a✝⁶ : VLevel.WF U v✝
a✝⁵ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝⁴ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝² : IsDefEqStrong env U Γ✝ e'✝ e'✝ A✝
a✝¹ : IsDefEqStrong env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (VExpr.sort v✝)
a✝ : IsDefEqStrong env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
ihe :
HasType1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧
HasType1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) e✝ e✝ B✝
ihe' : HasType1 env U defEq Γ✝ e'✝ A✝ ∧ HasType1 env U defEq Γ✝ e'✝ A✝ ∧ IsDefEq1 env U hasType defEq Γ✝ e'✝ e'✝ A✝
a_ih✝ :
HasType1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧
HasType1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (VExpr.sort v✝)
ihee :
HasType1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
HasType1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
⊢ HasType1 env U defEq Γ✝ (app (lam A✝ e✝) e'✝) (inst B✝ e'✝) ∧
HasType1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | have := HasType1.app ihe'.1 (.bvar .zero) | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝) | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
this : HasType1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) (inst (liftN 1 B✝ 1) (VExpr.bvar 0))
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | rw [instN_bvar0] at this | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
this : HasType1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) (inst (liftN 1 B✝ 1) (VExpr.bvar 0))
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝) | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
this : HasType1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) B✝
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
this : HasType1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) (inst (liftN 1 B✝ 1) (VExpr.bvar 0))
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact ⟨.lam ihA.1 this, ihe.1, .eta (hty ihe.1)⟩ | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
this : HasType1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) B✝
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEq1 env U hasType defEq Γ✝ A✝ A✝ (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasType1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a_ih✝ :
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasType1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEq1 env U hasType defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
ihe :
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEq1 env U hasType defEq Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ihe' :
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasType1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEq1 env U hasType defEq (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
this : HasType1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) B✝
⊢ HasType1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasType1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEq1 env U hasType defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact ⟨ih2.1, ih3.1, .proofIrrel (hty ih1.1) (hty ih2.1) (hty ih3.1)⟩ | case proofIrrel
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEqStrong env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEqStrong env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEqStrong env U Γ✝ h'✝ h'✝ p✝
ih1 :
HasType1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧
HasType1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧ IsDefEq1 env U hasType defEq Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
ih2 : HasType1 env U defEq Γ✝ h✝ p✝ ∧ HasType1 env U defEq Γ✝ h✝ p✝ ∧ IsDefEq1 env U hasType defEq Γ✝ h✝ h✝ p✝
ih3 : HasType1 env U defEq Γ✝ h'✝ p✝ ∧ HasType1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEq1 env U hasType defEq Γ✝ h'✝ h'✝ p✝
⊢ HasType1 env U defEq Γ✝ h✝ p✝ ∧ HasType1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEq1 env U hasType defEq Γ✝ h✝ h'✝ p✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEqStrong env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEqStrong env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEqStrong env U Γ✝ h'✝ h'✝ p✝
ih1 :
HasType1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧
HasType1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧ IsDefEq1 env U hasType defEq Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
ih2 : HasType1 env U defEq Γ✝ h✝ p✝ ∧ HasType1 env U defEq Γ✝ h✝ p✝ ∧ IsDefEq1 env U hasType defEq Γ✝ h✝ h✝ p✝
ih3 : HasType1 env U defEq Γ✝ h'✝ p✝ ∧ HasType1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEq1 env U hasType defEq Γ✝ h'✝ h'✝ p✝
⊢ HasType1 env U defEq Γ✝ h✝ p✝ ∧ HasType1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEq1 env U hasType defEq Γ✝ h✝ h'✝ p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact ⟨ihl'.1, ihr'.1, .extra h1 h2 h3⟩ | case extra
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
df✝ : VDefEq
ls✝ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
a✝⁵ : VLevel.WF U u✝
a✝⁴ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝² : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a✝¹ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a_ih✝² :
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
IsDefEq1 env U hasType defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a_ih✝ :
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
ihl' :
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
ihr' :
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
⊢ HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasType1 env U defEq Γ e A → hasType Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, IsDefEq1 env U hasType defEq Γ e1 e2 A → defEq Γ e1 e2 A
df✝ : VDefEq
ls✝ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
a✝⁵ : VLevel.WF U u✝
a✝⁴ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝² : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a✝¹ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a_ih✝² :
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
IsDefEq1 env U hasType defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝)
a_ih✝¹ :
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a_ih✝ :
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
ihl' :
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
ihr' :
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
⊢ HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasType1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEq1 env U hasType defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | induction H with
| bvar h => exact .bvar h
| const h1 h2 h3 => exact .const h1 h2 h3
| sort h => exact .sort h
| app _ _ ih1 ih2 => exact .app ih1 ih2
| lam _ _ ih1 ih2 => exact .lam ih1 ih2
| forallE _ _ ih1 ih2 => exact .forallE ih1 ih2
| defeq h1 _ ih => exact (IH h1).defeq ih | env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
H : HasType1 env U defEq Γ e A
⊢ HasType env U Γ e A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
H : HasType1 env U defEq Γ e A
⊢ HasType env U Γ e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact .bvar h | case bvar
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ HasType env U Γ✝ (VExpr.bvar i✝) A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ HasType env U Γ✝ (VExpr.bvar i✝) A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact .const h1 h2 h3 | case const
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = ci✝.uvars
⊢ HasType env U Γ✝ (VExpr.const c✝ ls✝) (instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = ci✝.uvars
⊢ HasType env U Γ✝ (VExpr.const c✝ ls✝) (instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact .sort h | case sort
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
l✝ : VLevel
h : VLevel.WF U l✝
⊢ HasType env U Γ✝ (VExpr.sort l✝) (VExpr.sort (VLevel.succ l✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sort
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
l✝ : VLevel
h : VLevel.WF U l✝
⊢ HasType env U Γ✝ (VExpr.sort l✝) (VExpr.sort (VLevel.succ l✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact .app ih1 ih2 | case app
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
f✝ A✝ B✝ a✝² : VExpr
a✝¹ : HasType1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
a✝ : HasType1 env U defEq Γ✝ a✝² A✝
ih1 : HasType env U Γ✝ f✝ (VExpr.forallE A✝ B✝)
ih2 : HasType env U Γ✝ a✝² A✝
⊢ HasType env U Γ✝ (VExpr.app f✝ a✝²) (inst B✝ a✝²) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case app
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
f✝ A✝ B✝ a✝² : VExpr
a✝¹ : HasType1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
a✝ : HasType1 env U defEq Γ✝ a✝² A✝
ih1 : HasType env U Γ✝ f✝ (VExpr.forallE A✝ B✝)
ih2 : HasType env U Γ✝ a✝² A✝
⊢ HasType env U Γ✝ (VExpr.app f✝ a✝²) (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact .lam ih1 ih2 | case lam
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ B✝ : VExpr
a✝¹ : HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasType1 env U defEq (A✝ :: Γ✝) body✝ B✝
ih1 : HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : HasType env U (A✝ :: Γ✝) body✝ B✝
⊢ HasType env U Γ✝ (VExpr.lam A✝ body✝) (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lam
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ B✝ : VExpr
a✝¹ : HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasType1 env U defEq (A✝ :: Γ✝) body✝ B✝
ih1 : HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : HasType env U (A✝ :: Γ✝) body✝ B✝
⊢ HasType env U Γ✝ (VExpr.lam A✝ body✝) (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact .forallE ih1 ih2 | case forallE
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ : VExpr
v✝ : VLevel
a✝¹ : HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasType1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
ih1 : HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : HasType env U (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
⊢ HasType env U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ : VExpr
v✝ : VLevel
a✝¹ : HasType1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasType1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
ih1 : HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : HasType env U (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
⊢ HasType env U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.HasType1.induction | [120, 1] | [128, 44] | exact (IH h1).defeq ih | case defeq
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : HasType1 env U defEq Γ✝ e✝ A✝
ih : HasType env U Γ✝ e✝ A✝
⊢ HasType env U Γ✝ e✝ B✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : HasType1 env U defEq Γ✝ e✝ A✝
ih : HasType env U Γ✝ e✝ A✝
⊢ HasType env U Γ✝ e✝ B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | induction H with
| refl h => exact hty h
| symm _ ih => exact ih.symm
| trans _ _ ih1 ih2 => exact ih1.trans ih2
| constDF h1 h2 h3 h4 h5 => exact .constDF h1 h2 h3 h4 h5
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| appDF _ _ ih1 ih2 => exact .appDF ih1 ih2
| lamDF _ _ ih1 ih2 => exact .lamDF ih1 ih2
| forallEDF _ _ ih1 ih2 => exact .forallEDF ih1 ih2
| defeqDF h1 _ ih => exact .defeqDF (hdf h1) ih
| beta h1 h2 => exact .beta (hty h1) (hty h2)
| eta h => exact .eta (hty h)
| proofIrrel h1 h2 h3 => exact .proofIrrel (hty h1) (hty h2) (hty h3)
| extra h1 h2 h3 => exact .extra h1 h2 h3 | env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq1 env U hasType defEq Γ e1 e2 A
⊢ IsDefEq env U Γ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq1 env U hasType defEq Γ e1 e2 A
⊢ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact hty h | case refl
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ : VExpr
h : hasType Γ✝ e✝ A✝
⊢ IsDefEq env U Γ✝ e✝ e✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ : VExpr
h : hasType Γ✝ e✝ A✝
⊢ IsDefEq env U Γ✝ e✝ e✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact ih.symm | case symm
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq1 env U hasType defEq Γ✝ e✝ e'✝ A✝
ih : IsDefEq env U Γ✝ e✝ e'✝ A✝
⊢ IsDefEq env U Γ✝ e'✝ e✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq1 env U hasType defEq Γ✝ e✝ e'✝ A✝
ih : IsDefEq env U Γ✝ e✝ e'✝ A✝
⊢ IsDefEq env U Γ✝ e'✝ e✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact ih1.trans ih2 | case trans
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq1 env U hasType defEq Γ✝ e₂✝ e₃✝ A✝
ih1 : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
ih2 : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
⊢ IsDefEq env U Γ✝ e₁✝ e₃✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq1 env U hasType defEq Γ✝ e₂✝ e₃✝ A✝
ih1 : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
ih2 : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
⊢ IsDefEq env U Γ✝ e₁✝ e₃✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .constDF h1 h2 h3 h4 h5 | case constDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
⊢ IsDefEq env U Γ✝ (const c✝ ls✝) (const c✝ ls'✝) (instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
⊢ IsDefEq env U Γ✝ (const c✝ ls✝) (const c✝ ls'✝) (instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .sortDF h1 h2 h3 | case sortDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env U Γ✝ (sort l✝) (sort l'✝) (sort (VLevel.succ l✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env U Γ✝ (sort l✝) (sort l'✝) (sort (VLevel.succ l✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .appDF ih1 ih2 | case appDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ f✝ f'✝ (forallE A✝ B✝)
a✝ : IsDefEq1 env U hasType defEq Γ✝ a✝² a'✝ A✝
ih1 : IsDefEq env U Γ✝ f✝ f'✝ (forallE A✝ B✝)
ih2 : IsDefEq env U Γ✝ a✝² a'✝ A✝
⊢ IsDefEq env U Γ✝ (app f✝ a✝²) (app f'✝ a'✝) (inst B✝ a✝²) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ f✝ f'✝ (forallE A✝ B✝)
a✝ : IsDefEq1 env U hasType defEq Γ✝ a✝² a'✝ A✝
ih1 : IsDefEq env U Γ✝ f✝ f'✝ (forallE A✝ B✝)
ih2 : IsDefEq env U Γ✝ a✝² a'✝ A✝
⊢ IsDefEq env U Γ✝ (app f✝ a✝²) (app f'✝ a'✝) (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .lamDF ih1 ih2 | case lamDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
b✝ b'✝ B✝ : VExpr
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (sort u✝)
a✝ : IsDefEq1 env U hasType defEq (A✝ :: Γ✝) b✝ b'✝ B✝
ih1 : IsDefEq env U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEq env U (A✝ :: Γ✝) b✝ b'✝ B✝
⊢ IsDefEq env U Γ✝ (lam A✝ b✝) (lam A'✝ b'✝) (forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
b✝ b'✝ B✝ : VExpr
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (sort u✝)
a✝ : IsDefEq1 env U hasType defEq (A✝ :: Γ✝) b✝ b'✝ B✝
ih1 : IsDefEq env U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEq env U (A✝ :: Γ✝) b✝ b'✝ B✝
⊢ IsDefEq env U Γ✝ (lam A✝ b✝) (lam A'✝ b'✝) (forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .forallEDF ih1 ih2 | case forallEDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ B'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (sort u✝)
a✝ : IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B'✝ (sort v✝)
ih1 : IsDefEq env U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEq env U (A✝ :: Γ✝) B✝ B'✝ (sort v✝)
⊢ IsDefEq env U Γ✝ (forallE A✝ B✝) (forallE A'✝ B'✝) (sort (VLevel.imax u✝ v✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ B'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq1 env U hasType defEq Γ✝ A✝ A'✝ (sort u✝)
a✝ : IsDefEq1 env U hasType defEq (A✝ :: Γ✝) B✝ B'✝ (sort v✝)
ih1 : IsDefEq env U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEq env U (A✝ :: Γ✝) B✝ B'✝ (sort v✝)
⊢ IsDefEq env U Γ✝ (forallE A✝ B✝) (forallE A'✝ B'✝) (sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .defeqDF (hdf h1) ih | case defeqDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e₁✝ e₂✝ : VExpr
h1 : defEq Γ✝ A✝ B✝ (sort u✝)
a✝ : IsDefEq1 env U hasType defEq Γ✝ e₁✝ e₂✝ A✝
ih : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
⊢ IsDefEq env U Γ✝ e₁✝ e₂✝ B✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e₁✝ e₂✝ : VExpr
h1 : defEq Γ✝ A✝ B✝ (sort u✝)
a✝ : IsDefEq1 env U hasType defEq Γ✝ e₁✝ e₂✝ A✝
ih : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
⊢ IsDefEq env U Γ✝ e₁✝ e₂✝ B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .beta (hty h1) (hty h2) | case beta
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
h1 : hasType (A✝ :: Γ✝) e✝ B✝
h2 : hasType Γ✝ e'✝ A✝
⊢ IsDefEq env U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
h1 : hasType (A✝ :: Γ✝) e✝ B✝
h2 : hasType Γ✝ e'✝ A✝
⊢ IsDefEq env U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .eta (hty h) | case eta
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
h : hasType Γ✝ e✝ (forallE A✝ B✝)
⊢ IsDefEq env U Γ✝ (lam A✝ (app (lift e✝) (bvar 0))) e✝ (forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
h : hasType Γ✝ e✝ (forallE A✝ B✝)
⊢ IsDefEq env U Γ✝ (lam A✝ (app (lift e✝) (bvar 0))) e✝ (forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .proofIrrel (hty h1) (hty h2) (hty h3) | case proofIrrel
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
h1 : hasType Γ✝ p✝ (sort VLevel.zero)
h2 : hasType Γ✝ h✝ p✝
h3 : hasType Γ✝ h'✝ p✝
⊢ IsDefEq env U Γ✝ h✝ h'✝ p✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
h1 : hasType Γ✝ p✝ (sort VLevel.zero)
h2 : hasType Γ✝ h✝ p✝
h3 : hasType Γ✝ h'✝ p✝
⊢ IsDefEq env U Γ✝ h✝ h'✝ p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq1.induction | [135, 1] | [150, 44] | exact .extra h1 h2 h3 | case extra
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
⊢ IsDefEq env U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
U : Nat
henv : Ordered env
hasType : List VExpr → VExpr → VExpr → Prop
defEq : List VExpr → VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, hasType Γ e A → HasType env U Γ e A
hdf : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, defEq Γ e1 e2 A → IsDefEq env U Γ e1 e2 A
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
⊢ IsDefEq env U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | simp [parentD] | a : Nat
arr : Array UFNode
⊢ parentD (Array.push arr { parent := Array.size arr, rank := 0 }) a = parentD arr a | a : Nat
arr : Array UFNode
⊢ (if h : a < Array.size arr + 1 then (Array.push arr { parent := Array.size arr, rank := 0 })[a].parent else a) =
if h : a < Array.size arr then arr[a].parent else a | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
⊢ parentD (Array.push arr { parent := Array.size arr, rank := 0 }) a = parentD arr a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | split <;> split <;> try simp [Array.get_push, *] | a : Nat
arr : Array UFNode
⊢ (if h : a < Array.size arr + 1 then (Array.push arr { parent := Array.size arr, rank := 0 })[a].parent else a) =
if h : a < Array.size arr then arr[a].parent else a | case inl.inr
a : Nat
arr : Array UFNode
h✝¹ : a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ Array.size arr = a
case inr.inl
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : a < Array.size arr
⊢ a = arr[a].parent | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
⊢ (if h : a < Array.size arr + 1 then (Array.push arr { parent := Array.size arr, rank := 0 })[a].parent else a) =
if h : a < Array.size arr then arr[a].parent else a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | simp [Array.get_push, *] | case inr.inr
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ a = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ a = a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | next h1 h2 =>
simp [Nat.lt_succ] at h1 h2
exact Nat.le_antisymm h2 h1 | case inl.inr
a : Nat
arr : Array UFNode
h✝¹ : a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ Array.size arr = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr
a : Nat
arr : Array UFNode
h✝¹ : a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ Array.size arr = a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | simp [Nat.lt_succ] at h1 h2 | a : Nat
arr : Array UFNode
h1 : a < Array.size arr + 1
h2 : ¬a < Array.size arr
⊢ Array.size arr = a | a : Nat
arr : Array UFNode
h1 : a ≤ Array.size arr
h2 : Array.size arr ≤ a
⊢ Array.size arr = a | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
h1 : a < Array.size arr + 1
h2 : ¬a < Array.size arr
⊢ Array.size arr = a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | exact Nat.le_antisymm h2 h1 | a : Nat
arr : Array UFNode
h1 : a ≤ Array.size arr
h2 : Array.size arr ≤ a
⊢ Array.size arr = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
h1 : a ≤ Array.size arr
h2 : Array.size arr ≤ a
⊢ Array.size arr = a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | next h1 h2 => cases h1 (Nat.lt_succ_of_lt h2) | case inr.inl
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : a < Array.size arr
⊢ a = arr[a].parent | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : a < Array.size arr
⊢ a = arr[a].parent
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_push | [13, 9] | [19, 50] | cases h1 (Nat.lt_succ_of_lt h2) | a : Nat
arr : Array UFNode
h1 : ¬a < Array.size arr + 1
h2 : a < Array.size arr
⊢ a = arr[a].parent | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
h1 : ¬a < Array.size arr + 1
h2 : a < Array.size arr
⊢ a = arr[a].parent
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parent_push | [21, 9] | [21, 95] | simp [parent] | a : Nat
m : UnionFind
⊢ parent (push m) a = parent m a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
m : UnionFind
⊢ parent (push m) a = parent m a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rankD_push | [23, 9] | [26, 48] | simp [rankD] | a : Nat
arr : Array UFNode
⊢ rankD (Array.push arr { parent := Array.size arr, rank := 0 }) a = rankD arr a | a : Nat
arr : Array UFNode
⊢ (if h : a < Array.size arr + 1 then (Array.push arr { parent := Array.size arr, rank := 0 })[a].rank else 0) =
if h : a < Array.size arr then arr[a].rank else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
⊢ rankD (Array.push arr { parent := Array.size arr, rank := 0 }) a = rankD arr a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rankD_push | [23, 9] | [26, 48] | split <;> split <;> try simp [Array.get_push, *] | a : Nat
arr : Array UFNode
⊢ (if h : a < Array.size arr + 1 then (Array.push arr { parent := Array.size arr, rank := 0 })[a].rank else 0) =
if h : a < Array.size arr then arr[a].rank else 0 | case inr.inl
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : a < Array.size arr
⊢ 0 = arr[a].rank | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
⊢ (if h : a < Array.size arr + 1 then (Array.push arr { parent := Array.size arr, rank := 0 })[a].rank else 0) =
if h : a < Array.size arr then arr[a].rank else 0
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rankD_push | [23, 9] | [26, 48] | next h1 h2 => cases h1 (Nat.lt_succ_of_lt h2) | case inr.inl
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : a < Array.size arr
⊢ 0 = arr[a].rank | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : a < Array.size arr
⊢ 0 = arr[a].rank
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rankD_push | [23, 9] | [26, 48] | simp [Array.get_push, *] | case inr.inr
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ 0 = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
a : Nat
arr : Array UFNode
h✝¹ : ¬a < Array.size arr + 1
h✝ : ¬a < Array.size arr
⊢ 0 = 0
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rankD_push | [23, 9] | [26, 48] | cases h1 (Nat.lt_succ_of_lt h2) | a : Nat
arr : Array UFNode
h1 : ¬a < Array.size arr + 1
h2 : a < Array.size arr
⊢ 0 = arr[a].rank | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
arr : Array UFNode
h1 : ¬a < Array.size arr + 1
h2 : a < Array.size arr
⊢ 0 = arr[a].rank
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rank_push | [28, 9] | [28, 87] | simp [rank] | a : Nat
m : UnionFind
⊢ rank (push m) a = rank m a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : Nat
m : UnionFind
⊢ rank (push m) a = rank m a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.rankMax_push | [30, 9] | [30, 95] | simp [rankMax] | m : UnionFind
⊢ rankMax (push m) = rankMax m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : UnionFind
⊢ rankMax (push m) = rankMax m
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_linkAux | [38, 1] | [48, 74] | dsimp [linkAux] | i : Nat
self : Array UFNode
x y : Fin (Array.size self)
⊢ parentD (linkAux self x y) i =
if ↑x = ↑y then parentD self i
else
if (Array.get self y).rank < (Array.get self x).rank then if ↑y = i then ↑x else parentD self i
else if ↑x = i then ↑y else parentD self i | i : Nat
self : Array UFNode
x y : Fin (Array.size self)
⊢ parentD
(if ↑x = ↑y then self
else
if (Array.get self y).rank < (Array.get self x).rank then
Array.set self y { parent := ↑x, rank := (Array.get self y).rank }
else
if (Array.get self x).rank = (Array.get self y).rank then
Array.set (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) { val := ↑y, isLt := ⋯ }
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }
else Array.set self x { parent := ↑y, rank := (Array.get self x).rank })
i =
if ↑x = ↑y then parentD self i
else
if (Array.get self y).rank < (Array.get self x).rank then if ↑y = i then ↑x else parentD self i
else if ↑x = i then ↑y else parentD self i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
⊢ parentD (linkAux self x y) i =
if ↑x = ↑y then parentD self i
else
if (Array.get self y).rank < (Array.get self x).rank then if ↑y = i then ↑x else parentD self i
else if ↑x = i then ↑y else parentD self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_linkAux | [38, 1] | [48, 74] | split <;> [rfl; split] <;> [rw [parentD_set]; split] <;> rw [parentD_set] | i : Nat
self : Array UFNode
x y : Fin (Array.size self)
⊢ parentD
(if ↑x = ↑y then self
else
if (Array.get self y).rank < (Array.get self x).rank then
Array.set self y { parent := ↑x, rank := (Array.get self y).rank }
else
if (Array.get self x).rank = (Array.get self y).rank then
Array.set (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) { val := ↑y, isLt := ⋯ }
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }
else Array.set self x { parent := ↑y, rank := (Array.get self x).rank })
i =
if ↑x = ↑y then parentD self i
else
if (Array.get self y).rank < (Array.get self x).rank then if ↑y = i then ↑x else parentD self i
else if ↑x = i then ↑y else parentD self i | case inr.inr.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (if ↑{ val := ↑y, isLt := ⋯ } = i then
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }.parent
else parentD (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) i) =
if ↑x = i then ↑y else parentD self i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
⊢ parentD
(if ↑x = ↑y then self
else
if (Array.get self y).rank < (Array.get self x).rank then
Array.set self y { parent := ↑x, rank := (Array.get self y).rank }
else
if (Array.get self x).rank = (Array.get self y).rank then
Array.set (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) { val := ↑y, isLt := ⋯ }
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }
else Array.set self x { parent := ↑y, rank := (Array.get self x).rank })
i =
if ↑x = ↑y then parentD self i
else
if (Array.get self y).rank < (Array.get self x).rank then if ↑y = i then ↑x else parentD self i
else if ↑x = i then ↑y else parentD self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_linkAux | [38, 1] | [48, 74] | simp | case inr.inr.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (if ↑{ val := ↑y, isLt := ⋯ } = i then
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }.parent
else parentD (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) i) =
if ↑x = i then ↑y else parentD self i | case inr.inr.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (if ↑y = i then (Array.get self y).parent
else parentD (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) i) =
if ↑x = i then ↑y else parentD self i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (if ↑{ val := ↑y, isLt := ⋯ } = i then
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }.parent
else parentD (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) i) =
if ↑x = i then ↑y else parentD self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_linkAux | [38, 1] | [48, 74] | split <;> [(subst i; rwa [if_neg, parentD_eq]); rw [parentD_set]] | case inr.inr.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (if ↑y = i then (Array.get self y).parent
else parentD (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) i) =
if ↑x = i then ↑y else parentD self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (if ↑y = i then (Array.get self y).parent
else parentD (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) i) =
if ↑x = i then ↑y else parentD self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_linkAux | [38, 1] | [48, 74] | subst i | case inr.inr.inl.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝³ : ¬↑x = ↑y
h✝² : ¬(Array.get self y).rank < (Array.get self x).rank
h✝¹ : (Array.get self x).rank = (Array.get self y).rank
h✝ : ↑y = i
⊢ (Array.get self y).parent = if ↑x = i then ↑y else parentD self i | case inr.inr.inl.inl
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (Array.get self y).parent = if ↑x = ↑y then ↑y else parentD self ↑y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl.inl
i : Nat
self : Array UFNode
x y : Fin (Array.size self)
h✝³ : ¬↑x = ↑y
h✝² : ¬(Array.get self y).rank < (Array.get self x).rank
h✝¹ : (Array.get self x).rank = (Array.get self y).rank
h✝ : ↑y = i
⊢ (Array.get self y).parent = if ↑x = i then ↑y else parentD self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parentD_linkAux | [38, 1] | [48, 74] | rwa [if_neg, parentD_eq] | case inr.inr.inl.inl
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (Array.get self y).parent = if ↑x = ↑y then ↑y else parentD self ↑y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl.inl
self : Array UFNode
x y : Fin (Array.size self)
h✝² : ¬↑x = ↑y
h✝¹ : ¬(Array.get self y).rank < (Array.get self x).rank
h✝ : (Array.get self x).rank = (Array.get self y).rank
⊢ (Array.get self y).parent = if ↑x = ↑y then ↑y else parentD self ↑y
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parent_link | [50, 1] | [59, 41] | simp [rankD_eq] | self : UnionFind
x y : Fin (size self)
yroot : parent self ↑y = ↑y
i : Nat
⊢ parent (link self x y yroot) i =
if ↑x = ↑y then parent self i
else
if rank self ↑y < rank self ↑x then if ↑y = i then ↑x else parent self i else if ↑x = i then ↑y else parent self i | self : UnionFind
x y : Fin (size self)
yroot : parent self ↑y = ↑y
i : Nat
⊢ parent (link self x y yroot) i =
if ↑x = ↑y then parent self i
else
if (Array.get self.arr y).rank < (Array.get self.arr x).rank then if ↑y = i then ↑x else parent self i
else if ↑x = i then ↑y else parent self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
yroot : parent self ↑y = ↑y
i : Nat
⊢ parent (link self x y yroot) i =
if ↑x = ↑y then parent self i
else
if rank self ↑y < rank self ↑x then if ↑y = i then ↑x else parent self i else if ↑x = i then ↑y else parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.parent_link | [50, 1] | [59, 41] | exact parentD_linkAux | self : UnionFind
x y : Fin (size self)
yroot : parent self ↑y = ↑y
i : Nat
⊢ parent (link self x y yroot) i =
if ↑x = ↑y then parent self i
else
if (Array.get self.arr y).rank < (Array.get self.arr x).rank then if ↑y = i then ↑x else parent self i
else if ↑x = i then ↑y else parent self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
yroot : parent self ↑y = ↑y
i : Nat
⊢ parent (link self x y yroot) i =
if ↑x = ↑y then parent self i
else
if (Array.get self.arr y).rank < (Array.get self.arr x).rank then if ↑y = i then ↑x else parent self i
else if ↑x = i then ↑y else parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | refine ⟨x, .inl rfl, fun i => ?_⟩ | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i : Nat
⊢ root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [root_ext (m2 := self) (fun _ => by rw [parent_link, if_pos h])] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i : Nat
⊢ root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i : Nat
⊢ root self i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i : Nat
⊢ root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | split <;> [obtain _ | _ := ‹_› <;> simp [*]; rfl] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i : Nat
⊢ root self i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i : Nat
⊢ root self i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [parent_link, if_pos h] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i x✝ : Nat
⊢ parent (link self x y yroot) x✝ = parent self x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ↑x = ↑y
i x✝ : Nat
⊢ parent (link self x y yroot) x✝ = parent self x✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | if hr : self.rank y < self.rank x then
exact this xroot yroot fun i => by simp [parent_link, h, hr]
else
simpa (config := {singlePass := true}) [or_comm] using
this yroot xroot fun i => by simp [parent_link, h, hr] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | exact ⟨x, .inl rfl, go⟩ | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
⊢ ∃ r, (r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
⊢ ∃ r, (r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [root_eq_self.2 h] | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : parent m i = i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : parent m i = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : parent m i = i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [hm i] at h | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : parent m i = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : (if ↑y = i then ↑x else parent self i) = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : parent m i = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | split at h | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : (if ↑y = i then ↑x else parent self i) = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | case inl
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ↑y = i
h : ↑x = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
case inr
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : (if ↑y = i then ↑x else parent self i) = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [if_pos, h] | case inl
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ↑y = i
h : ↑x = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | case inl.hc
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ↑y = i
h : ↑x = i
⊢ root self i = ↑x ∨ root self i = ↑y | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ↑y = i
h : ↑x = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | simp [← h, root_eq_self, xroot] | case inl.hc
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ↑y = i
h : ↑x = i
⊢ root self i = ↑x ∨ root self i = ↑y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hc
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ↑y = i
h : ↑x = i
⊢ root self i = ↑x ∨ root self i = ↑y
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [root_eq_self.2 ‹_›] | case inr
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | case inr
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
⊢ i = if i = ↑x ∨ i = ↑y then ↑x else i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
⊢ i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | split <;> [skip; rfl] | case inr
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
⊢ i = if i = ↑x ∨ i = ↑y then ↑x else i | case inr.inl
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝² : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝¹ : ¬↑y = i
h : parent self i = i
h✝ : i = ↑x ∨ i = ↑y
⊢ i = ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
⊢ i = if i = ↑x ∨ i = ↑y then ↑x else i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | next h' => exact h'.resolve_right (Ne.symm ‹_›) | case inr.inl
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝² : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝¹ : ¬↑y = i
h : parent self i = i
h✝ : i = ↑x ∨ i = ↑y
⊢ i = ↑x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝² : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝¹ : ¬↑y = i
h : parent self i = i
h✝ : i = ↑x ∨ i = ↑y
⊢ i = ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | exact h'.resolve_right (Ne.symm ‹_›) | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
h' : i = ↑x ∨ i = ↑y
⊢ i = ↑x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝¹ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h✝ : ¬↑y = i
h : parent self i = i
h' : i = ↑x ∨ i = ↑y
⊢ i = ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | have _ := Nat.sub_lt_sub_left (m.lt_rankMax i) (m.rank_lt h) | self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [← root_parent, go (m.parent i)] | self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ (if root self (parent m i) = ↑x ∨ root self (parent m i) = ↑y then ↑x else root self (parent m i)) =
if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | rw [hm i] | self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ (if root self (parent m i) = ↑x ∨ root self (parent m i) = ↑y then ↑x else root self (parent m i)) =
if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ (if root self (if ↑y = i then ↑x else parent self i) = ↑x ∨ root self (if ↑y = i then ↑x else parent self i) = ↑y then
↑x
else root self (if ↑y = i then ↑x else parent self i)) =
if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ (if root self (parent m i) = ↑x ∨ root self (parent m i) = ↑y then ↑x else root self (parent m i)) =
if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | split <;> [subst i; rw [root_parent]] | self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ (if root self (if ↑y = i then ↑x else parent self i) = ↑x ∨ root self (if ↑y = i then ↑x else parent self i) = ↑y then
↑x
else root self (if ↑y = i then ↑x else parent self i)) =
if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i | case inl
self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
h : ¬parent m ↑y = ↑y
x✝ : rankMax m - rank m (parent m ↑y) < rankMax m - rank m ↑y
⊢ (if root self ↑x = ↑x ∨ root self ↑x = ↑y then ↑x else root self ↑x) =
if root self ↑y = ↑x ∨ root self ↑y = ↑y then ↑x else root self ↑y | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
i : Nat
h : ¬parent m i = i
x✝ : rankMax m - rank m (parent m i) < rankMax m - rank m i
⊢ (if root self (if ↑y = i then ↑x else parent self i) = ↑x ∨ root self (if ↑y = i then ↑x else parent self i) = ↑y then
↑x
else root self (if ↑y = i then ↑x else parent self i)) =
if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | simp [root_eq_self.2 xroot, root_eq_self.2 yroot] | case inl
self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
h : ¬parent m ↑y = ↑y
x✝ : rankMax m - rank m (parent m ↑y) < rankMax m - rank m ↑y
⊢ (if root self ↑x = ↑x ∨ root self ↑x = ↑y then ↑x else root self ↑x) =
if root self ↑y = ↑x ∨ root self ↑y = ↑y then ↑x else root self ↑y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
self : UnionFind
x✝¹ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝¹ = ↑x✝¹
yroot✝ : parent self ↑y✝ = ↑y✝
h✝ : ¬↑x✝¹ = ↑y✝
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
m : UnionFind
hm : ∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i
h : ¬parent m ↑y = ↑y
x✝ : rankMax m - rank m (parent m ↑y) < rankMax m - rank m ↑y
⊢ (if root self ↑x = ↑x ∨ root self ↑x = ↑y then ↑x else root self ↑x) =
if root self ↑y = ↑x ∨ root self ↑y = ↑y then ↑x else root self ↑y
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | exact this xroot yroot fun i => by simp [parent_link, h, hr] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : rank self ↑y < rank self ↑x
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : rank self ↑y < rank self ↑x
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | simp [parent_link, h, hr] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : rank self ↑y < rank self ↑x
i : Nat
⊢ parent (link self x y yroot) i = if ↑y = i then ↑x else parent self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : rank self ↑y < rank self ↑x
i : Nat
⊢ parent (link self x y yroot) i = if ↑y = i then ↑x else parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | simpa (config := {singlePass := true}) [or_comm] using
this yroot xroot fun i => by simp [parent_link, h, hr] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : ¬rank self ↑y < rank self ↑x
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : ¬rank self ↑y < rank self ↑x
⊢ ∃ r,
(r = x ∨ r = y) ∧
∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.root_link | [61, 1] | [93, 61] | simp [parent_link, h, hr] | self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : ¬rank self ↑y < rank self ↑x
i : Nat
⊢ parent (link self x y yroot) i = if ↑x = i then ↑y else parent self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
h : ¬↑x = ↑y
this :
∀ {x y : Fin (size self)},
parent self ↑x = ↑x →
parent self ↑y = ↑y →
∀ {m : UnionFind},
(∀ (i : Nat), parent m i = if ↑y = i then ↑x else parent self i) →
∃ r,
(r = x ∨ r = y) ∧ ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
hr : ¬rank self ↑y < rank self ↑x
i : Nat
⊢ parent (link self x y yroot) i = if ↑x = i then ↑y else parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_empty | [101, 9] | [101, 73] | simp [Equiv] | a b : Nat
⊢ Equiv empty a b ↔ a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
⊢ Equiv empty a b ↔ a = b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_push | [103, 9] | [103, 85] | simp [Equiv] | a b : Nat
self : UnionFind
⊢ Equiv (push self) a b ↔ Equiv self a b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
⊢ Equiv (push self) a b ↔ Equiv self a b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_root | [105, 9] | [105, 86] | simp [Equiv, root_root] | self : UnionFind
a : Nat
⊢ Equiv self (root self a) a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
a : Nat
⊢ Equiv self (root self a) a
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_root_l | [106, 9] | [107, 26] | simp [Equiv, root_root] | self : UnionFind
a b : Nat
⊢ Equiv self (root self a) b ↔ Equiv self a b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
a b : Nat
⊢ Equiv self (root self a) b ↔ Equiv self a b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_root_r | [108, 9] | [109, 26] | simp [Equiv, root_root] | self : UnionFind
a b : Nat
⊢ Equiv self a (root self b) ↔ Equiv self a b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
a b : Nat
⊢ Equiv self a (root self b) ↔ Equiv self a b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_find | [111, 1] | [111, 96] | simp [Equiv, find_root_1] | a b : Nat
self : UnionFind
x : Fin (size self)
⊢ Equiv (find self x).fst a b ↔ Equiv self a b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x : Fin (size self)
⊢ Equiv (find self x).fst a b ↔ Equiv self a b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | obtain ⟨r, ha, hr⟩ := root_link xroot yroot | a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
⊢ Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
hr : ∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
⊢ Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
⊢ Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | revert hr | case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
hr : ∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
⊢ Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
⊢ (∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
hr : ∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i
⊢ Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | rw [← root_eq_self] at xroot yroot | case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
⊢ (∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b) | case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot✝ : parent self ↑y = ↑y
yroot : root self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
⊢ (∀ (i : Nat), root (link self x y yroot✝) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self x y yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : parent self ↑x = ↑x
yroot : parent self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
⊢ (∀ (i : Nat), root (link self x y yroot) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self x y yroot) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | obtain rfl | rfl := ha | case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot✝ : parent self ↑y = ↑y
yroot : root self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
⊢ (∀ (i : Nat), root (link self x y yroot✝) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self x y yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b) | case intro.intro.inl
a b : Nat
self : UnionFind
y : Fin (size self)
yroot✝ : parent self ↑y = ↑y
yroot : root self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
xroot : root self ↑r = ↑r
⊢ (∀ (i : Nat), root (link self r y yroot✝) i = if root self i = ↑r ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self r y yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑r ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑r) b)
case intro.intro.inr
a b : Nat
self : UnionFind
x : Fin (size self)
xroot : root self ↑x = ↑x
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
yroot✝ : parent self ↑r = ↑r
yroot : root self ↑r = ↑r
⊢ (∀ (i : Nat), root (link self x r yroot✝) i = if root self i = ↑x ∨ root self i = ↑r then ↑r else root self i) →
(Equiv (link self x r yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑r) b ∨ Equiv self a ↑r ∧ Equiv self (↑x) b) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
a b : Nat
self : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot✝ : parent self ↑y = ↑y
yroot : root self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
ha : r = x ∨ r = y
⊢ (∀ (i : Nat), root (link self x y yroot✝) i = if root self i = ↑x ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self x y yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | simp [Equiv, hm, xroot, yroot] | a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
⊢ Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
⊢ ((if root self a = ↑x ∨ root self a = ↑y then ↑x else root self a) =
if root self b = ↑x ∨ root self b = ↑y then ↑x else root self b) ↔
root self a = root self b ∨ root self a = ↑x ∧ ↑y = root self b ∨ root self a = ↑y ∧ ↑x = root self b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
⊢ Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | by_cases h1 : root self a = x <;> by_cases h2 : root self b = x <;>
simp [h1, h2, imp_false, Decidable.not_not] | a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
⊢ ((if root self a = ↑x ∨ root self a = ↑y then ↑x else root self a) =
if root self b = ↑x ∨ root self b = ↑y then ↑x else root self b) ↔
root self a = root self b ∨ root self a = ↑x ∧ ↑y = root self b ∨ root self a = ↑y ∧ ↑x = root self b | case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : root self a = ↑x
h2 : ¬root self b = ↑x
⊢ (↑x = if root self b = ↑y then ↑x else root self b) ↔ ↑x = root self b ∨ ↑y = root self b ∨ ↑x = ↑y ∧ ↑x = root self b
case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : ¬root self a = ↑x
h2 : ¬root self b = ↑x
⊢ ((if root self a = ↑y then ↑x else root self a) = if root self b = ↑y then ↑x else root self b) ↔
root self a = root self b ∨ root self a = ↑y ∧ ↑x = root self b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
⊢ ((if root self a = ↑x ∨ root self a = ↑y then ↑x else root self a) =
if root self b = ↑x ∨ root self b = ↑y then ↑x else root self b) ↔
root self a = root self b ∨ root self a = ↑x ∧ ↑y = root self b ∨ root self a = ↑y ∧ ↑x = root self b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | simp [h2, Ne.symm h2] | case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : root self a = ↑x
h2 : ¬root self b = ↑x
⊢ (↑x = if root self b = ↑y then ↑x else root self b) ↔ ↑x = root self b ∨ ↑y = root self b ∨ ↑x = ↑y ∧ ↑x = root self b | case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : root self a = ↑x
h2 : ¬root self b = ↑x
⊢ (↑x = if root self b = ↑y then ↑x else root self b) ↔ ↑y = root self b | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : root self a = ↑x
h2 : ¬root self b = ↑x
⊢ (↑x = if root self b = ↑y then ↑x else root self b) ↔ ↑x = root self b ∨ ↑y = root self b ∨ ↑x = ↑y ∧ ↑x = root self b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | split <;> simp [@eq_comm _ _ (root self b), *] | case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : root self a = ↑x
h2 : ¬root self b = ↑x
⊢ (↑x = if root self b = ↑y then ↑x else root self b) ↔ ↑y = root self b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : root self a = ↑x
h2 : ¬root self b = ↑x
⊢ (↑x = if root self b = ↑y then ↑x else root self b) ↔ ↑y = root self b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | by_cases h1 : root self a = y <;> by_cases h2 : root self b = y <;>
simp [h1, h2, @eq_comm _ _ (root self b), *] | case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : ¬root self a = ↑x
h2 : ¬root self b = ↑x
⊢ ((if root self a = ↑y then ↑x else root self a) = if root self b = ↑y then ↑x else root self b) ↔
root self a = root self b ∨ root self a = ↑y ∧ ↑x = root self b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
a b : Nat
self : UnionFind
x✝ y✝ : Fin (size self)
xroot✝ : parent self ↑x✝ = ↑x✝
yroot✝ : parent self ↑y✝ = ↑y✝
m : UnionFind
x y : Fin (size self)
xroot : root self ↑x = ↑x
yroot : root self ↑y = ↑y
hm : ∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i
h1 : ¬root self a = ↑x
h2 : ¬root self b = ↑x
⊢ ((if root self a = ↑y then ↑x else root self a) = if root self b = ↑y then ↑x else root self b) ↔
root self a = root self b ∨ root self a = ↑y ∧ ↑x = root self b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | exact this xroot yroot | case intro.intro.inl
a b : Nat
self : UnionFind
y : Fin (size self)
yroot✝ : parent self ↑y = ↑y
yroot : root self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
xroot : root self ↑r = ↑r
⊢ (∀ (i : Nat), root (link self r y yroot✝) i = if root self i = ↑r ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self r y yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑r ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑r) b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.inl
a b : Nat
self : UnionFind
y : Fin (size self)
yroot✝ : parent self ↑y = ↑y
yroot : root self ↑y = ↑y
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
xroot : root self ↑r = ↑r
⊢ (∀ (i : Nat), root (link self r y yroot✝) i = if root self i = ↑r ∨ root self i = ↑y then ↑r else root self i) →
(Equiv (link self r y yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑r ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑r) b)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_link | [113, 1] | [132, 53] | simpa [or_comm, and_comm] using this yroot xroot | case intro.intro.inr
a b : Nat
self : UnionFind
x : Fin (size self)
xroot : root self ↑x = ↑x
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
yroot✝ : parent self ↑r = ↑r
yroot : root self ↑r = ↑r
⊢ (∀ (i : Nat), root (link self x r yroot✝) i = if root self i = ↑x ∨ root self i = ↑r then ↑r else root self i) →
(Equiv (link self x r yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑r) b ∨ Equiv self a ↑r ∧ Equiv self (↑x) b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.inr
a b : Nat
self : UnionFind
x : Fin (size self)
xroot : root self ↑x = ↑x
this :
∀ {m : UnionFind} {x y : Fin (size self)},
root self ↑x = ↑x →
root self ↑y = ↑y →
(∀ (i : Nat), root m i = if root self i = ↑x ∨ root self i = ↑y then ↑x else root self i) →
(Equiv m a b ↔ Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b)
r : Fin (size self)
yroot✝ : parent self ↑r = ↑r
yroot : root self ↑r = ↑r
⊢ (∀ (i : Nat), root (link self x r yroot✝) i = if root self i = ↑x ∨ root self i = ↑r then ↑r else root self i) →
(Equiv (link self x r yroot✝) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑r) b ∨ Equiv self a ↑r ∧ Equiv self (↑x) b)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_union | [134, 1] | [137, 89] | simp [union] | a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv (union self x y) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv
(link (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst { val := root self ↑x, isLt := ⋯ }
(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val ⋯)
a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv (union self x y) a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_union | [134, 1] | [137, 89] | rw [equiv_link (by simp [← root_eq_self, root_root])] | a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv
(link (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst { val := root self ↑x, isLt := ⋯ }
(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val ⋯)
a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a b ∨
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a ↑{ val := root self ↑x, isLt := ⋯ } ∧
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst
(↑(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val) b ∨
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a
↑(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val ∧
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst (↑{ val := root self ↑x, isLt := ⋯ }) b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv
(link (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst { val := root self ↑x, isLt := ⋯ }
(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val ⋯)
a b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_union | [134, 1] | [137, 89] | simp [equiv_find] | a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a b ∨
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a ↑{ val := root self ↑x, isLt := ⋯ } ∧
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst
(↑(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val) b ∨
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a
↑(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val ∧
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst (↑{ val := root self ↑x, isLt := ⋯ }) b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a b ∨
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a ↑{ val := root self ↑x, isLt := ⋯ } ∧
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst
(↑(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val) b ∨
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst a
↑(find (find self x).fst { val := ↑y, isLt := ⋯ }).2.val ∧
Equiv (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst (↑{ val := root self ↑x, isLt := ⋯ }) b ↔
Equiv self a b ∨ Equiv self a ↑x ∧ Equiv self (↑y) b ∨ Equiv self a ↑y ∧ Equiv self (↑x) b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/UnionFind.lean | Lean4Lean.UnionFind.equiv_union | [134, 1] | [137, 89] | simp [← root_eq_self, root_root] | a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ parent (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst ↑{ val := root self ↑x, isLt := ⋯ } =
↑{ val := root self ↑x, isLt := ⋯ } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : Nat
self : UnionFind
x y : Fin (size self)
⊢ parent (find (find self x).fst { val := ↑y, isLt := ⋯ }).fst ↑{ val := root self ↑x, isLt := ⋯ } =
↑{ val := root self ↑x, isLt := ⋯ }
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.