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/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | let β¨_, hBβ© := (ih2 hΞ').isType' henv envIH hΞ' | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ) | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
wβ : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .lamDF hu (hB.defeq.sort_r henv hΞ'.defeq) (ih1 hΞ)
hB ((ih1 hΞ).defeqDF_l henv hΞ hB) (ih2 hΞ') ((ih1 hΞ).defeqDF_l henv hΞ (ih2 hΞ')) | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
wβ : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
wβ : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have hu := hA.sort_r henv hΞ.defeq | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (VExpr.forallE Aβ bodyβ) (VExpr.forallE A'β body'β) (VExpr.sort (VLevel.imax uβ vβ)) | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
β’ IsDefEqStrong env U Ξβ (VExpr.forallE Aβ bodyβ) (VExpr.forallE A'β body'β) (VExpr.sort (VLevel.imax uβ vβ)) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (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/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have hΞ' : CtxStrong env U (_::_) := β¨hΞ, _, (ih1 hΞ).hasType.1β© | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
β’ IsDefEqStrong env U Ξβ (VExpr.forallE Aβ bodyβ) (VExpr.forallE A'β body'β) (VExpr.sort (VLevel.imax uβ vβ)) | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (VExpr.forallE Aβ bodyβ) (VExpr.forallE A'β body'β) (VExpr.sort (VLevel.imax uβ vβ)) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
β’ IsDefEqStrong env U Ξβ (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/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .forallEDF hu (hb.sort_r henv hΞ'.defeq)
(ih1 hΞ) (ih2 hΞ') ((ih1 hΞ).defeqDF_l henv hΞ (ih2 hΞ')) | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
hA : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
hb : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ A'β (VExpr.sort uβ)
ih2 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
hΞ : CtxStrong env U Ξβ
hu : VLevel.WF U uβ
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (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/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .defeqDF (hAB.sort_r henv hΞ.defeq) (ih1 hΞ) (ih2 hΞ) | case defeqDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
hAB : IsDefEq env U Ξβ Aβ Bβ (VExpr.sort uβ)
aβ : IsDefEq env U Ξβ e1β e2β Aβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ Bβ (VExpr.sort uβ)
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e1β e2β Aβ
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ e1β e2β Bβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
hAB : IsDefEq env U Ξβ Aβ Bβ (VExpr.sort uβ)
aβ : IsDefEq env U Ξβ e1β e2β Aβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ Aβ Bβ (VExpr.sort uβ)
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e1β e2β Aβ
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ e1β e2β Bβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have he' := ih2 hΞ | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have β¨_, hAβ© := he'.isType' henv envIH hΞ | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have hΞ' : CtxStrong env U (_::_) := β¨hΞ, _, hAβ© | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have he := ih1 hΞ' | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have β¨_, hBβ© := he.isType' henv envIH hΞ' | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβΒΉ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβΒΉ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
wβ : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .beta (hA.defeq.sort_r henv hΞ.defeq) (hB.defeq.sort_r henv hΞ'.defeq)
hA hB he he' (he'.instN henv hΞ .zero hB hΞ) (he'.instN henv hΞ .zero he hΞ) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβΒΉ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβΒΉ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
wβ : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort wβ)
β’ IsDefEqStrong 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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβΒΉ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
aβ : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : CtxStrong env U (Aβ :: Ξβ) β IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ e'β e'β Aβ
hΞ : CtxStrong env U Ξβ
he' : IsDefEqStrong env U Ξβ e'β e'β Aβ
wβΒΉ : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort wβΒΉ)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
wβ : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have he := ih hΞ | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ) | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | let β¨_, hABβ© := he.isType' henv envIH hΞ | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ) | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | let β¨β¨u, hAβ©, β¨v, hBβ©β© := hAB.forallE_inv' henv envIH hΞ (.inl rfl) | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ) | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
u : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort u)
v : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort v)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | have hΞ' : CtxStrong env U (_::_) := β¨hΞ, _, hAβ© | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
u : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort u)
v : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort v)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ) | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
u : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort u)
v : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort v)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
u : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort u)
v : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort v)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .eta (hA.defeq.sort_r henv hΞ.defeq) (hB.defeq.sort_r henv hΞ'.defeq)
hA hB (hB.weakN henv (.succ .one)) he (he.weakN henv .one) | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
u : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort u)
v : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort v)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
hΞ : CtxStrong env U Ξβ
he : IsDefEqStrong env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
wβ : VLevel
hAB : IsDefEqStrong env U Ξβ (VExpr.forallE Aβ Bβ) (VExpr.forallE Aβ Bβ) (VExpr.sort wβ)
u : VLevel
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort u)
v : VLevel
hB : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort v)
hΞ' : CtxStrong env U (Aβ :: Ξβ)
β’ IsDefEqStrong env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .proofIrrel (ih1 hΞ) (ih2 hΞ) (ih3 hΞ) | case proofIrrel
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEq env U Ξβ pβ pβ (VExpr.sort VLevel.zero)
aβΒΉ : IsDefEq env U Ξβ hβ hβ pβ
aβ : IsDefEq env U Ξβ h'β h'β pβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ pβ pβ (VExpr.sort VLevel.zero)
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ hβ hβ pβ
ih3 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ h'β h'β pβ
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ hβ h'β pβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEq env U Ξβ pβ pβ (VExpr.sort VLevel.zero)
aβΒΉ : IsDefEq env U Ξβ hβ hβ pβ
aβ : IsDefEq env U Ξβ h'β h'β pβ
ih1 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ pβ pβ (VExpr.sort VLevel.zero)
ih2 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ hβ hβ pβ
ih3 : CtxStrong env U Ξβ β IsDefEqStrong env U Ξβ h'β h'β pβ
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ hβ h'β pβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | let β¨β¨hl, β¨_, htβ©, _β©, hr, _, _β© := envIH.2 h1 | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
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
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (VExpr.instL lsβ dfβ.lhs) (VExpr.instL lsβ dfβ.rhs) (VExpr.instL lsβ dfβ.type) | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
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
hΞ : CtxStrong env U Ξβ
hl : IsDefEqStrong env dfβ.uvars [] dfβ.lhs dfβ.lhs dfβ.type
wβ : VLevel
ht : IsDefEqStrong env dfβ.uvars [] dfβ.type dfβ.type (VExpr.sort wβ)
rightβΒΉ :
β (A B : VExpr),
dfβ.lhs = VExpr.forallE A B β
(β u, IsDefEqStrong env dfβ.uvars [] A A (VExpr.sort u)) β§ β u, IsDefEqStrong env dfβ.uvars [A] B B (VExpr.sort u)
hr : IsDefEqStrong env dfβ.uvars [] dfβ.rhs dfβ.rhs dfβ.type
leftβ : β u, IsDefEqStrong env dfβ.uvars [] dfβ.type dfβ.type (VExpr.sort u)
rightβ :
β (A B : VExpr),
dfβ.rhs = VExpr.forallE A B β
(β u, IsDefEqStrong env dfβ.uvars [] A A (VExpr.sort u)) β§ β u, IsDefEqStrong env dfβ.uvars [A] B B (VExpr.sort u)
β’ IsDefEqStrong env U Ξβ (VExpr.instL lsβ dfβ.lhs) (VExpr.instL lsβ dfβ.rhs) (VExpr.instL lsβ dfβ.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
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
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (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/Strong.lean | Lean4Lean.VEnv.IsDefEq.strong' | [408, 1] | [465, 88] | exact .extra h1 h2 h3 (.inst h2) (ht.instL h2)
(hl.instL h2) (hr.instL h2) ((hl.instL h2).weak0 henv) ((hr.instL h2).weak0 henv) | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
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
hΞ : CtxStrong env U Ξβ
hl : IsDefEqStrong env dfβ.uvars [] dfβ.lhs dfβ.lhs dfβ.type
wβ : VLevel
ht : IsDefEqStrong env dfβ.uvars [] dfβ.type dfβ.type (VExpr.sort wβ)
rightβΒΉ :
β (A B : VExpr),
dfβ.lhs = VExpr.forallE A B β
(β u, IsDefEqStrong env dfβ.uvars [] A A (VExpr.sort u)) β§ β u, IsDefEqStrong env dfβ.uvars [A] B B (VExpr.sort u)
hr : IsDefEqStrong env dfβ.uvars [] dfβ.rhs dfβ.rhs dfβ.type
leftβ : β u, IsDefEqStrong env dfβ.uvars [] dfβ.type dfβ.type (VExpr.sort u)
rightβ :
β (A B : VExpr),
dfβ.rhs = VExpr.forallE A B β
(β u, IsDefEqStrong env dfβ.uvars [] A A (VExpr.sort u)) β§ β u, IsDefEqStrong env dfβ.uvars [A] B B (VExpr.sort u)
β’ IsDefEqStrong env U Ξβ (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
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
hctx : β {Ξ : List VExpr}, (OnCtx Ξ fun Ξ A => β u, IsDefEqStrong env U Ξ A A (VExpr.sort u)) β OnCtx Ξ (IsType env U)
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
hΞ : CtxStrong env U Ξβ
hl : IsDefEqStrong env dfβ.uvars [] dfβ.lhs dfβ.lhs dfβ.type
wβ : VLevel
ht : IsDefEqStrong env dfβ.uvars [] dfβ.type dfβ.type (VExpr.sort wβ)
rightβΒΉ :
β (A B : VExpr),
dfβ.lhs = VExpr.forallE A B β
(β u, IsDefEqStrong env dfβ.uvars [] A A (VExpr.sort u)) β§ β u, IsDefEqStrong env dfβ.uvars [A] B B (VExpr.sort u)
hr : IsDefEqStrong env dfβ.uvars [] dfβ.rhs dfβ.rhs dfβ.type
leftβ : β u, IsDefEqStrong env dfβ.uvars [] dfβ.type dfβ.type (VExpr.sort u)
rightβ :
β (A B : VExpr),
dfβ.rhs = VExpr.forallE A B β
(β u, IsDefEqStrong env dfβ.uvars [] A A (VExpr.sort u)) β§ β u, IsDefEqStrong env dfβ.uvars [A] B B (VExpr.sort u)
β’ IsDefEqStrong env U Ξβ (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/Strong.lean | Lean4Lean.VEnv.CtxStrong.strong' | [467, 1] | [471, 90] | induction Ξ with
| nil => trivial
| cons _ _ ih => let β¨hΞ, _, hAβ© := hΞ; exact β¨ih hΞ, _, hA.strong' henv envIH (ih hΞ)β© | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
hΞ : OnCtx Ξ (IsType env U)
β’ CtxStrong env U Ξ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
hΞ : OnCtx Ξ (IsType env U)
β’ CtxStrong env U Ξ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.CtxStrong.strong' | [467, 1] | [471, 90] | trivial | case nil
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
hΞ : OnCtx [] (IsType env U)
β’ CtxStrong env U [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
hΞ : OnCtx [] (IsType env U)
β’ CtxStrong env U []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.CtxStrong.strong' | [467, 1] | [471, 90] | let β¨hΞ, _, hAβ© := hΞ | case cons
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
headβ : VExpr
tailβ : List VExpr
ih : OnCtx tailβ (IsType env U) β CtxStrong env U tailβ
hΞ : OnCtx (headβ :: tailβ) (IsType env U)
β’ CtxStrong env U (headβ :: tailβ) | case cons
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
headβ : VExpr
tailβ : List VExpr
ih : OnCtx tailβ (IsType env U) β CtxStrong env U tailβ
hΞβ : OnCtx (headβ :: tailβ) (IsType env U)
hΞ : OnCtx tailβ (IsType env U)
wβ : VLevel
hA : HasType env U tailβ headβ (sort wβ)
β’ CtxStrong env U (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
headβ : VExpr
tailβ : List VExpr
ih : OnCtx tailβ (IsType env U) β CtxStrong env U tailβ
hΞ : OnCtx (headβ :: tailβ) (IsType env U)
β’ CtxStrong env U (headβ :: tailβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.CtxStrong.strong' | [467, 1] | [471, 90] | exact β¨ih hΞ, _, hA.strong' henv envIH (ih hΞ)β© | case cons
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
headβ : VExpr
tailβ : List VExpr
ih : OnCtx tailβ (IsType env U) β CtxStrong env U tailβ
hΞβ : OnCtx (headβ :: tailβ) (IsType env U)
hΞ : OnCtx tailβ (IsType env U)
wβ : VLevel
hA : HasType env U tailβ headβ (sort wβ)
β’ CtxStrong env U (headβ :: tailβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
env : VEnv
U : Nat
henv : Ordered env
envIH : OnTypes env (EnvStrong env)
headβ : VExpr
tailβ : List VExpr
ih : OnCtx tailβ (IsType env U) β CtxStrong env U tailβ
hΞβ : OnCtx (headβ :: tailβ) (IsType env U)
hΞ : OnCtx tailβ (IsType env U)
wβ : VLevel
hA : HasType env U tailβ headβ (sort wβ)
β’ CtxStrong env U (headβ :: tailβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | have H' := H.strong henv hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V f a : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = app f a β¨ e2 = app f a
β’ β A B, HasType env U Ξ f (VExpr.forallE A B) β§ HasType env U Ξ a A | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V f a : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = app f a β¨ e2 = app f a
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β A B, HasType env U Ξ f (VExpr.forallE A B) β§ HasType env U Ξ a A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V f a : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = app f a β¨ e2 = app f a
β’ β A B, HasType env U Ξ f (VExpr.forallE A B) β§ HasType env U Ξ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | clear H hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V f a : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = app f a β¨ e2 = app f a
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β A B, HasType env U Ξ f (VExpr.forallE A B) β§ HasType env U Ξ a A | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
eq : e1 = app f a β¨ e2 = app f a
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β A B, HasType env U Ξ f (VExpr.forallE A B) β§ HasType env U Ξ a A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V f a : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = app f a β¨ e2 = app f a
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β A B, HasType env U Ξ f (VExpr.forallE A B) β§ HasType env U Ξ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact ih eq.symm | case symm
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : eβ = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : e'β = app f a β¨ eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : eβ = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : e'β = app f a β¨ eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | obtain eq | eq := eq <;> [exact ih1 (.inl eq); exact ih2 (.inr eq)] | case extra
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
aββΈ : env.defeqs dfβ
aββ· : β (l : VLevel), l β lsβ β VLevel.WF U l
aββΆ : 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βΒ² :
VExpr.instL lsβ dfβ.type = app f a β¨ VExpr.instL lsβ dfβ.type = app f a β
β A B, HasType env U [] f (VExpr.forallE A B) β§ HasType env U [] a A
a_ihβΒΉ :
VExpr.instL lsβ dfβ.lhs = app f a β¨ VExpr.instL lsβ dfβ.lhs = app f a β
β A B, HasType env U [] f (VExpr.forallE A B) β§ HasType env U [] a A
a_ihβ :
VExpr.instL lsβ dfβ.rhs = app f a β¨ VExpr.instL lsβ dfβ.rhs = app f a β
β A B, HasType env U [] f (VExpr.forallE A B) β§ HasType env U [] a A
ih1 :
VExpr.instL lsβ dfβ.lhs = app f a β¨ VExpr.instL lsβ dfβ.lhs = app f a β
β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ih2 :
VExpr.instL lsβ dfβ.rhs = app f a β¨ VExpr.instL lsβ dfβ.rhs = app f a β
β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : VExpr.instL lsβ dfβ.lhs = app f a β¨ VExpr.instL lsβ dfβ.rhs = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | 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 V f a : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
aββΈ : env.defeqs dfβ
aββ· : β (l : VLevel), l β lsβ β VLevel.WF U l
aββΆ : 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βΒ² :
VExpr.instL lsβ dfβ.type = app f a β¨ VExpr.instL lsβ dfβ.type = app f a β
β A B, HasType env U [] f (VExpr.forallE A B) β§ HasType env U [] a A
a_ihβΒΉ :
VExpr.instL lsβ dfβ.lhs = app f a β¨ VExpr.instL lsβ dfβ.lhs = app f a β
β A B, HasType env U [] f (VExpr.forallE A B) β§ HasType env U [] a A
a_ihβ :
VExpr.instL lsβ dfβ.rhs = app f a β¨ VExpr.instL lsβ dfβ.rhs = app f a β
β A B, HasType env U [] f (VExpr.forallE A B) β§ HasType env U [] a A
ih1 :
VExpr.instL lsβ dfβ.lhs = app f a β¨ VExpr.instL lsβ dfβ.lhs = app f a β
β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ih2 :
VExpr.instL lsβ dfβ.rhs = app f a β¨ VExpr.instL lsβ dfβ.rhs = app f a β
β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : VExpr.instL lsβ dfβ.lhs = app f a β¨ VExpr.instL lsβ dfβ.rhs = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | obtain β¨β¨β©β© | β¨β¨β©β© := eq | case appDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : 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β)
h1 : IsDefEqStrong env U Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
h2 : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (VExpr.sort vβ)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² : fβ = app f a β¨ f'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒΉ : aββ΅ = app f a β¨ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ aββ΅ = app f a β¨ inst Bβ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : app fβ aββ΅ = app f a β¨ app f'β a'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | case appDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
f'β a'β : 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_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
h1 : IsDefEqStrong env U Ξβ f f'β (VExpr.forallE Aβ Bβ)
a_ihβΒ² : f = app f a β¨ f'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
h2 : IsDefEqStrong env U Ξβ a a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ a) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ : a = app f a β¨ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ a = app f a β¨ inst Bβ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
case appDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ aββ΅ : 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_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
h1 : IsDefEqStrong env U Ξβ fβ f (VExpr.forallE Aβ Bβ)
a_ihβΒ² : fβ = app f a β¨ f = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
h2 : IsDefEqStrong env U Ξβ aββ΅ a Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a) (VExpr.sort vβ)
a_ihβΒΉ : aββ΅ = app f a β¨ a = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ aββ΅ = app f a β¨ inst Bβ a = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : 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β)
h1 : IsDefEqStrong env U Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
h2 : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (VExpr.sort vβ)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² : fβ = app f a β¨ f'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒΉ : aββ΅ = app f a β¨ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ aββ΅ = app f a β¨ inst Bβ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : app fβ aββ΅ = app f a β¨ app f'β a'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact β¨_, _, h1.defeq.hasType.1, h2.defeq.hasType.1β© | case appDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
f'β a'β : 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_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
h1 : IsDefEqStrong env U Ξβ f f'β (VExpr.forallE Aβ Bβ)
a_ihβΒ² : f = app f a β¨ f'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
h2 : IsDefEqStrong env U Ξβ a a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ a) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ : a = app f a β¨ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ a = app f a β¨ inst Bβ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
f'β a'β : 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_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
h1 : IsDefEqStrong env U Ξβ f f'β (VExpr.forallE Aβ Bβ)
a_ihβΒ² : f = app f a β¨ f'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
h2 : IsDefEqStrong env U Ξβ a a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ a) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ : a = app f a β¨ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ a = app f a β¨ inst Bβ a'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact β¨_, _, h1.defeq.hasType.2, h2.defeq.hasType.2β© | case appDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ aββ΅ : 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_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
h1 : IsDefEqStrong env U Ξβ fβ f (VExpr.forallE Aβ Bβ)
a_ihβΒ² : fβ = app f a β¨ f = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
h2 : IsDefEqStrong env U Ξβ aββ΅ a Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a) (VExpr.sort vβ)
a_ihβΒΉ : aββ΅ = app f a β¨ a = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ aββ΅ = app f a β¨ inst Bβ a = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ aββ΅ : 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_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
h1 : IsDefEqStrong env U Ξβ fβ f (VExpr.forallE Aβ Bβ)
a_ihβΒ² : fβ = app f a β¨ f = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
h2 : IsDefEqStrong env U Ξβ aββ΅ a Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a) (VExpr.sort vβ)
a_ihβΒΉ : aββ΅ = app f a β¨ a = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ aββ΅ = app f a β¨ inst Bβ a = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact ih2 eq | case defeqDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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β
a_ihβ : Aβ = app f a β¨ Bβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ih2 : e1β = app f a β¨ e2β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : e1β = app f a β¨ e2β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | 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 V f a : VExpr
Ξβ : 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β
a_ihβ : Aβ = app f a β¨ Bβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ih2 : e1β = app f a β¨ e2β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : e1β = app f a β¨ e2β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | obtain β¨β¨β©β© | eq := eq | case beta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
he' : 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'β)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app f a β¨ eβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ : e'β = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ e'β = app f a β¨ inst Bβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ e'β = app f a β¨ inst eβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : app (lam Aβ eβ) e'β = app f a β¨ inst eβ e'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | case beta.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
a_ihββ΄ :
Aβ = app (lam Aβ eβ) a β¨ Aβ = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app (lam Aβ eβ) a β¨ Bβ = app (lam Aβ eβ) a β
β A B, HasType env U (Aβ :: Ξβ) (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app (lam Aβ eβ) a β¨ eβ = app (lam Aβ eβ) a β
β A B, HasType env U (Aβ :: Ξβ) (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
he' : IsDefEqStrong env U Ξβ a a Aβ
aβΒΉ : IsDefEqStrong env U Ξβ (inst Bβ a) (inst Bβ a) (VExpr.sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ a) (inst eβ a) (inst Bβ a)
a_ihβΒΉ :
a = app (lam Aβ eβ) a β¨ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ a = app (lam Aβ eβ) a β¨ inst Bβ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ a = app (lam Aβ eβ) a β¨ inst eβ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
he' : 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'β)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app f a β¨ eβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ : e'β = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ e'β = app f a β¨ inst Bβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ e'β = app f a β¨ inst eβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : inst eβ e'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
he' : 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'β)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app f a β¨ eβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ : e'β = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ e'β = app f a β¨ inst Bβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ e'β = app f a β¨ inst eβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : app (lam Aβ eβ) e'β = app f a β¨ inst eβ e'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact β¨_, _, .lam hA.defeq he.defeq, he'.defeqβ© | case beta.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
a_ihββ΄ :
Aβ = app (lam Aβ eβ) a β¨ Aβ = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app (lam Aβ eβ) a β¨ Bβ = app (lam Aβ eβ) a β
β A B, HasType env U (Aβ :: Ξβ) (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app (lam Aβ eβ) a β¨ eβ = app (lam Aβ eβ) a β
β A B, HasType env U (Aβ :: Ξβ) (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
he' : IsDefEqStrong env U Ξβ a a Aβ
aβΒΉ : IsDefEqStrong env U Ξβ (inst Bβ a) (inst Bβ a) (VExpr.sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ a) (inst eβ a) (inst Bβ a)
a_ihβΒΉ :
a = app (lam Aβ eβ) a β¨ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ a = app (lam Aβ eβ) a β¨ inst Bβ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ a = app (lam Aβ eβ) a β¨ inst eβ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
a_ihββ΄ :
Aβ = app (lam Aβ eβ) a β¨ Aβ = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app (lam Aβ eβ) a β¨ Bβ = app (lam Aβ eβ) a β
β A B, HasType env U (Aβ :: Ξβ) (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app (lam Aβ eβ) a β¨ eβ = app (lam Aβ eβ) a β
β A B, HasType env U (Aβ :: Ξβ) (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
he' : IsDefEqStrong env U Ξβ a a Aβ
aβΒΉ : IsDefEqStrong env U Ξβ (inst Bβ a) (inst Bβ a) (VExpr.sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ a) (inst eβ a) (inst Bβ a)
a_ihβΒΉ :
a = app (lam Aβ eβ) a β¨ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ a = app (lam Aβ eβ) a β¨ inst Bβ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ a = app (lam Aβ eβ) a β¨ inst eβ a = app (lam Aβ eβ) a β
β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
β’ β A B, HasType env U Ξβ (lam Aβ eβ) (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact ihee (.inl eq) | case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
he' : 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'β)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app f a β¨ eβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ : e'β = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ e'β = app f a β¨ inst Bβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ e'β = app f a β¨ inst eβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : inst eβ e'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
he : IsDefEqStrong env U (Aβ :: Ξβ) eβ eβ Bβ
he' : 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'β)
a_ihββ΄ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ³ :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒ² :
eβ = app f a β¨ eβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ : e'β = app f a β¨ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
inst Bβ e'β = app f a β¨ inst Bβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
ihee :
inst eβ e'β = app f a β¨ inst eβ e'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
eq : inst eβ e'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | obtain β¨β¨β©β© | eq := eq | case eta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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))
a_ihβΒ³ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ² :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ :
liftN 1 Bβ 1 = app f a β¨ liftN 1 Bβ 1 = app f a β
β A B, HasType env U (lift Aβ :: Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (lift Aβ :: Aβ :: Ξβ) a A
ih : eβ = app f a β¨ eβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
lift eβ = app f a β¨ lift eβ = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
eq : lam Aβ (app (lift eβ) (VExpr.bvar 0)) = app f a β¨ eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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))
a_ihβΒ³ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ² :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ :
liftN 1 Bβ 1 = app f a β¨ liftN 1 Bβ 1 = app f a β
β A B, HasType env U (lift Aβ :: Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (lift Aβ :: Aβ :: Ξβ) a A
ih : eβ = app f a β¨ eβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
lift eβ = app f a β¨ lift eβ = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
eq : eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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))
a_ihβΒ³ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ² :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ :
liftN 1 Bβ 1 = app f a β¨ liftN 1 Bβ 1 = app f a β
β A B, HasType env U (lift Aβ :: Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (lift Aβ :: Aβ :: Ξβ) a A
ih : eβ = app f a β¨ eβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
lift eβ = app f a β¨ lift eβ = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
eq : lam Aβ (app (lift eβ) (VExpr.bvar 0)) = app f a β¨ eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | exact ih (.inl eq) | case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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))
a_ihβΒ³ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ² :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ :
liftN 1 Bβ 1 = app f a β¨ liftN 1 Bβ 1 = app f a β
β A B, HasType env U (lift Aβ :: Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (lift Aβ :: Aβ :: Ξβ) a A
ih : eβ = app f a β¨ eβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
lift eβ = app f a β¨ lift eβ = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
eq : eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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))
a_ihβΒ³ : Aβ = app f a β¨ Aβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒ² :
Bβ = app f a β¨ Bβ = app f a β β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβΒΉ :
liftN 1 Bβ 1 = app f a β¨ liftN 1 Bβ 1 = app f a β
β A B, HasType env U (lift Aβ :: Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (lift Aβ :: Aβ :: Ξβ) a A
ih : eβ = app f a β¨ eβ = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβ :
lift eβ = app f a β¨ lift eβ = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
eq : eβ = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.app_inv' | [489, 1] | [511, 20] | nomatch eq | case forallEDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V f a : VExpr
Ξβ : 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β)
a_ihβΒ² : Aβ = app f a β¨ A'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒΉ :
bodyβ = app f a β¨ body'β = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβ :
bodyβ = app f a β¨ body'β = app f a β
β A B, HasType env U (A'β :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (A'β :: Ξβ) a A
eq : VExpr.forallE Aβ bodyβ = app f a β¨ VExpr.forallE A'β body'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A | 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 V f a : VExpr
Ξβ : 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β)
a_ihβΒ² : Aβ = app f a β¨ A'β = app f a β β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
a_ihβΒΉ :
bodyβ = app f a β¨ body'β = app f a β
β A B, HasType env U (Aβ :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (Aβ :: Ξβ) a A
a_ihβ :
bodyβ = app f a β¨ body'β = app f a β
β A B, HasType env U (A'β :: Ξβ) f (VExpr.forallE A B) β§ HasType env U (A'β :: Ξβ) a A
eq : VExpr.forallE Aβ bodyβ = app f a β¨ VExpr.forallE A'β body'β = app f a
β’ β A B, HasType env U Ξβ f (VExpr.forallE A B) β§ HasType env U Ξβ a A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | have H' := H.strong henv hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V A body : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = lam A body β¨ e2 = lam A body
β’ IsType env U Ξ A β§ WF env U (A :: Ξ) body | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V A body : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = lam A body β¨ e2 = lam A body
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ IsType env U Ξ A β§ WF env U (A :: Ξ) body | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V A body : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = lam A body β¨ e2 = lam A body
β’ IsType env U Ξ A β§ WF env U (A :: Ξ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | clear H hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V A body : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = lam A body β¨ e2 = lam A body
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ IsType env U Ξ A β§ WF env U (A :: Ξ) body | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
eq : e1 = lam A body β¨ e2 = lam A body
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ IsType env U Ξ A β§ WF env U (A :: Ξ) body | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V A body : VExpr
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = lam A body β¨ e2 = lam A body
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ IsType env U Ξ A β§ WF env U (A :: Ξ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact ih eq.symm | case symm
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : eβ = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : e'β = lam A body β¨ eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : eβ = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : e'β = lam A body β¨ eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | obtain eq | eq := eq <;> [exact ih1 (.inl eq); exact ih2 (.inr eq)] | case extra
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
aββΈ : env.defeqs dfβ
aββ· : β (l : VLevel), l β lsβ β VLevel.WF U l
aββΆ : 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βΒ² :
VExpr.instL lsβ dfβ.type = lam A body β¨ VExpr.instL lsβ dfβ.type = lam A body β IsType env U [] A β§ WF env U [A] body
a_ihβΒΉ :
VExpr.instL lsβ dfβ.lhs = lam A body β¨ VExpr.instL lsβ dfβ.lhs = lam A body β IsType env U [] A β§ WF env U [A] body
a_ihβ :
VExpr.instL lsβ dfβ.rhs = lam A body β¨ VExpr.instL lsβ dfβ.rhs = lam A body β IsType env U [] A β§ WF env U [A] body
ih1 :
VExpr.instL lsβ dfβ.lhs = lam A body β¨ VExpr.instL lsβ dfβ.lhs = lam A body β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ih2 :
VExpr.instL lsβ dfβ.rhs = lam A body β¨ VExpr.instL lsβ dfβ.rhs = lam A body β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : VExpr.instL lsβ dfβ.lhs = lam A body β¨ VExpr.instL lsβ dfβ.rhs = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | 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 V A body : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
aββΈ : env.defeqs dfβ
aββ· : β (l : VLevel), l β lsβ β VLevel.WF U l
aββΆ : 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βΒ² :
VExpr.instL lsβ dfβ.type = lam A body β¨ VExpr.instL lsβ dfβ.type = lam A body β IsType env U [] A β§ WF env U [A] body
a_ihβΒΉ :
VExpr.instL lsβ dfβ.lhs = lam A body β¨ VExpr.instL lsβ dfβ.lhs = lam A body β IsType env U [] A β§ WF env U [A] body
a_ihβ :
VExpr.instL lsβ dfβ.rhs = lam A body β¨ VExpr.instL lsβ dfβ.rhs = lam A body β IsType env U [] A β§ WF env U [A] body
ih1 :
VExpr.instL lsβ dfβ.lhs = lam A body β¨ VExpr.instL lsβ dfβ.lhs = lam A body β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ih2 :
VExpr.instL lsβ dfβ.rhs = lam A body β¨ VExpr.instL lsβ dfβ.rhs = lam A body β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : VExpr.instL lsβ dfβ.lhs = lam A body β¨ VExpr.instL lsβ dfβ.rhs = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | obtain β¨β¨β©β© | β¨β¨β©β© := eq | case lamDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ body'β : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
h1 : 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β)
h4 : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
h5 : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
a_ihββ΄ : Aβ = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
a_ihβΒΉ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
eq : lam Aβ bodyβ = lam A body β¨ lam A'β body'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | case lamDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
body'β : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
aβΒΉ : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihββ΄ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
h1 : IsDefEqStrong env U Ξβ A A'β (VExpr.sort uβ)
aβ : IsDefEqStrong env U (A :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihβΒ³ : A = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
h5 : IsDefEqStrong env U (A'β :: Ξβ) body body'β Bβ
a_ihβΒΉ : body = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
h4 : IsDefEqStrong env U (A :: Ξβ) body body'β Bβ
a_ihβ : body = lam A body β¨ body'β = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
case lamDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihββ΄ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
h1 : IsDefEqStrong env U Ξβ Aβ A (VExpr.sort uβ)
aβ : IsDefEqStrong env U (A :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihβΒ³ : Aβ = lam A body β¨ A = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
h4 : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body Bβ
a_ihβΒΉ : bodyβ = lam A body β¨ body = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
h5 : IsDefEqStrong env U (A :: Ξβ) bodyβ body Bβ
a_ihβ : bodyβ = lam A body β¨ body = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ body'β : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
h1 : 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β)
h4 : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
h5 : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
a_ihββ΄ : Aβ = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
a_ihβΒΉ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
eq : lam Aβ bodyβ = lam A body β¨ lam A'β body'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact β¨β¨_, h1.defeq.hasType.1β©, _, h4.defeq.hasType.1β© | case lamDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
body'β : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
aβΒΉ : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihββ΄ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
h1 : IsDefEqStrong env U Ξβ A A'β (VExpr.sort uβ)
aβ : IsDefEqStrong env U (A :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihβΒ³ : A = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
h5 : IsDefEqStrong env U (A'β :: Ξβ) body body'β Bβ
a_ihβΒΉ : body = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
h4 : IsDefEqStrong env U (A :: Ξβ) body body'β Bβ
a_ihβ : body = lam A body β¨ body'β = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
body'β : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
aβΒΉ : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihββ΄ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
h1 : IsDefEqStrong env U Ξβ A A'β (VExpr.sort uβ)
aβ : IsDefEqStrong env U (A :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihβΒ³ : A = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
h5 : IsDefEqStrong env U (A'β :: Ξβ) body body'β Bβ
a_ihβΒΉ : body = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
h4 : IsDefEqStrong env U (A :: Ξβ) body body'β Bβ
a_ihβ : body = lam A body β¨ body'β = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact β¨β¨_, h1.defeq.hasType.2β©, _, h5.defeq.hasType.2β© | case lamDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihββ΄ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
h1 : IsDefEqStrong env U Ξβ Aβ A (VExpr.sort uβ)
aβ : IsDefEqStrong env U (A :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihβΒ³ : Aβ = lam A body β¨ A = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
h4 : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body Bβ
a_ihβΒΉ : bodyβ = lam A body β¨ body = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
h5 : IsDefEqStrong env U (A :: Ξβ) bodyβ body Bβ
a_ihβ : bodyβ = lam A body β¨ body = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ : VExpr
aβΒ³ : VLevel.WF U uβ
aβΒ² : VLevel.WF U vβ
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihββ΄ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
h1 : IsDefEqStrong env U Ξβ Aβ A (VExpr.sort uβ)
aβ : IsDefEqStrong env U (A :: Ξβ) Bβ Bβ (VExpr.sort vβ)
a_ihβΒ³ : Aβ = lam A body β¨ A = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
h4 : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body Bβ
a_ihβΒΉ : bodyβ = lam A body β¨ body = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
h5 : IsDefEqStrong env U (A :: Ξβ) bodyβ body Bβ
a_ihβ : bodyβ = lam A body β¨ body = lam A body β IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact ih2 eq | case defeqDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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β
a_ihβ : Aβ = lam A body β¨ Bβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ih2 : e1β = lam A body β¨ e2β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : e1β = lam A body β¨ e2β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | 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 V A body : VExpr
Ξβ : 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β
a_ihβ : Aβ = lam A body β¨ Bβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ih2 : e1β = lam A body β¨ e2β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : e1β = lam A body β¨ e2β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | obtain β¨β¨β©β© | eq := eq | case beta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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'β)
a_ihββ΄ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : eβ = lam A body β¨ eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ : e'β = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : inst Bβ e'β = lam A body β¨ inst Bβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ihee : inst eβ e'β = lam A body β¨ inst eβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : app (lam Aβ eβ) e'β = lam A body β¨ inst eβ e'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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'β)
a_ihββ΄ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : eβ = lam A body β¨ eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ : e'β = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : inst Bβ e'β = lam A body β¨ inst Bβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ihee : inst eβ e'β = lam A body β¨ inst eβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : inst eβ e'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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'β)
a_ihββ΄ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : eβ = lam A body β¨ eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ : e'β = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : inst Bβ e'β = lam A body β¨ inst Bβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ihee : inst eβ e'β = lam A body β¨ inst eβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : app (lam Aβ eβ) e'β = lam A body β¨ inst eβ e'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact ihee (.inl eq) | case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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'β)
a_ihββ΄ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : eβ = lam A body β¨ eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ : e'β = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : inst Bβ e'β = lam A body β¨ inst Bβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ihee : inst eβ e'β = lam A body β¨ inst eβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : inst eβ e'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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'β)
a_ihββ΄ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ³ : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒ² : eβ = lam A body β¨ eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ : e'β = lam A body β¨ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : inst Bβ e'β = lam A body β¨ inst Bβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
ihee : inst eβ e'β = lam A body β¨ inst eβ e'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
eq : inst eβ e'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | obtain β¨β¨β©β© | eq := eq | case eta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A body β¨ liftN 1 Bβ 1 = lam A body β
IsType env U (lift Aβ :: Aβ :: Ξβ) A β§ WF env U (A :: lift Aβ :: Aβ :: Ξβ) body
ih : eβ = lam A body β¨ eβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : lift eβ = lam A body β¨ lift eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
eq : lam Aβ (app (lift eβ) (VExpr.bvar 0)) = lam A body β¨ eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | case eta.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A : VExpr
Ξβ : List VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (A :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift A) (liftN 1 Bβ 1))
ih :
eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒ³ :
A = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ A = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒ² :
Bβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ Bβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ liftN 1 Bβ 1 = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (lift A :: A :: Ξβ) A β§ WF env U (A :: lift A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβ :
lift eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ lift eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A body β¨ liftN 1 Bβ 1 = lam A body β
IsType env U (lift Aβ :: Aβ :: Ξβ) A β§ WF env U (A :: lift Aβ :: Aβ :: Ξβ) body
ih : eβ = lam A body β¨ eβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : lift eβ = lam A body β¨ lift eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
eq : eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A body β¨ liftN 1 Bβ 1 = lam A body β
IsType env U (lift Aβ :: Aβ :: Ξβ) A β§ WF env U (A :: lift Aβ :: Aβ :: Ξβ) body
ih : eβ = lam A body β¨ eβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : lift eβ = lam A body β¨ lift eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
eq : lam Aβ (app (lift eβ) (VExpr.bvar 0)) = lam A body β¨ eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact β¨β¨_, hA.defeq.hasType.1β©, _, he'.defeq.hasType.1.app (.bvar .zero)β© | case eta.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A : VExpr
Ξβ : List VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (A :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift A) (liftN 1 Bβ 1))
ih :
eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒ³ :
A = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ A = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒ² :
Bβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ Bβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ liftN 1 Bβ 1 = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (lift A :: A :: Ξβ) A β§ WF env U (A :: lift A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβ :
lift eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ lift eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A : VExpr
Ξβ : List VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (A :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift A) (liftN 1 Bβ 1))
ih :
eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒ³ :
A = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ A = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒ² :
Bβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ Bβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ liftN 1 Bβ 1 = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (lift A :: A :: Ξβ) A β§ WF env U (A :: lift A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
a_ihβ :
lift eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β¨ lift eβ = lam A (app (lift eβ) (VExpr.bvar 0)) β
IsType env U (A :: Ξβ) A β§ WF env U (A :: A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) (app (lift eβ) (VExpr.bvar 0))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | exact ih (.inl eq) | case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A body β¨ liftN 1 Bβ 1 = lam A body β
IsType env U (lift Aβ :: Aβ :: Ξβ) A β§ WF env U (A :: lift Aβ :: Aβ :: Ξβ) body
ih : eβ = lam A body β¨ eβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : lift eβ = lam A body β¨ lift eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
eq : eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
aββ΄ : VLevel.WF U uβ
aβΒ³ : VLevel.WF U vβ
hA : 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β)
he' : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (VExpr.forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : Aβ = lam A body β¨ Aβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒ² : Bβ = lam A body β¨ Bβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβΒΉ :
liftN 1 Bβ 1 = lam A body β¨ liftN 1 Bβ 1 = lam A body β
IsType env U (lift Aβ :: Aβ :: Ξβ) A β§ WF env U (A :: lift Aβ :: Aβ :: Ξβ) body
ih : eβ = lam A body β¨ eβ = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβ : lift eβ = lam A body β¨ lift eβ = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
eq : eβ = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.lam_inv' | [524, 1] | [546, 20] | nomatch eq | case forallEDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V A body : VExpr
Ξβ : 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β)
a_ihβΒ² : Aβ = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒΉ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
eq : VExpr.forallE Aβ bodyβ = lam A body β¨ VExpr.forallE A'β body'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body | 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 V A body : VExpr
Ξβ : 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β)
a_ihβΒ² : Aβ = lam A body β¨ A'β = lam A body β IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
a_ihβΒΉ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (Aβ :: Ξβ) A β§ WF env U (A :: Aβ :: Ξβ) body
a_ihβ : bodyβ = lam A body β¨ body'β = lam A body β IsType env U (A'β :: Ξβ) A β§ WF env U (A :: A'β :: Ξβ) body
eq : VExpr.forallE Aβ bodyβ = lam A body β¨ VExpr.forallE A'β body'β = lam A body
β’ IsType env U Ξβ A β§ WF env U (A :: Ξβ) body
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | have H' := H.strong henv hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V : VExpr
c : Name
ls : List VLevel
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = VExpr.const c ls β¨ e2 = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V : VExpr
c : Name
ls : List VLevel
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = VExpr.const c ls β¨ e2 = VExpr.const c ls
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V : VExpr
c : Name
ls : List VLevel
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = VExpr.const c ls β¨ e2 = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | clear H hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V : VExpr
c : Name
ls : List VLevel
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = VExpr.const c ls β¨ e2 = VExpr.const c ls
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
eq : e1 = VExpr.const c ls β¨ e2 = VExpr.const c ls
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
e1 e2 V : VExpr
c : Name
ls : List VLevel
H : IsDefEq env U Ξ e1 e2 V
eq : e1 = VExpr.const c ls β¨ e2 = VExpr.const c ls
H' : IsDefEqStrong env U Ξ e1 e2 V
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | exact ih eq.symm | case symm
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih :
eβ = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : e'β = VExpr.const c ls β¨ eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih :
eβ = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : e'β = VExpr.const c ls β¨ eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | obtain eq | eq := eq <;> [exact ih1 (.inl eq); exact ih2 (.inr eq)] | case extra
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
aββΈ : env.defeqs dfβ
aββ· : β (l : VLevel), l β lsβ β VLevel.WF U l
aββΆ : 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βΒ² :
VExpr.instL lsβ dfβ.type = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih1 :
VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih2 :
VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.rhs = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | 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 V : VExpr
c : Name
ls : List VLevel
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
aββΈ : env.defeqs dfβ
aββ· : β (l : VLevel), l β lsβ β VLevel.WF U l
aββΆ : 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βΒ² :
VExpr.instL lsβ dfβ.type = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih1 :
VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih2 :
VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.rhs = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : VExpr.instL lsβ dfβ.lhs = VExpr.const c ls β¨ VExpr.instL lsβ dfβ.rhs = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | obtain β¨β¨β©β© | β¨β¨β©β© := eq | case constDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
cβ : Name
ciβ : VConstant
lsβ ls'β : List VLevel
uβ : 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'β
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : VExpr.const cβ lsβ = VExpr.const c ls β¨ VExpr.const cβ ls'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | case constDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
ciβ : VConstant
ls'β : List VLevel
uβ : VLevel
Ξβ : List VExpr
h3 : β (l : VLevel), l β ls'β β VLevel.WF U l
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ a_ihβΒ² :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
h1 : env.constants c = some (some ciβ)
h2 : β (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'β
aβΒΉ : IsDefEqStrong env U [] (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
a_ihβΒΉ a_ihβ :
VExpr.instL ls ciβ.type = VExpr.const c ls β¨ VExpr.instL ls ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
case constDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
ciβ : VConstant
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h4 : List.length lsβ = ciβ.uvars
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ a_ihβΒ² :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
h1 : env.constants c = some (some ciβ)
h3 : β (l : VLevel), l β ls β VLevel.WF U l
h5 : List.Forallβ (fun x x_1 => x β x_1) lsβ ls
aβΒΉ : IsDefEqStrong env U [] (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
a_ihβΒΉ a_ihβ :
VExpr.instL ls ciβ.type = VExpr.const c ls β¨ VExpr.instL ls ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
cβ : Name
ciβ : VConstant
lsβ ls'β : List VLevel
uβ : 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'β
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : VExpr.const cβ lsβ = VExpr.const c ls β¨ VExpr.const cβ ls'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | exact β¨_, h1, h2, h4β© | case constDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
ciβ : VConstant
ls'β : List VLevel
uβ : VLevel
Ξβ : List VExpr
h3 : β (l : VLevel), l β ls'β β VLevel.WF U l
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ a_ihβΒ² :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
h1 : env.constants c = some (some ciβ)
h2 : β (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'β
aβΒΉ : IsDefEqStrong env U [] (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
a_ihβΒΉ a_ihβ :
VExpr.instL ls ciβ.type = VExpr.const c ls β¨ VExpr.instL ls ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF.inl.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
ciβ : VConstant
ls'β : List VLevel
uβ : VLevel
Ξβ : List VExpr
h3 : β (l : VLevel), l β ls'β β VLevel.WF U l
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ a_ihβΒ² :
VExpr.instL ls'β ciβ.type = VExpr.const c ls β¨ VExpr.instL ls'β ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
h1 : env.constants c = some (some ciβ)
h2 : β (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'β
aβΒΉ : IsDefEqStrong env U [] (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
a_ihβΒΉ a_ihβ :
VExpr.instL ls ciβ.type = VExpr.const c ls β¨ VExpr.instL ls ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | exact β¨_, h1, h3, h5.length_eq.symm.trans h4β© | case constDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
ciβ : VConstant
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h4 : List.length lsβ = ciβ.uvars
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ a_ihβΒ² :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
h1 : env.constants c = some (some ciβ)
h3 : β (l : VLevel), l β ls β VLevel.WF U l
h5 : List.Forallβ (fun x x_1 => x β x_1) lsβ ls
aβΒΉ : IsDefEqStrong env U [] (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
a_ihβΒΉ a_ihβ :
VExpr.instL ls ciβ.type = VExpr.const c ls β¨ VExpr.instL ls ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF.inr.refl
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
ciβ : VConstant
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h4 : List.length lsβ = ciβ.uvars
aββ΄ : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
aβΒ² : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort uβ)
a_ihβΒ³ a_ihβΒ² :
VExpr.instL lsβ ciβ.type = VExpr.const c ls β¨ VExpr.instL lsβ ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
h1 : env.constants c = some (some ciβ)
h3 : β (l : VLevel), l β ls β VLevel.WF U l
h5 : List.Forallβ (fun x x_1 => x β x_1) lsβ ls
aβΒΉ : IsDefEqStrong env U [] (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls ciβ.type) (VExpr.instL ls ciβ.type) (VExpr.sort uβ)
a_ihβΒΉ a_ihβ :
VExpr.instL ls ciβ.type = VExpr.const c ls β¨ VExpr.instL ls ciβ.type = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | exact ih2 eq | case defeqDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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β
a_ihβ :
Aβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih2 :
e1β = VExpr.const c ls β¨ e2β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : e1β = VExpr.const c ls β¨ e2β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | 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 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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β
a_ihβ :
Aβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih2 :
e1β = VExpr.const c ls β¨ e2β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : e1β = VExpr.const c ls β¨ e2β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | obtain β¨β¨β©β© | eq := eq | case beta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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'β)
a_ihββ΄ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ³ :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
e'β = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
inst Bβ e'β = VExpr.const c ls β¨ inst Bβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ihee :
inst eβ e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : app (lam Aβ eβ) e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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'β)
a_ihββ΄ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ³ :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
e'β = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
inst Bβ e'β = VExpr.const c ls β¨ inst Bβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ihee :
inst eβ e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : inst eβ e'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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'β)
a_ihββ΄ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ³ :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
e'β = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
inst Bβ e'β = VExpr.const c ls β¨ inst Bβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ihee :
inst eβ e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : app (lam Aβ eβ) e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | exact ihee (.inl eq) | case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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'β)
a_ihββ΄ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ³ :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
e'β = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
inst Bβ e'β = VExpr.const c ls β¨ inst Bβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ihee :
inst eβ e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : inst eβ e'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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'β)
a_ihββ΄ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ³ :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
e'β = VExpr.const c ls β¨ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
inst Bβ e'β = VExpr.const c ls β¨ inst Bβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ihee :
inst eβ e'β = VExpr.const c ls β¨ inst eβ e'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : inst eβ e'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | obtain β¨β¨β©β© | eq := eq | case eta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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))
a_ihβΒ³ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
liftN 1 Bβ 1 = VExpr.const c ls β¨ liftN 1 Bβ 1 = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
lift eβ = VExpr.const c ls β¨ lift eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : lam Aβ (app (lift eβ) (VExpr.bvar 0)) = VExpr.const c ls β¨ eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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))
a_ihβΒ³ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
liftN 1 Bβ 1 = VExpr.const c ls β¨ liftN 1 Bβ 1 = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
lift eβ = VExpr.const c ls β¨ lift eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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))
a_ihβΒ³ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
liftN 1 Bβ 1 = VExpr.const c ls β¨ liftN 1 Bβ 1 = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
lift eβ = VExpr.const c ls β¨ lift eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : lam Aβ (app (lift eβ) (VExpr.bvar 0)) = VExpr.const c ls β¨ eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | exact ih (.inl eq) | case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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))
a_ihβΒ³ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
liftN 1 Bβ 1 = VExpr.const c ls β¨ liftN 1 Bβ 1 = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
lift eβ = VExpr.const c ls β¨ lift eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.inr
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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))
a_ihβΒ³ :
Aβ = VExpr.const c ls β¨ Aβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒ² :
Bβ = VExpr.const c ls β¨ Bβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ :
liftN 1 Bβ 1 = VExpr.const c ls β¨ liftN 1 Bβ 1 = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
ih :
eβ = VExpr.const c ls β¨ eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβ :
lift eβ = VExpr.const c ls β¨ lift eβ = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : eβ = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEq.const_inv' | [559, 1] | [580, 20] | nomatch eq | case forallEDF
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
e1 e2 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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β)
a_ihβΒ² :
Aβ = VExpr.const c ls β¨ A'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ a_ihβ :
bodyβ = VExpr.const c ls β¨ body'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : VExpr.forallE Aβ bodyβ = VExpr.const c ls β¨ VExpr.forallE A'β body'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars | 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 V : VExpr
c : Name
ls : List VLevel
Ξβ : 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β)
a_ihβΒ² :
Aβ = VExpr.const c ls β¨ A'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
a_ihβΒΉ a_ihβ :
bodyβ = VExpr.const c ls β¨ body'β = VExpr.const c ls β
β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
eq : VExpr.forallE Aβ bodyβ = VExpr.const c ls β¨ VExpr.forallE A'β body'β = VExpr.const c ls
β’ β ci, env.constants c = some (some ci) β§ (β (l : VLevel), l β ls β VLevel.WF U l) β§ List.length ls = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | refine with_addConst (cis := [.const _ eqConst]) (hcis := β¨hq, β¨β©β©) henv
(fun _ => β¨_, by type_tacβ©) fun henv => ?_ | env env' : VEnv
henv : Ordered env
hq : QuotReady env
β’ addQuot env = some env' β Ordered env' | env env' : VEnv
henvβ : Ordered env
hq : QuotReady env
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β [VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env' | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henv : Ordered env
hq : QuotReady env
β’ addQuot env = some env' β Ordered env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | refine with_addConst henv (fun β¨quot, _β© => β¨_, by type_tacβ©) fun henv => ?_ | env env' : VEnv
henvβ : Ordered env
hq : QuotReady env
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β [VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env' | env env' : VEnv
henvβΒΉ : Ordered env
hq : QuotReady env
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst),
VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env' | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβ : Ordered env
hq : QuotReady env
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β [VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | refine with_addConst henv (fun β¨_, quot, _β© => β¨_, by type_tacβ©) fun henv => ?_ | env env' : VEnv
henvβΒΉ : Ordered env
hq : QuotReady env
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst),
VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env' | env env' : VEnv
henvβΒ² : Ordered env
hq : QuotReady env
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env' | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβΒΉ : Ordered env
hq : QuotReady env
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst),
VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | refine with_addConst henv (fun β¨_, _, quot, eq, _β© => β¨_, by type_tacβ©) fun henv => ?_ | env env' : VEnv
henvβΒ² : Ordered env
hq : QuotReady env
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env' | env env' : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.lift (some quotLiftConst), VObject.const `Quot.ind (some quotIndConst),
VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst),
VObject.const `Eq (some eqConst)] β
some (addDefEq env1β quotDefEq) = some env' β Ordered env' | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβΒ² : Ordered env
hq : QuotReady env
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)] β
(do
let env β addConst env1β `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env' β
Ordered env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | rintro β¨_, _, _, _, eq, _β© β¨β© | env env' : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.lift (some quotLiftConst), VObject.const `Quot.ind (some quotIndConst),
VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst),
VObject.const `Eq (some eqConst)] β
some (addDefEq env1β quotDefEq) = some env' β Ordered env' | case intro.intro.intro.intro.intro.refl
env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ Ordered (addDefEq env1β quotDefEq) | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
β’ HasObjects env1β
[VObject.const `Quot.lift (some quotLiftConst), VObject.const `Quot.ind (some quotIndConst),
VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst),
VObject.const `Eq (some eqConst)] β
some (addDefEq env1β quotDefEq) = some env' β Ordered env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | exact .defeq henv β¨by type_tac, by type_tacβ© | case intro.intro.intro.intro.intro.refl
env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ Ordered (addDefEq env1β quotDefEq) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.refl
env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ Ordered (addDefEq env1β quotDefEq)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | type_tac | env env' : VEnv
henv : Ordered env
hq : QuotReady env
xβ : HasObjects env [VObject.const `Eq (some eqConst)]
β’ HasType env quotConst.uvars [] quotConst.type (VExpr.sort (?m.204 xβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henv : Ordered env
hq : QuotReady env
xβ : HasObjects env [VObject.const `Eq (some eqConst)]
β’ HasType env quotConst.uvars [] quotConst.type (VExpr.sort (?m.204 xβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | type_tac | env env' : VEnv
henvβ : Ordered env
hq : QuotReady env
env1β : VEnv
henv : Ordered env1β
xβ : HasObjects env1β [VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)]
quot : env1β.constants `Quot = some (some quotConst)
rightβ : HasObjects env1β [VObject.const `Eq (some eqConst)]
β’ HasType env1β quotMkConst.uvars [] quotMkConst.type (VExpr.sort (?m.743 xβ quot rightβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβ : Ordered env
hq : QuotReady env
env1β : VEnv
henv : Ordered env1β
xβ : HasObjects env1β [VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)]
quot : env1β.constants `Quot = some (some quotConst)
rightβ : HasObjects env1β [VObject.const `Eq (some eqConst)]
β’ HasType env1β quotMkConst.uvars [] quotMkConst.type (VExpr.sort (?m.743 xβ quot rightβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | type_tac | env env' : VEnv
henvβΒΉ : Ordered env
hq : QuotReady env
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
xβ :
HasObjects env1β
[VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)]
leftβ : env1β.constants `Quot.mk = some (some quotMkConst)
quot : env1β.constants `Quot = some (some quotConst)
rightβ : HasObjects env1β [VObject.const `Eq (some eqConst)]
β’ HasType env1β quotIndConst.uvars [] quotIndConst.type (VExpr.sort (?m.2200 xβ leftβ quot rightβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβΒΉ : Ordered env
hq : QuotReady env
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
xβ :
HasObjects env1β
[VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)]
leftβ : env1β.constants `Quot.mk = some (some quotMkConst)
quot : env1β.constants `Quot = some (some quotConst)
rightβ : HasObjects env1β [VObject.const `Eq (some eqConst)]
β’ HasType env1β quotIndConst.uvars [] quotIndConst.type (VExpr.sort (?m.2200 xβ leftβ quot rightβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | type_tac | env env' : VEnv
henvβΒ² : Ordered env
hq : QuotReady env
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
xβ :
HasObjects env1β
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)]
leftβΒΉ : env1β.constants `Quot.ind = some (some quotIndConst)
leftβ : env1β.constants `Quot.mk = some (some quotMkConst)
quot : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ HasType env1β quotLiftConst.uvars [] quotLiftConst.type (VExpr.sort (?m.5951 xβ leftβΒΉ leftβ quot eq rightβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henvβΒ² : Ordered env
hq : QuotReady env
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
xβ :
HasObjects env1β
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst), VObject.const `Eq (some eqConst)]
leftβΒΉ : env1β.constants `Quot.ind = some (some quotIndConst)
leftβ : env1β.constants `Quot.mk = some (some quotMkConst)
quot : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ HasType env1β quotLiftConst.uvars [] quotLiftConst.type (VExpr.sort (?m.5951 xβ leftβΒΉ leftβ quot eq rightβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | type_tac | env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ HasType env1β quotDefEq.uvars [] quotDefEq.lhs quotDefEq.type | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ HasType env1β quotDefEq.uvars [] quotDefEq.lhs quotDefEq.type
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_WF | [7, 1] | [14, 78] | type_tac | env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ HasType env1β quotDefEq.uvars [] quotDefEq.rhs quotDefEq.type | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henvβΒ³ : Ordered env
hq : QuotReady env
env1βΒ³ : VEnv
henvβΒ² : Ordered env1βΒ³
env1βΒ² : VEnv
henvβΒΉ : Ordered env1βΒ²
env1βΒΉ : VEnv
henvβ : Ordered env1βΒΉ
env1β : VEnv
henv : Ordered env1β
leftβΒ³ : env1β.constants `Quot.lift = some (some quotLiftConst)
leftβΒ² : env1β.constants `Quot.ind = some (some quotIndConst)
leftβΒΉ : env1β.constants `Quot.mk = some (some quotMkConst)
leftβ : env1β.constants `Quot = some (some quotConst)
eq : env1β.constants `Eq = some (some eqConst)
rightβ : HasObjects env1β []
β’ HasType env1β quotDefEq.uvars [] quotDefEq.rhs quotDefEq.type
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_objs | [19, 1] | [25, 45] | let β¨env, h, henvβ© := HasObjects.bind_const (ls := []) trivial henv | env env' : VEnv
henv : addQuot env = some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | envβ env' : VEnv
henvβ : addQuot envβ = some env'
env : VEnv
h : HasObjects env [VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henv : addQuot env = some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_objs | [19, 1] | [25, 45] | let β¨env, h, henvβ© := HasObjects.bind_const h henv | envβ env' : VEnv
henvβ : addQuot envβ = some env'
env : VEnv
h : HasObjects env [VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | envβΒΉ env' : VEnv
henvβΒΉ : addQuot envβΒΉ = some env'
envβ : VEnv
hβ : HasObjects envβ [VObject.const `Quot (some quotConst)]
henvβ :
(do
let env β addConst envβ `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
env : VEnv
h : HasObjects env [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | Please generate a tactic in lean4 to solve the state.
STATE:
envβ env' : VEnv
henvβ : addQuot envβ = some env'
env : VEnv
h : HasObjects env [VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_objs | [19, 1] | [25, 45] | let β¨env, h, henvβ© := HasObjects.bind_const h henv | envβΒΉ env' : VEnv
henvβΒΉ : addQuot envβΒΉ = some env'
envβ : VEnv
hβ : HasObjects envβ [VObject.const `Quot (some quotConst)]
henvβ :
(do
let env β addConst envβ `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
env : VEnv
h : HasObjects env [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | envβΒ² env' : VEnv
henvβΒ² : addQuot envβΒ² = some env'
envβΒΉ : VEnv
hβΒΉ : HasObjects envβΒΉ [VObject.const `Quot (some quotConst)]
henvβΒΉ :
(do
let env β addConst envβΒΉ `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
envβ : VEnv
hβ : HasObjects envβ [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henvβ :
(do
let env β addConst envβ `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
env : VEnv
h :
HasObjects env
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | Please generate a tactic in lean4 to solve the state.
STATE:
envβΒΉ env' : VEnv
henvβΒΉ : addQuot envβΒΉ = some env'
envβ : VEnv
hβ : HasObjects envβ [VObject.const `Quot (some quotConst)]
henvβ :
(do
let env β addConst envβ `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
env : VEnv
h : HasObjects env [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_objs | [19, 1] | [25, 45] | obtain β¨env, h, β¨β©β© := HasObjects.bind_const h henv | envβΒ² env' : VEnv
henvβΒ² : addQuot envβΒ² = some env'
envβΒΉ : VEnv
hβΒΉ : HasObjects envβΒΉ [VObject.const `Quot (some quotConst)]
henvβΒΉ :
(do
let env β addConst envβΒΉ `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
envβ : VEnv
hβ : HasObjects envβ [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henvβ :
(do
let env β addConst envβ `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
env : VEnv
h :
HasObjects env
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | case intro.intro.refl
envβΒ³ envβΒ² : VEnv
hβΒ² : HasObjects envβΒ² [VObject.const `Quot (some quotConst)]
envβΒΉ : VEnv
hβΒΉ : HasObjects envβΒΉ [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
envβ : VEnv
hβ :
HasObjects envβ
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
env : VEnv
h :
HasObjects env
[VObject.const `Quot.lift (some quotLiftConst), VObject.const `Quot.ind (some quotIndConst),
VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henvβΒ² : addQuot envβΒ³ = some (addDefEq env quotDefEq)
henvβΒΉ :
(do
let env β addConst envβΒ² `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
henvβ :
(do
let env β addConst envβΒΉ `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
henv :
(do
let env β addConst envβ `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
β’ HasObjects (addDefEq env quotDefEq)
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | Please generate a tactic in lean4 to solve the state.
STATE:
envβΒ² env' : VEnv
henvβΒ² : addQuot envβΒ² = some env'
envβΒΉ : VEnv
hβΒΉ : HasObjects envβΒΉ [VObject.const `Quot (some quotConst)]
henvβΒΉ :
(do
let env β addConst envβΒΉ `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
envβ : VEnv
hβ : HasObjects envβ [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henvβ :
(do
let env β addConst envβ `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
env : VEnv
h :
HasObjects env
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
henv :
(do
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some env'
β’ HasObjects env'
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/QuotLemmas.lean | Lean4Lean.VEnv.addQuot_objs | [19, 1] | [25, 45] | exact HasObjects.defeq (df := quotDefEq) h | case intro.intro.refl
envβΒ³ envβΒ² : VEnv
hβΒ² : HasObjects envβΒ² [VObject.const `Quot (some quotConst)]
envβΒΉ : VEnv
hβΒΉ : HasObjects envβΒΉ [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
envβ : VEnv
hβ :
HasObjects envβ
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
env : VEnv
h :
HasObjects env
[VObject.const `Quot.lift (some quotLiftConst), VObject.const `Quot.ind (some quotIndConst),
VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henvβΒ² : addQuot envβΒ³ = some (addDefEq env quotDefEq)
henvβΒΉ :
(do
let env β addConst envβΒ² `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
henvβ :
(do
let env β addConst envβΒΉ `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
henv :
(do
let env β addConst envβ `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
β’ HasObjects (addDefEq env quotDefEq)
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.refl
envβΒ³ envβΒ² : VEnv
hβΒ² : HasObjects envβΒ² [VObject.const `Quot (some quotConst)]
envβΒΉ : VEnv
hβΒΉ : HasObjects envβΒΉ [VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
envβ : VEnv
hβ :
HasObjects envβ
[VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
env : VEnv
h :
HasObjects env
[VObject.const `Quot.lift (some quotLiftConst), VObject.const `Quot.ind (some quotIndConst),
VObject.const `Quot.mk (some quotMkConst), VObject.const `Quot (some quotConst)]
henvβΒ² : addQuot envβΒ³ = some (addDefEq env quotDefEq)
henvβΒΉ :
(do
let env β addConst envβΒ² `Quot.mk (some quotMkConst)
let env β addConst env `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
henvβ :
(do
let env β addConst envβΒΉ `Quot.ind (some quotIndConst)
let env β addConst env `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
henv :
(do
let env β addConst envβ `Quot.lift (some quotLiftConst)
some (addDefEq env quotDefEq)) =
some (addDefEq env quotDefEq)
β’ HasObjects (addDefEq env quotDefEq)
[VObject.defeq quotDefEq, VObject.const `Quot.lift (some quotLiftConst),
VObject.const `Quot.ind (some quotIndConst), VObject.const `Quot.mk (some quotMkConst),
VObject.const `Quot (some quotConst)]
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.DefInv.symm | [17, 8] | [20, 78] | cases e1 <;> cases e2 <;> try trivial | env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
e1 e2 : VExpr
h : DefInv env U Ξ e1 e2
β’ DefInv env U Ξ e2 e1 | case sort.sort
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
uβΒΉ uβ : VLevel
h : DefInv env U Ξ (sort uβΒΉ) (sort uβ)
β’ DefInv env U Ξ (sort uβ) (sort uβΒΉ)
case forallE.forallE
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (forallE binderTypeβ bodyβ)
β’ DefInv env U Ξ (forallE binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
e1 e2 : VExpr
h : DefInv env U Ξ e1 e2
β’ DefInv env U Ξ e2 e1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.DefInv.symm | [17, 8] | [20, 78] | trivial | case forallE.lam
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (lam binderTypeβ bodyβ)
β’ DefInv env U Ξ (lam binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE.lam
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (lam binderTypeβ bodyβ)
β’ DefInv env U Ξ (lam binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.DefInv.symm | [17, 8] | [20, 78] | exact h.symm | case sort.sort
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
uβΒΉ uβ : VLevel
h : DefInv env U Ξ (sort uβΒΉ) (sort uβ)
β’ DefInv env U Ξ (sort uβ) (sort uβΒΉ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sort.sort
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
uβΒΉ uβ : VLevel
h : DefInv env U Ξ (sort uβΒΉ) (sort uβ)
β’ DefInv env U Ξ (sort uβ) (sort uβΒΉ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.DefInv.symm | [17, 8] | [20, 78] | let β¨u, v, h1, h2β© := h | case forallE.forallE
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (forallE binderTypeβ bodyβ)
β’ DefInv env U Ξ (forallE binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ) | case forallE.forallE
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (forallE binderTypeβ bodyβ)
u v : VLevel
h1 : IsDefEq env U Ξ binderTypeβΒΉ binderTypeβ (sort u)
h2 : IsDefEq env U (binderTypeβΒΉ :: Ξ) bodyβΒΉ bodyβ (sort v)
β’ DefInv env U Ξ (forallE binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE.forallE
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (forallE binderTypeβ bodyβ)
β’ DefInv env U Ξ (forallE binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.DefInv.symm | [17, 8] | [20, 78] | exact β¨u, v, h1.symm, h1.defeqDF_l henv h2.symmβ© | case forallE.forallE
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (forallE binderTypeβ bodyβ)
u v : VLevel
h1 : IsDefEq env U Ξ binderTypeβΒΉ binderTypeβ (sort u)
h2 : IsDefEq env U (binderTypeβΒΉ :: Ξ) bodyβΒΉ bodyβ (sort v)
β’ DefInv env U Ξ (forallE binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE.forallE
env : VEnv
henv : Ordered env
U : Nat
Ξ : List VExpr
binderTypeβΒΉ bodyβΒΉ binderTypeβ bodyβ : VExpr
h : DefInv env U Ξ (forallE binderTypeβΒΉ bodyβΒΉ) (forallE binderTypeβ bodyβ)
u v : VLevel
h1 : IsDefEq env U Ξ binderTypeβΒΉ binderTypeβ (sort u)
h2 : IsDefEq env U (binderTypeβΒΉ :: Ξ) bodyβΒΉ bodyβ (sort v)
β’ DefInv env U Ξ (forallE binderTypeβ bodyβ) (forallE binderTypeβΒΉ bodyβΒΉ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | have H' := H.strong henv hΞ | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
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
H : IsDefEq env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
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
H : IsDefEq env U Ξ e1 e2 A
H' : IsDefEqStrong env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
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
H : IsDefEq env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | clear hΞ H | env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
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
H : IsDefEq env U Ξ e1 e2 A
H' : IsDefEqStrong env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A | 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
H' : IsDefEqStrong env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Ξ : List VExpr
U : Nat
henv : Ordered env
hΞ : OnCtx Ξ (IsType env U)
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
H : IsDefEq env U Ξ e1 e2 A
H' : IsDefEqStrong env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | induction H' with
| bvar h => exact β¨.bvar h, .bvar h, .refl (hty (.bvar h))β©
| symm _ ih => exact β¨ih.2.1, ih.1, .symm ih.2.2β©
| trans _ _ ih1 ih2 => exact β¨ih1.1, ih2.2.1, .trans ih1.2.2 ih2.2.2β©
| @constDF _ _ lsβ lsβ u _ h1 h2 h3 h4 h5 =>
exact β¨.const h1 h2 h4,
.defeq (u := u.inst lsβ) sorry <| .const h1 h3 (h5.length_eq.symm.trans h4),
.constDF h1 h2 h3 h4 h5β©
| @sortDF l l' _ h1 h2 h3 =>
refine β¨.sort h1, ?_, .sortDF h1 h2 h3β©
exact .defeq (hdf <| .symm <| .sortDF (l' := l'.succ) h1 h2 (VLevel.succ_congr h3)) (.sort h2)
| appDF _ _ _ _ _ _ _ _ _ ihf iha ihBa =>
let β¨hf, hf', ffβ© := ihf; let β¨ha, ha', aaβ© := iha
exact β¨.app hf ha, .defeq (hdf ihBa.2.2.symm) (.app hf' ha'), .appDF ff aaβ©
| lamDF _ _ _ _ _ _ _ ihA ihB _ ihb ihb' =>
refine β¨.lam ihA.1 ihb.1, ?_, .lamDF ihA.2.2 ihb.2.2β©
exact .defeq (hdf <| .symm <| .forallEDF ihA.2.2 ihB.2.2) <| .lam ihA.2.1 ihb'.2.1
| forallEDF _ _ _ _ _ ih1 ih2 ih3 =>
exact β¨.forallE ih1.1 ih2.1, .forallE ih1.2.1 ih3.2.1, .forallEDF ih1.2.2 ih2.2.2β©
| defeqDF _ _ _ ih1 ih2 =>
exact β¨.defeq (hdf ih1.2.2) ih2.1, .defeq (hdf ih1.2.2) ih2.2.1, .defeqDF (hdf ih1.2.2) ih2.2.2β©
| beta _ _ _ _ _ _ _ _ ihA _ ihe ihe' _ ihee =>
exact β¨.app (.lam ihA.1 ihe.1) ihe'.1, ihee.1, .beta (hty ihe.1) (hty ihe'.1)β©
| eta _ _ _ _ _ _ _ ihA _ _ ihe ihe' =>
have := HasType1.app ihe'.1 (.bvar .zero)
rw [instN_bvar0] at this
exact β¨.lam ihA.1 this, ihe.1, .eta (hty ihe.1)β©
| proofIrrel _ _ _ ih1 ih2 ih3 =>
exact β¨ih2.1, ih3.1, .proofIrrel (hty ih1.1) (hty ih2.1) (hty ih3.1)β©
| extra h1 h2 h3 _ _ _ _ _ _ _ _ _ ihl' ihr' =>
exact β¨ihl'.1, ihr'.1, .extra h1 h2 h3β© | 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
H' : IsDefEqStrong env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
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
H' : IsDefEqStrong env U Ξ e1 e2 A
β’ HasType1 env U defEq Ξ e1 A β§ HasType1 env U defEq Ξ e2 A β§ IsDefEq1 env U hasType defEq Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact β¨.bvar h, .bvar h, .refl (hty (.bvar h))β© | case bvar
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
iβ : Nat
Aβ : VExpr
uβ : VLevel
h : Lookup Ξβ iβ Aβ
aβΒΉ : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
a_ihβ :
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β)
β’ HasType1 env U defEq Ξβ (VExpr.bvar iβ) Aβ β§
HasType1 env U defEq Ξβ (VExpr.bvar iβ) Aβ β§ IsDefEq1 env U hasType defEq Ξβ (VExpr.bvar iβ) (VExpr.bvar iβ) Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
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
iβ : Nat
Aβ : VExpr
uβ : VLevel
h : Lookup Ξβ iβ Aβ
aβΒΉ : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (VExpr.sort uβ)
a_ihβ :
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β)
β’ HasType1 env U defEq Ξβ (VExpr.bvar iβ) Aβ β§
HasType1 env U defEq Ξβ (VExpr.bvar iβ) Aβ β§ IsDefEq1 env U hasType defEq Ξβ (VExpr.bvar iβ) (VExpr.bvar iβ) Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact β¨ih.2.1, ih.1, .symm ih.2.2β© | case symm
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
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : HasType1 env U defEq Ξβ eβ Aβ β§ HasType1 env U defEq Ξβ e'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ eβ e'β Aβ
β’ HasType1 env U defEq Ξβ e'β Aβ β§ HasType1 env U defEq Ξβ eβ Aβ β§ IsDefEq1 env U hasType defEq Ξβ e'β eβ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
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
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : HasType1 env U defEq Ξβ eβ Aβ β§ HasType1 env U defEq Ξβ e'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ eβ e'β Aβ
β’ HasType1 env U defEq Ξβ e'β Aβ β§ HasType1 env U defEq Ξβ eβ Aβ β§ IsDefEq1 env U hasType defEq Ξβ e'β eβ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact β¨ih1.1, ih2.2.1, .trans ih1.2.2 ih2.2.2β© | case trans
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
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : HasType1 env U defEq Ξβ eββ Aβ β§ HasType1 env U defEq Ξβ eββ Aβ β§ IsDefEq1 env U hasType defEq Ξβ eββ eββ Aβ
ih2 : HasType1 env U defEq Ξβ eββ Aβ β§ HasType1 env U defEq Ξβ eββ Aβ β§ IsDefEq1 env U hasType defEq Ξβ eββ eββ Aβ
β’ HasType1 env U defEq Ξβ eββ Aβ β§ HasType1 env U defEq Ξβ eββ Aβ β§ IsDefEq1 env U hasType defEq Ξβ eββ eββ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
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
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : HasType1 env U defEq Ξβ eββ Aβ β§ HasType1 env U defEq Ξβ eββ Aβ β§ IsDefEq1 env U hasType defEq Ξβ eββ eββ Aβ
ih2 : HasType1 env U defEq Ξβ eββ Aβ β§ HasType1 env U defEq Ξβ eββ Aβ β§ IsDefEq1 env U hasType defEq Ξβ eββ eββ Aβ
β’ HasType1 env U defEq Ξβ eββ Aβ β§ HasType1 env U defEq Ξβ eββ Aβ β§ IsDefEq1 env U hasType defEq Ξβ eββ eββ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact β¨.const h1 h2 h4,
.defeq (u := u.inst lsβ) sorry <| .const h1 h3 (h5.length_eq.symm.trans h4),
.constDF h1 h2 h3 h4 h5β© | case constDF
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
cβ : Name
ciβ : VConstant
lsβ lsβ : List VLevel
u : 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β
aββ΄ : VLevel.WF U u
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβΒ³ :
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβΒ² :
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβΒΉ :
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβ :
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
β’ HasType1 env U defEq Ξβ (VExpr.const cβ lsβ) (VExpr.instL lsβ ciβ.type) β§
HasType1 env U defEq Ξβ (VExpr.const cβ lsβ) (VExpr.instL lsβ ciβ.type) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.const cβ lsβ) (VExpr.const cβ lsβ) (VExpr.instL lsβ ciβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
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
cβ : Name
ciβ : VConstant
lsβ lsβ : List VLevel
u : 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β
aββ΄ : VLevel.WF U u
aβΒ³ : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβΒ³ :
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβΒ² :
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq [] (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβΒΉ :
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
a_ihβ :
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
HasType1 env U defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.sort u) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (VExpr.sort u)
β’ HasType1 env U defEq Ξβ (VExpr.const cβ lsβ) (VExpr.instL lsβ ciβ.type) β§
HasType1 env U defEq Ξβ (VExpr.const cβ lsβ) (VExpr.instL lsβ ciβ.type) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.const cβ lsβ) (VExpr.const cβ lsβ) (VExpr.instL lsβ ciβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | refine β¨.sort h1, ?_, .sortDF h1 h2 h3β© | case sortDF
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
l l' : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l β l'
β’ HasType1 env U defEq Ξβ (VExpr.sort l) (VExpr.sort (VLevel.succ l)) β§
HasType1 env U defEq Ξβ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.sort l) (VExpr.sort l') (VExpr.sort (VLevel.succ l)) | case sortDF
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
l l' : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l β l'
β’ HasType1 env U defEq Ξβ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
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
l l' : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l β l'
β’ HasType1 env U defEq Ξβ (VExpr.sort l) (VExpr.sort (VLevel.succ l)) β§
HasType1 env U defEq Ξβ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) β§
IsDefEq1 env U hasType defEq Ξβ (VExpr.sort l) (VExpr.sort l') (VExpr.sort (VLevel.succ l))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact .defeq (hdf <| .symm <| .sortDF (l' := l'.succ) h1 h2 (VLevel.succ_congr h3)) (.sort h2) | case sortDF
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
l l' : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l β l'
β’ HasType1 env U defEq Ξβ (VExpr.sort l') (VExpr.sort (VLevel.succ l)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
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
l l' : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U l
h2 : VLevel.WF U l'
h3 : l β l'
β’ HasType1 env U defEq Ξβ (VExpr.sort l') (VExpr.sort (VLevel.succ l))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | let β¨hf, hf', ffβ© := ihf | case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·) | case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
hf : HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ)
hf' : HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ)
ff : IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | let β¨ha, ha', aaβ© := iha | case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
hf : HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ)
hf' : HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ)
ff : IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·) | case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
hf : HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ)
hf' : HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ)
ff : IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
ha : HasType1 env U defEq Ξβ aββ· Aβ
ha' : HasType1 env U defEq Ξβ a'β Aβ
aa : IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
hf : HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ)
hf' : HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ)
ff : IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | exact β¨.app hf ha, .defeq (hdf ihBa.2.2.symm) (.app hf' ha'), .appDF ff aaβ© | case appDF
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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
hf : HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ)
hf' : HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ)
ff : IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
ha : HasType1 env U defEq Ξβ aββ· Aβ
ha' : HasType1 env U defEq Ξβ a'β Aβ
aa : IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (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
Ξ : 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
fβ f'β aββ· a'β : 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 Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
a_ihβΒΉ :
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β)
ihf :
HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ) β§
HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ) β§ IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
iha : HasType1 env U defEq Ξβ aββ· Aβ β§ HasType1 env U defEq Ξβ a'β Aβ β§ IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
ihBa :
HasType1 env U defEq Ξβ (inst Bβ aββ·) (VExpr.sort vβ) β§
HasType1 env U defEq Ξβ (inst Bβ a'β) (VExpr.sort vβ) β§
IsDefEq1 env U hasType defEq Ξβ (inst Bβ aββ·) (inst Bβ a'β) (VExpr.sort vβ)
hf : HasType1 env U defEq Ξβ fβ (VExpr.forallE Aβ Bβ)
hf' : HasType1 env U defEq Ξβ f'β (VExpr.forallE Aβ Bβ)
ff : IsDefEq1 env U hasType defEq Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
ha : HasType1 env U defEq Ξβ aββ· Aβ
ha' : HasType1 env U defEq Ξβ a'β Aβ
aa : IsDefEq1 env U hasType defEq Ξβ aββ· a'β Aβ
β’ HasType1 env U defEq Ξβ (app fβ aββ·) (inst Bβ aββ·) β§
HasType1 env U defEq Ξβ (app f'β a'β) (inst Bβ aββ·) β§
IsDefEq1 env U hasType defEq Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Stratified.lean | Lean4Lean.VEnv.IsDefEq.induction1 | [75, 1] | [115, 44] | refine β¨.lam ihA.1 ihb.1, ?_, .lamDF ihA.2.2 ihb.2.2β© | 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β) β§
HasType1 env U defEq Ξβ (lam A'β body'β) (VExpr.forallE Aβ Bβ) β§
IsDefEq1 env U hasType defEq Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ) | 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β) | 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β) β§
HasType1 env U defEq Ξβ (lam A'β body'β) (VExpr.forallE Aβ Bβ) β§
IsDefEq1 env U hasType defEq Ξβ (lam Aβ bodyβ) (lam A'β body'β) (VExpr.forallE Aβ Bβ)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.