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/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ((ih1 hΞ).forallE_inv henv).2.instN henv .zero h2.hasType.1 | case appDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
fβ f'β Aβ Bβ aβΒΉ a'β : VExpr
aβ : IsDefEq env U Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
h2 : IsDefEq env U Ξβ aβΒΉ a'β Aβ
ih1 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.forallE Aβ Bβ)
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (inst Bβ aβΒΉ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
fβ f'β Aβ Bβ aβΒΉ a'β : VExpr
aβ : IsDefEq env U Ξβ fβ f'β (VExpr.forallE Aβ Bβ)
h2 : IsDefEq env U Ξβ aβΒΉ a'β Aβ
ih1 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.forallE Aβ Bβ)
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (inst Bβ aβΒΉ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | let β¨_, hβ© := ih2 β¨hΞ, _, h1.hasType.1β© | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (VExpr.forallE Aβ Bβ) | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
hΞ : OnCtx Ξβ (IsType env U)
wβ : VLevel
h : HasType env U (Aβ :: Ξβ) Bβ (VExpr.sort wβ)
β’ IsType env U Ξβ (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 fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact β¨_, .forallE h1.hasType.1 hβ© | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
hΞ : OnCtx Ξβ (IsType env U)
wβ : VLevel
h : HasType env U (Aβ :: Ξβ) Bβ (VExpr.sort wβ)
β’ IsType env U Ξβ (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 fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β Bβ : VExpr
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
hΞ : OnCtx Ξβ (IsType env U)
wβ : VLevel
h : HasType env U (Aβ :: Ξβ) Bβ (VExpr.sort wβ)
β’ IsType env U Ξβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact β¨_, .sort β¨(ih1 hΞ).sort_inv henv, (ih2 β¨hΞ, _, h1.hasType.1β©).sort_inv henvβ©β© | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) (VExpr.sort vβ)
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (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 fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
h1 : IsDefEq env U Ξβ Aβ A'β (VExpr.sort uβ)
aβ : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (VExpr.sort vβ)
ih1 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
ih2 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) (VExpr.sort vβ)
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (VExpr.sort (VLevel.imax uβ vβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact β¨_, h1.hasType.2β© | case defeqDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
h1 : IsDefEq env U Ξβ Aβ Bβ (VExpr.sort uβ)
aβ : IsDefEq env U Ξβ e1β e2β Aβ
a_ihβΒΉ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ Bβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
h1 : IsDefEq env U Ξβ Aβ Bβ (VExpr.sort uβ)
aβ : IsDefEq env U Ξβ e1β e2β Aβ
a_ihβΒΉ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.sort uβ)
a_ihβ : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ Bβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | have β¨_, hβ© := ih2 hΞ | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
h2 : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
ih2 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (inst Bβ e'β) | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
h2 : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
ih2 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
wβ : VLevel
h : HasType env U Ξβ Aβ (VExpr.sort wβ)
β’ IsType env U Ξβ (inst Bβ e'β) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
h2 : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
ih2 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact (ih1 β¨hΞ, _, h.hasType.2β©).instN henv .zero h2 | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
h2 : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
ih2 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
wβ : VLevel
h : HasType env U Ξβ Aβ (VExpr.sort wβ)
β’ IsType env U Ξβ (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 fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A Aβ : VExpr
Ξβ : List VExpr
eβ Bβ e'β : VExpr
aβ : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
h2 : IsDefEq env U Ξβ e'β e'β Aβ
ih1 : OnCtx (Aβ :: Ξβ) (IsType env U) β IsType env U (Aβ :: Ξβ) Bβ
ih2 : OnCtx Ξβ (IsType env U) β IsType env U Ξβ Aβ
hΞ : OnCtx Ξβ (IsType env U)
wβ : VLevel
h : HasType env U Ξβ Aβ (VExpr.sort wβ)
β’ IsType env U Ξβ (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ih hΞ | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.forallE Aβ Bβ)
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (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 fun U e A => HasType env U [] e A β§ IsType env U [] A
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
eβ Aβ Bβ : VExpr
aβ : IsDefEq env U Ξβ eβ eβ (VExpr.forallE Aβ Bβ)
ih : OnCtx Ξβ (IsType env U) β IsType env U Ξβ (VExpr.forallE Aβ Bβ)
hΞ : OnCtx Ξβ (IsType env U)
β’ IsType env U Ξβ (VExpr.forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | refine .bvar (h1.weakN W) h2 (h3.weakN W) | case bvar
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h1 : Lookup Ξβ iβ Aβ
h2 : VLevel.WF U uβ
h3 : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (VExpr.bvar iβ) k) (liftN n (VExpr.bvar iβ) k) (liftN n Aβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h1 : Lookup Ξβ iβ Aβ
h2 : VLevel.WF U uβ
h3 : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (VExpr.bvar iβ) k) (liftN n (VExpr.bvar iβ) k) (liftN n Aβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .symm (ih W) | case symm
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n eβ k) (liftN n e'β k) (liftN n Aβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n e'β k) (liftN n eβ k) (liftN n Aβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n eβ k) (liftN n e'β k) (liftN n Aβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n e'β k) (liftN n eβ k) (liftN n Aβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .trans (ih1 W) (ih2 W) | case trans
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n eββ k) (liftN n eββ k) (liftN n Aβ k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n eββ k) (liftN n eββ k) (liftN n Aβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n eββ k) (liftN n eββ k) (liftN n Aβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n eββ k) (liftN n eββ k) (liftN n Aβ k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n eββ k) (liftN n eββ k) (liftN n Aβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n eββ k) (liftN n eββ k) (liftN n Aβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .sortDF h1 h2 h3 | case sortDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U lβ
h2 : VLevel.WF U l'β
h3 : lβ β l'β
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (sort lβ) k) (liftN n (sort l'β) k) (liftN n (sort (VLevel.succ lβ)) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U lβ
h2 : VLevel.WF U l'β
h3 : lβ β l'β
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (sort lβ) k) (liftN n (sort l'β) k) (liftN n (sort (VLevel.succ lβ)) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | simp [(henv.closedC h1).instL.liftN_eq (Nat.zero_le _)] at ih3 ih4 β’ | case constDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
h7 : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
h8 : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (const cβ lsβ) k) (liftN n (const cβ ls'β) k) (liftN n (instL lsβ ciβ.type) k) | case constDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
h7 : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
h8 : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ ciβ.type) (instL lsβ ciβ.type) (liftN n (sort uβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL ls'β ciβ.type) (instL ls'β ciβ.type) (liftN n (sort uβ) k)
β’ IsDefEqStrong env U Ξ' (liftN n (const cβ lsβ) k) (liftN n (const cβ ls'β) k) (instL lsβ ciβ.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
h7 : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
h8 : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (const cβ lsβ) k) (liftN n (const cβ ls'β) k) (liftN n (instL lsβ ciβ.type) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .constDF h1 h2 h3 h4 h5 h6 h7 h8 (ih3 W) (ih4 W) | case constDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
h7 : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
h8 : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ ciβ.type) (instL lsβ ciβ.type) (liftN n (sort uβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL ls'β ciβ.type) (instL ls'β ciβ.type) (liftN n (sort uβ) k)
β’ IsDefEqStrong env U Ξ' (liftN n (const cβ lsβ) k) (liftN n (const cβ ls'β) k) (instL lsβ ciβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
h7 : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
h8 : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ ciβ.type) k) (liftN n (instL lsβ ciβ.type) k) (liftN n (sort uβ) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL ls'β ciβ.type) k) (liftN n (instL ls'β ciβ.type) k) (liftN n (sort uβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ ciβ.type) (instL lsβ ciβ.type) (liftN n (sort uβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL ls'β ciβ.type) (instL ls'β ciβ.type) (liftN n (sort uβ) k)
β’ IsDefEqStrong env U Ξ' (liftN n (const cβ lsβ) k) (liftN n (const cβ ls'β) k) (instL lsβ ciβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | refine liftN_inst_hi .. βΈ .appDF h1 h2 (ih1 W) (ih2 W.succ) (ih3 W) (ih4 W) ?_ | case appDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n fβ k) (liftN n f'β k) (liftN n (forallE Aβ Bβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n aββ΅ k) (liftN n a'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ aββ΅) k) (liftN n (inst Bβ a'β) k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (app fβ aββ΅) k) (liftN n (app f'β a'β) k) (liftN n (inst Bβ aββ΅) k) | case appDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n fβ k) (liftN n f'β k) (liftN n (forallE Aβ Bβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n aββ΅ k) (liftN n a'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ aββ΅) k) (liftN n (inst Bβ a'β) k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (inst (liftN n Bβ (k + 1)) (liftN n aββ΅ k)) (inst (liftN n Bβ (k + 1)) (liftN n a'β k))
(sort vβ) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n fβ k) (liftN n f'β k) (liftN n (forallE Aβ Bβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n aββ΅ k) (liftN n a'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ aββ΅) k) (liftN n (inst Bβ a'β) k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (app fβ aββ΅) k) (liftN n (app f'β a'β) k) (liftN n (inst Bβ aββ΅) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact liftN_inst_hi .. βΈ liftN_inst_hi .. βΈ ih5 W | case appDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n fβ k) (liftN n f'β k) (liftN n (forallE Aβ Bβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n aββ΅ k) (liftN n a'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ aββ΅) k) (liftN n (inst Bβ a'β) k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (inst (liftN n Bβ (k + 1)) (liftN n aββ΅ k)) (inst (liftN n Bβ (k + 1)) (liftN n a'β k))
(sort vβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n fβ k) (liftN n f'β k) (liftN n (forallE Aβ Bβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n aββ΅ k) (liftN n a'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ aββ΅) k) (liftN n (inst Bβ a'β) k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (inst (liftN n Bβ (k + 1)) (liftN n aββ΅ k)) (inst (liftN n Bβ (k + 1)) (liftN n a'β k))
(sort vβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .lamDF h1 h2 (ih1 W) (ih2 W.succ) (ih3 W.succ) (ih4 W.succ) (ih5 W.succ) | case lamDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ body'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n A'β k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (A'β :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n Bβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (A'β :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n Bβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (lam Aβ bodyβ) k) (liftN n (lam A'β body'β) k) (liftN n (forallE Aβ Bβ) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ body'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n A'β k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (A'β :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n Bβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (A'β :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n Bβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (lam Aβ bodyβ) k) (liftN n (lam A'β body'β) k) (liftN n (forallE Aβ Bβ) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .forallEDF h1 h2 (ih1 W) (ih2 W.succ) (ih3 W.succ) | case forallEDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aβΒ² : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n A'β k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (A'β :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (forallE Aβ bodyβ) k) (liftN n (forallE A'β body'β) k)
(liftN n (sort (VLevel.imax uβ vβ)) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aβΒ² : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n A'β k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (A'β :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n bodyβ k) (liftN n body'β k) (liftN n (sort vβ) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (forallE Aβ bodyβ) k) (liftN n (forallE A'β body'β) k)
(liftN n (sort (VLevel.imax uβ vβ)) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .defeqDF h1 (ih1 W) (ih2 W) | case defeqDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
h1 : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Bβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n e1β k) (liftN n e2β k) (liftN n Aβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n e1β k) (liftN n e2β k) (liftN n Bβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
h1 : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Bβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n e1β k) (liftN n e2β k) (liftN n Aβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n e1β k) (liftN n e2β k) (liftN n Bβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | refine liftN_inst_hi .. βΈ liftN_instN_hi .. βΈ .beta h1 h2
(ih1 W) (ih2 W.succ) (ih3 W.succ) (ih4 W)
(liftN_instN_hi .. βΈ ih5 W :)
(liftN_instN_hi .. βΈ liftN_instN_hi .. βΈ ih6 W :) | case beta
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n eβ k) (liftN n eβ k) (liftN n Bβ k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n e'β k) (liftN n e'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ e'β) k) (liftN n (inst Bβ e'β) k) (liftN n (sort vβ) k)
ih6 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst eβ e'β) k) (liftN n (inst eβ e'β) k) (liftN n (inst Bβ e'β) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (app (lam Aβ eβ) e'β) k) (liftN n (inst eβ e'β) k) (liftN n (inst Bβ e'β) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n Aβ k) (liftN n Aβ k) (liftN n (sort uβ) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n Bβ k) (liftN n Bβ k) (liftN n (sort vβ) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (Aβ :: Ξβ) Ξ' β IsDefEqStrong env U Ξ' (liftN n eβ k) (liftN n eβ k) (liftN n Bβ k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n e'β k) (liftN n e'β k) (liftN n Aβ k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst Bβ e'β) k) (liftN n (inst Bβ e'β) k) (liftN n (sort vβ) k)
ih6 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (inst eβ e'β) k) (liftN n (inst eβ e'β) k) (liftN n (inst Bβ e'β) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (app (lam Aβ eβ) e'β) k) (liftN n (inst eβ e'β) k) (liftN n (inst Bβ e'β) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | have := IsDefEqStrong.eta h1 h2 (ih1 W) (ih2 W.succ) ?_ (ih4 W) ?_ | case eta
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (lam a (app (lift e) (VExpr.bvar 0))) k) (liftN n e k) (liftN n (forallE a B) k) | case eta.refine_3
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
this :
IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (lift (liftN n e k)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
β’ IsDefEqStrong env U Ξ' (liftN n (lam a (app (lift e) (VExpr.bvar 0))) k) (liftN n e k) (liftN n (forallE a B) k)
case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v)
case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U (liftN n a k :: Ξ') (lift (liftN n e k)) (lift (liftN n e k))
(forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (lam a (app (lift e) (VExpr.bvar 0))) k) (liftN n e k) (liftN n (forallE a B) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | simp [liftN] | case eta.refine_3
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
this :
IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (lift (liftN n e k)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
β’ IsDefEqStrong env U Ξ' (liftN n (lam a (app (lift e) (VExpr.bvar 0))) k) (liftN n e k) (liftN n (forallE a B) k) | case eta.refine_3
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
this :
IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (lift (liftN n e k)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
β’ IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (liftN n (lift e) (k + 1)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_3
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
this :
IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (lift (liftN n e k)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
β’ IsDefEqStrong env U Ξ' (liftN n (lam a (app (lift e) (VExpr.bvar 0))) k) (liftN n e k) (liftN n (forallE a B) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | rwa [β lift_liftN'] | case eta.refine_3
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
this :
IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (lift (liftN n e k)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
β’ IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (liftN n (lift e) (k + 1)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_3
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
this :
IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (lift (liftN n e k)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
β’ IsDefEqStrong env U Ξ' (lam (liftN n a k) (app (liftN n (lift e) (k + 1)) (VExpr.bvar 0))) (liftN n e k)
(forallE (liftN n a k) (liftN n B (k + 1)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | specialize ih3 W.succ.succ | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | have := liftN'_comm B n 1 (k+1) 1 (Nat.le_add_left ..) | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
this : liftN 1 (liftN n B (k + 1)) 1 = liftN n (liftN 1 B 1) (1 + (k + 1))
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | rw [Nat.add_comm 1] at this | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
this : liftN 1 (liftN n B (k + 1)) 1 = liftN n (liftN 1 B 1) (1 + (k + 1))
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
this : liftN 1 (liftN n B (k + 1)) 1 = liftN n (liftN 1 B 1) (k + 1 + 1)
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
this : liftN 1 (liftN n B (k + 1)) 1 = liftN n (liftN 1 B 1) (1 + (k + 1))
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | rwa [β this, β lift_liftN'] at ih3 | case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
this : liftN 1 (liftN n B (k + 1)) 1 = liftN n (liftN 1 B 1) (k + 1 + 1)
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_1
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih3 :
IsDefEqStrong env U (liftN n (lift a) (k + 1) :: liftN n a k :: Ξ') (liftN n (liftN 1 B 1) (k + 1 + 1))
(liftN n (liftN 1 B 1) (k + 1 + 1)) (liftN n (sort v) (k + 1 + 1))
this : liftN 1 (liftN n B (k + 1)) 1 = liftN n (liftN 1 B 1) (k + 1 + 1)
β’ IsDefEqStrong env U (lift (liftN n a k) :: liftN n a k :: Ξ') (liftN 1 (liftN n B (k + 1)) 1)
(liftN 1 (liftN n B (k + 1)) 1) (sort v)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | have ih5 : IsDefEqStrong _ _ _ _ _ (liftN n (lift (forallE ..)) _) := ih5 W.succ | case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U (liftN n a k :: Ξ') (lift (liftN n e k)) (lift (liftN n e k))
(forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1)) | case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5β :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih5 :
IsDefEqStrong env U (liftN n a k :: Ξ') (liftN n (lift e) (k + 1)) (liftN n (lift e) (k + 1))
(liftN n (lift (forallE a B)) (k + 1))
β’ IsDefEqStrong env U (liftN n a k :: Ξ') (lift (liftN n e k)) (lift (liftN n e k))
(forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
β’ IsDefEqStrong env U (liftN n a k :: Ξ') (lift (liftN n e k)) (lift (liftN n e k))
(forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | rwa [β lift_liftN', β lift_liftN'] at ih5 | case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5β :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih5 :
IsDefEqStrong env U (liftN n a k :: Ξ') (liftN n (lift e) (k + 1)) (liftN n (lift e) (k + 1))
(liftN n (lift (forallE a B)) (k + 1))
β’ IsDefEqStrong env U (liftN n a k :: Ξ') (lift (liftN n e k)) (lift (liftN n e k))
(forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Ξβ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
aββ΄ : IsDefEqStrong env U Ξ a a (sort u)
aβΒ³ : IsDefEqStrong env U (a :: Ξ) B B (sort v)
aβΒ² : IsDefEqStrong env U (lift a :: a :: Ξ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
aβΒΉ : IsDefEqStrong env U Ξ e e (forallE a B)
aβ : IsDefEqStrong env U (a :: Ξ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β IsDefEqStrong env U Ξ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (lift a :: a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξ Ξ' β IsDefEqStrong env U Ξ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5β :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k (a :: Ξ) Ξ' β
IsDefEqStrong env U Ξ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξ Ξ'
ih5 :
IsDefEqStrong env U (liftN n a k :: Ξ') (liftN n (lift e) (k + 1)) (liftN n (lift e) (k + 1))
(liftN n (lift (forallE a B)) (k + 1))
β’ IsDefEqStrong env U (liftN n a k :: Ξ') (lift (liftN n e k)) (lift (liftN n e k))
(forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact .proofIrrel (ih1 W) (ih2 W) (ih3 W) | case proofIrrel
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n pβ k) (liftN n pβ k) (liftN n (sort VLevel.zero) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n hβ k) (liftN n hβ k) (liftN n pβ k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n h'β k) (liftN n h'β k) (liftN n pβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n hβ k) (liftN n h'β k) (liftN n pβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n pβ k) (liftN n pβ k) (liftN n (sort VLevel.zero) k)
ih2 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n hβ k) (liftN n hβ k) (liftN n pβ k)
ih3 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (liftN n h'β k) (liftN n h'β k) (liftN n pβ k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n hβ k) (liftN n h'β k) (liftN n pβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | have β¨β¨hA1, _β©, hA2, hA3β© := henv.closed.2 h1 | case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k) | case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
hA1 : ClosedN dfβ.lhs
rightβ : ClosedN dfβ.type
hA2 : ClosedN dfβ.rhs
hA3 : ClosedN dfβ.type
β’ IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
β’ IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | simp [
hA1.instL.liftN_eq (Nat.zero_le _),
hA2.instL.liftN_eq (Nat.zero_le _),
hA3.instL.liftN_eq (Nat.zero_le _)] at ih4 ih5 β’ | case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
hA1 : ClosedN dfβ.lhs
rightβ : ClosedN dfβ.type
hA2 : ClosedN dfβ.rhs
hA3 : ClosedN dfβ.type
β’ IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k) | case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
hA1 : ClosedN dfβ.lhs
rightβ : ClosedN dfβ.type
hA2 : ClosedN dfβ.rhs
hA3 : ClosedN dfβ.type
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEqStrong env U Ξ' (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
hA1 : ClosedN dfβ.lhs
rightβ : ClosedN dfβ.type
hA2 : ClosedN dfβ.rhs
hA3 : ClosedN dfβ.type
β’ IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weakN | [92, 1] | [129, 67] | exact IsDefEqStrong.extra h1 h2 h3 h4 h5 h6 h7 (ih4 W) (ih5 W) | case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
hA1 : ClosedN dfβ.lhs
rightβ : ClosedN dfβ.type
hA2 : ClosedN dfβ.rhs
hA3 : ClosedN dfβ.type
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEqStrong env U Ξ' (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
n : Nat
Ξ : List VExpr
U : Nat
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
h5 : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
h6 : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
h7 : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒ² :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.type) k) (liftN n (instL lsβ dfβ.type) k) (liftN n (sort uβ) k)
a_ihβΒΉ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.lhs) k) (liftN n (instL lsβ dfβ.lhs) k)
(liftN n (instL lsβ dfβ.type) k)
a_ihβ :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k [] Ξ' β
IsDefEqStrong env U Ξ' (liftN n (instL lsβ dfβ.rhs) k) (liftN n (instL lsβ dfβ.rhs) k)
(liftN n (instL lsβ dfβ.type) k)
k : Nat
Ξ' : List VExpr
W : Ctx.LiftN n k Ξβ Ξ'
hA1 : ClosedN dfβ.lhs
rightβ : ClosedN dfβ.type
hA2 : ClosedN dfβ.rhs
hA3 : ClosedN dfβ.type
ih4 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih5 :
β {k : Nat} {Ξ' : List VExpr},
Ctx.LiftN n k Ξβ Ξ' β IsDefEqStrong env U Ξ' (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEqStrong env U Ξ' (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | induction H with
| bvar h => exact .bvar h
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 => exact .constDF h1 h2 h3 h4 h5
| appDF _ _ _ _ _ _ _ _ _ ih1 ih2 => exact .appDF ih1 ih2
| lamDF _ _ _ _ _ _ _ ih1 _ _ ih2 => exact .lamDF ih1 ih2
| forallEDF _ _ _ _ _ ih1 ih2 => exact .forallEDF ih1 ih2
| defeqDF _ _ _ ih1 ih2 => exact .defeqDF ih1 ih2
| beta _ _ _ _ _ _ _ _ _ _ ih1 ih2 => exact .beta ih1 ih2
| eta _ _ _ _ _ _ _ _ _ _ ih => exact .eta ih
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 => exact .extra h1 h2 h3 | env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Ξ e1 e2 A
β’ IsDefEq env U Ξ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Ξ e1 e2 A
β’ IsDefEq env U Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .bvar h | case bvar
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h : Lookup Ξβ iβ Aβ
aβΒΉ : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
a_ihβ : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
β’ IsDefEq env U Ξβ (VExpr.bvar iβ) (VExpr.bvar iβ) Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h : Lookup Ξβ iβ Aβ
aβΒΉ : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
a_ihβ : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
β’ IsDefEq env U Ξβ (VExpr.bvar iβ) (VExpr.bvar iβ) Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .symm ih | case symm
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : IsDefEq env U Ξβ eβ e'β Aβ
β’ IsDefEq env U Ξβ e'β eβ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : IsDefEq env U Ξβ eβ e'β Aβ
β’ IsDefEq env U Ξβ e'β eβ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .trans ih1 ih2 | case trans
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : IsDefEq env U Ξβ eββ eββ Aβ
ih2 : IsDefEq env U Ξβ eββ eββ Aβ
β’ IsDefEq env U Ξβ eββ eββ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : IsDefEq env U Ξβ eββ eββ Aβ
ih2 : IsDefEq env U Ξβ eββ eββ Aβ
β’ IsDefEq env U Ξβ eββ eββ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .sortDF h1 h2 h3 | case sortDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U lβ
h2 : VLevel.WF U l'β
h3 : lβ β l'β
β’ IsDefEq env U Ξβ (sort lβ) (sort l'β) (sort (VLevel.succ lβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U lβ
h2 : VLevel.WF U l'β
h3 : lβ β l'β
β’ IsDefEq env U Ξβ (sort lβ) (sort l'β) (sort (VLevel.succ lβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .constDF h1 h2 h3 h4 h5 | case constDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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 [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒ³ : IsDefEq env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
a_ihβΒ² : IsDefEq env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ : IsDefEq env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
a_ihβ : IsDefEq env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
β’ IsDefEq env U Ξβ (const cβ lsβ) (const cβ ls'β) (instL lsβ ciβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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 [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒ³ : IsDefEq env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
a_ihβΒ² : IsDefEq env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
a_ihβΒΉ : IsDefEq env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
a_ihβ : IsDefEq env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
β’ IsDefEq env U Ξβ (const cβ lsβ) (const cβ ls'β) (instL lsβ ciβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .appDF ih1 ih2 | case appDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (sort vβ)
a_ihβΒ² : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
a_ihβΒΉ : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih1 : IsDefEq env U Ξβ fβ f'β (forallE Aβ Bβ)
ih2 : IsDefEq env U Ξβ aββ· a'β Aβ
a_ihβ : IsDefEq env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (sort vβ)
β’ IsDefEq env U Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (sort vβ)
a_ihβΒ² : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
a_ihβΒΉ : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih1 : IsDefEq env U Ξβ fβ f'β (forallE Aβ Bβ)
ih2 : IsDefEq env U Ξβ aββ· a'β Aβ
a_ihβ : IsDefEq env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (sort vβ)
β’ IsDefEq env U Ξβ (app fβ aββ·) (app f'β a'β) (inst Bβ aββ·)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .lamDF ih1 ih2 | case lamDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : 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β
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 : IsDefEq env U Ξβ Aβ A'β (sort uβ)
a_ihβΒ² : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
a_ihβΒΉ : IsDefEq env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
ih2 : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : IsDefEq env U (A'β :: Ξβ) bodyβ body'β Bβ
β’ IsDefEq env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (forallE Aβ Bβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : 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β
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 : IsDefEq env U Ξβ Aβ A'β (sort uβ)
a_ihβΒ² : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
a_ihβΒΉ : IsDefEq env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
ih2 : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β Bβ
a_ihβ : IsDefEq env U (A'β :: Ξβ) bodyβ body'β Bβ
β’ IsDefEq env U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .forallEDF ih1 ih2 | case forallEDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 : IsDefEq env U Ξβ Aβ A'β (sort uβ)
ih2 : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
a_ihβ : IsDefEq env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
β’ IsDefEq env U Ξβ (forallE Aβ bodyβ) (forallE A'β body'β) (sort (VLevel.imax uβ vβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 : IsDefEq env U Ξβ Aβ A'β (sort uβ)
ih2 : IsDefEq env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
a_ihβ : IsDefEq env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
β’ IsDefEq env U Ξβ (forallE Aβ bodyβ) (forallE A'β body'β) (sort (VLevel.imax uβ vβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .defeqDF ih1 ih2 | case defeqDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
aβΒ² : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 : IsDefEq env U Ξβ Aβ Bβ (sort uβ)
ih2 : IsDefEq env U Ξβ e1β e2β Aβ
β’ IsDefEq env U Ξβ e1β e2β Bβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
aβΒ² : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 : IsDefEq env U Ξβ Aβ Bβ (sort uβ)
ih2 : IsDefEq env U Ξβ e1β e2β Aβ
β’ IsDefEq env U Ξβ e1β e2β Bβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .beta ih1 ih2 | case beta
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
a_ihβΒ³ : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
a_ihβΒ² : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih1 : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : IsDefEq env U Ξβ e'β e'β Aβ
a_ihβΒΉ : IsDefEq env U Ξβ (inst Bβ e'β) (inst Bβ e'β) (sort vβ)
a_ihβ : IsDefEq env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
β’ IsDefEq env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
a_ihβΒ³ : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
a_ihβΒ² : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih1 : IsDefEq env U (Aβ :: Ξβ) eβ eβ Bβ
ih2 : IsDefEq env U Ξβ e'β e'β Aβ
a_ihβΒΉ : IsDefEq env U Ξβ (inst Bβ e'β) (inst Bβ e'β) (sort vβ)
a_ihβ : IsDefEq env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
β’ IsDefEq env U Ξβ (app (lam Aβ eβ) e'β) (inst eβ e'β) (inst Bβ e'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .eta ih | case eta
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
a_ihβΒ² : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
a_ihβΒΉ : IsDefEq env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
ih : IsDefEq env U Ξβ eβ eβ (forallE Aβ Bβ)
a_ihβ : IsDefEq env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
β’ IsDefEq env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (forallE Aβ Bβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
a_ihβΒ³ : IsDefEq env U Ξβ Aβ Aβ (sort uβ)
a_ihβΒ² : IsDefEq env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
a_ihβΒΉ : IsDefEq env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
ih : IsDefEq env U Ξβ eβ eβ (forallE Aβ Bβ)
a_ihβ : IsDefEq env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
β’ IsDefEq env U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .proofIrrel ih1 ih2 ih3 | case proofIrrel
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 : IsDefEq env U Ξβ pβ pβ (sort VLevel.zero)
ih2 : IsDefEq env U Ξβ hβ hβ pβ
ih3 : IsDefEq env U Ξβ h'β h'β pβ
β’ IsDefEq env U Ξβ hβ h'β pβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 : IsDefEq env U Ξβ pβ pβ (sort VLevel.zero)
ih2 : IsDefEq env U Ξβ hβ hβ pβ
ih3 : IsDefEq env U Ξβ h'β h'β pβ
β’ IsDefEq env U Ξβ hβ h'β pβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.defeq | [131, 1] | [145, 44] | exact .extra h1 h2 h3 | case extra
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
aβΒ³ : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβΒ² : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihββ΄ : IsDefEq env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
a_ihβΒ³ : IsDefEq env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
a_ihβΒ² : IsDefEq env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒΉ : IsDefEq env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
a_ihβ : IsDefEq env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEq env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
aβΒ³ : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβΒ² : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihββ΄ : IsDefEq env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
a_ihβΒ³ : IsDefEq env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
a_ihβΒ² : IsDefEq env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
a_ihβΒΉ : IsDefEq env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
a_ihβ : IsDefEq env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEq env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | induction H with
| bvar h1 h2 _ ih => exact .bvar h1 h2 ih
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 h6 _ _ _ _ ih1 ih2 ih3 ih4 =>
exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5 h6 ih1 ih2 ih3 ih4
| appDF h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 => exact .appDF h1 h2 ih1 ih2 ih3 ih4 ih5
| lamDF h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 => exact .lamDF h1 h2 ih1 ih2 ih3 ih4 ih5
| forallEDF h1 h2 _ _ _ ih1 ih2 ih3 => exact .forallEDF h1 h2 ih1 ih2 ih3
| defeqDF h1 _ _ ih1 ih2 => exact .defeqDF h1 ih1 ih2
| beta h1 h2 _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 ih6 => exact .beta h1 h2 ih1 ih2 ih3 ih4 ih5 ih6
| eta h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 => exact .eta h1 h2 ih1 ih2 ih3 ih4 ih5
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 h4 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
exact .extra (henv.2 _ h1) h2 h3 h4 ih1 ih2 ih3 ih4 ih5 | env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Ξ e1 e2 A
β’ IsDefEqStrong env' U Ξ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Ξ e1 e2 A
β’ IsDefEqStrong env' U Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .bvar h1 h2 ih | case bvar
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h1 : Lookup Ξβ iβ Aβ
h2 : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
ih : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
β’ IsDefEqStrong env' U Ξβ (VExpr.bvar iβ) (VExpr.bvar iβ) Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h1 : Lookup Ξβ iβ Aβ
h2 : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
ih : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
β’ IsDefEqStrong env' U Ξβ (VExpr.bvar iβ) (VExpr.bvar iβ) Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .symm ih | case symm
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : IsDefEqStrong env' U Ξβ eβ e'β Aβ
β’ IsDefEqStrong env' U Ξβ e'β eβ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : IsDefEqStrong env' U Ξβ eβ e'β Aβ
β’ IsDefEqStrong env' U Ξβ e'β eβ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .trans ih1 ih2 | case trans
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : IsDefEqStrong env' U Ξβ eββ eββ Aβ
ih2 : IsDefEqStrong env' U Ξβ eββ eββ Aβ
β’ IsDefEqStrong env' U Ξβ eββ eββ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : IsDefEqStrong env' U Ξβ eββ eββ Aβ
ih2 : IsDefEqStrong env' U Ξβ eββ eββ Aβ
β’ IsDefEqStrong env' U Ξβ eββ eββ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .sortDF h1 h2 h3 | case sortDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U lβ
h2 : VLevel.WF U l'β
h3 : lβ β l'β
β’ IsDefEqStrong env' U Ξβ (sort lβ) (sort l'β) (sort (VLevel.succ lβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
h1 : VLevel.WF U lβ
h2 : VLevel.WF U l'β
h3 : lβ β l'β
β’ IsDefEqStrong env' U Ξβ (sort lβ) (sort l'β) (sort (VLevel.succ lβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5 h6 ih1 ih2 ih3 ih4 | case constDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
ih1 : IsDefEqStrong env' U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
ih2 : IsDefEqStrong env' U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
ih3 : IsDefEqStrong env' U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
ih4 : IsDefEqStrong env' U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
β’ IsDefEqStrong env' U Ξβ (const cβ lsβ) (const cβ ls'β) (instL lsβ ciβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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'β
h6 : VLevel.WF U uβ
aβΒ³ : IsDefEqStrong env U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
ih1 : IsDefEqStrong env' U [] (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
ih2 : IsDefEqStrong env' U [] (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
ih3 : IsDefEqStrong env' U Ξβ (instL lsβ ciβ.type) (instL lsβ ciβ.type) (sort uβ)
ih4 : IsDefEqStrong env' U Ξβ (instL ls'β ciβ.type) (instL ls'β ciβ.type) (sort uβ)
β’ IsDefEqStrong env' U Ξβ (const cβ lsβ) (const cβ ls'β) (instL lsβ ciβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .appDF h1 h2 ih1 ih2 ih3 ih4 ih5 | case appDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U Ξβ fβ f'β (forallE Aβ Bβ)
ih4 : IsDefEqStrong env' U Ξβ aββ΅ a'β Aβ
ih5 : IsDefEqStrong env' U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
β’ IsDefEqStrong env' U Ξβ (app fβ aββ΅) (app f'β a'β) (inst Bβ aββ΅) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
fβ f'β aββ΅ a'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ΅ a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
ih1 : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U Ξβ fβ f'β (forallE Aβ Bβ)
ih4 : IsDefEqStrong env' U Ξβ aββ΅ a'β Aβ
ih5 : IsDefEqStrong env' U Ξβ (inst Bβ aββ΅) (inst Bβ a'β) (sort vβ)
β’ IsDefEqStrong env' U Ξβ (app fβ aββ΅) (app f'β a'β) (inst Bβ aββ΅)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .lamDF h1 h2 ih1 ih2 ih3 ih4 ih5 | case lamDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ body'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 : IsDefEqStrong env' U Ξβ Aβ A'β (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U (A'β :: Ξβ) Bβ Bβ (sort vβ)
ih4 : IsDefEqStrong env' U (Aβ :: Ξβ) bodyβ body'β Bβ
ih5 : IsDefEqStrong env' U (A'β :: Ξβ) bodyβ body'β Bβ
β’ IsDefEqStrong env' U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (forallE Aβ Bβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
bodyβ body'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 : IsDefEqStrong env' U Ξβ Aβ A'β (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U (A'β :: Ξβ) Bβ Bβ (sort vβ)
ih4 : IsDefEqStrong env' U (Aβ :: Ξβ) bodyβ body'β Bβ
ih5 : IsDefEqStrong env' U (A'β :: Ξβ) bodyβ body'β Bβ
β’ IsDefEqStrong env' U Ξβ (lam Aβ bodyβ) (lam A'β body'β) (forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .forallEDF h1 h2 ih1 ih2 ih3 | case forallEDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aβΒ² : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 : IsDefEqStrong env' U Ξβ Aβ A'β (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
ih3 : IsDefEqStrong env' U (A'β :: Ξβ) bodyβ body'β (sort vβ)
β’ IsDefEqStrong env' U Ξβ (forallE Aβ bodyβ) (forallE A'β body'β) (sort (VLevel.imax uβ vβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ A'β : VExpr
uβ : VLevel
bodyβ body'β : VExpr
vβ : VLevel
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aβΒ² : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 : IsDefEqStrong env' U Ξβ Aβ A'β (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
ih3 : IsDefEqStrong env' U (A'β :: Ξβ) bodyβ body'β (sort vβ)
β’ IsDefEqStrong env' U Ξβ (forallE Aβ bodyβ) (forallE A'β body'β) (sort (VLevel.imax uβ vβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .defeqDF h1 ih1 ih2 | case defeqDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
h1 : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 : IsDefEqStrong env' U Ξβ Aβ Bβ (sort uβ)
ih2 : IsDefEqStrong env' U Ξβ e1β e2β Aβ
β’ IsDefEqStrong env' U Ξβ e1β e2β Bβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
h1 : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 : IsDefEqStrong env' U Ξβ Aβ Bβ (sort uβ)
ih2 : IsDefEqStrong env' U Ξβ e1β e2β Aβ
β’ IsDefEqStrong env' U Ξβ e1β e2β Bβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .beta h1 h2 ih1 ih2 ih3 ih4 ih5 ih6 | case beta
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U (Aβ :: Ξβ) eβ eβ Bβ
ih4 : IsDefEqStrong env' U Ξβ e'β e'β Aβ
ih5 : IsDefEqStrong env' U Ξβ (inst Bβ e'β) (inst Bβ e'β) (sort vβ)
ih6 : IsDefEqStrong env' U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
β’ 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 env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ e'β : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U (Aβ :: Ξβ) eβ eβ Bβ
ih4 : IsDefEqStrong env' U Ξβ e'β e'β Aβ
ih5 : IsDefEqStrong env' U Ξβ (inst Bβ e'β) (inst Bβ e'β) (sort vβ)
ih6 : IsDefEqStrong env' U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
β’ 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.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .eta h1 h2 ih1 ih2 ih3 ih4 ih5 | case eta
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
ih4 : IsDefEqStrong env' U Ξβ eβ eβ (forallE Aβ Bβ)
ih5 : IsDefEqStrong env' U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
β’ IsDefEqStrong env' U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (forallE Aβ Bβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ : VExpr
uβ : VLevel
Bβ : VExpr
vβ : VLevel
eβ : VExpr
h1 : VLevel.WF U uβ
h2 : VLevel.WF U vβ
aββ΄ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 : IsDefEqStrong env' U Ξβ Aβ Aβ (sort uβ)
ih2 : IsDefEqStrong env' U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
ih3 : IsDefEqStrong env' U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
ih4 : IsDefEqStrong env' U Ξβ eβ eβ (forallE Aβ Bβ)
ih5 : IsDefEqStrong env' U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
β’ IsDefEqStrong env' U Ξβ (lam Aβ (app (lift eβ) (VExpr.bvar 0))) eβ (forallE Aβ Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .proofIrrel ih1 ih2 ih3 | case proofIrrel
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 : IsDefEqStrong env' U Ξβ pβ pβ (sort VLevel.zero)
ih2 : IsDefEqStrong env' U Ξβ hβ hβ pβ
ih3 : IsDefEqStrong env' U Ξβ h'β h'β pβ
β’ IsDefEqStrong env' U Ξβ hβ h'β pβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 : IsDefEqStrong env' U Ξβ pβ pβ (sort VLevel.zero)
ih2 : IsDefEqStrong env' U Ξβ hβ hβ pβ
ih3 : IsDefEqStrong env' U Ξβ h'β h'β pβ
β’ IsDefEqStrong env' U Ξβ hβ h'β pβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.mono | [148, 1] | [165, 60] | exact .extra (henv.2 _ h1) h2 h3 h4 ih1 ih2 ih3 ih4 ih5 | case extra
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
aβΒ³ : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβΒ² : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
ih1 : IsDefEqStrong env' U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
ih2 : IsDefEqStrong env' U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih3 : IsDefEqStrong env' U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
ih4 : IsDefEqStrong env' U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih5 : IsDefEqStrong env' U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEqStrong env' U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env env' : VEnv
henv : env β€ env'
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
h4 : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
aβΒ³ : IsDefEqStrong env U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβΒ² : IsDefEqStrong env U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
aβΒΉ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
aβ : IsDefEqStrong env U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
ih1 : IsDefEqStrong env' U [] (instL lsβ dfβ.type) (instL lsβ dfβ.type) (sort uβ)
ih2 : IsDefEqStrong env' U [] (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih3 : IsDefEqStrong env' U [] (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
ih4 : IsDefEqStrong env' U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.lhs) (instL lsβ dfβ.type)
ih5 : IsDefEqStrong env' U Ξβ (instL lsβ dfβ.rhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
β’ IsDefEqStrong env' U Ξβ (instL lsβ dfβ.lhs) (instL lsβ dfβ.rhs) (instL lsβ dfβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weak0 | [168, 1] | [172, 66] | have β¨h1, h2, h3β© := H.defeq.closedN' henv.closed β¨β© | env : VEnv
henv : Ordered env
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
H : IsDefEqStrong env U [] e1 e2 A
β’ IsDefEqStrong env U Ξ e1 e2 A | env : VEnv
henv : Ordered env
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
H : IsDefEqStrong env U [] e1 e2 A
h1 : ClosedN e1 (List.length [])
h2 : ClosedN e2 (List.length [])
h3 : ClosedN A (List.length [])
β’ IsDefEqStrong env U Ξ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
H : IsDefEqStrong env U [] e1 e2 A
β’ IsDefEqStrong env U Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.weak0 | [168, 1] | [172, 66] | simpa [h1.liftN_eq (Nat.zero_le _), h2.liftN_eq (Nat.zero_le _),
h3.liftN_eq (Nat.zero_le _)] using H.weakN henv (.zero Ξ rfl) | env : VEnv
henv : Ordered env
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
H : IsDefEqStrong env U [] e1 e2 A
h1 : ClosedN e1 (List.length [])
h2 : ClosedN e2 (List.length [])
h3 : ClosedN A (List.length [])
β’ IsDefEqStrong env U Ξ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
e1 e2 A : VExpr
Ξ : List VExpr
H : IsDefEqStrong env U [] e1 e2 A
h1 : ClosedN e1 (List.length [])
h2 : ClosedN e2 (List.length [])
h3 : ClosedN A (List.length [])
β’ IsDefEqStrong env U Ξ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | induction H with
| bvar h _ _ ih =>
exact .bvar h.instL (.inst hls) ih
| constDF h1 h2 h3 h4 h5 _ _ _ _ _ ih1 ih2 ih3 ih4 =>
simp [VExpr.instL, VExpr.instL_instL] at ih1 ih2 ih3 ih4 β’
exact .constDF h1
(by simp [h2, VLevel.WF.inst hls]) (by simp [h3, VLevel.WF.inst hls]) (by simp [h4])
(by simpa using h5.imp fun _ _ => VLevel.inst_congr_l) (.inst hls) ih1 ih2 ih3 ih4
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| sortDF _ _ h3 =>
exact .sortDF (VLevel.WF.inst hls) (VLevel.WF.inst hls) (VLevel.inst_congr_l h3)
| appDF _ _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
exact instL_instN βΈ .appDF (.inst hls) (.inst hls)
ih1 ih2 ih3 ih4 (instL_instN βΈ instL_instN βΈ ih5)
| lamDF _ _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
exact .lamDF (.inst hls) (.inst hls) ih1 ih2 ih3 ih4 ih5
| forallEDF _ _ _ _ _ ih1 ih2 ih3 =>
exact .forallEDF (.inst hls) (.inst hls) ih1 ih2 ih3
| defeqDF _ _ _ ih1 ih2 =>
exact .defeqDF (.inst hls) ih1 ih2
| beta _ _ _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 ih6 =>
simpa using .beta (.inst hls) (.inst hls) ih1 ih2 ih3 ih4
(by simpa using ih5) (by simpa using ih6)
| eta _ _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
simpa [VExpr.instL] using .eta (.inst hls) (.inst hls) ih1 ih2
(by simpa using ih3) ih4 (by simpa [VExpr.instL] using ih5)
| proofIrrel _ _ _ ih1 ih2 ih3 =>
exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
simp [VExpr.instL, VExpr.instL_instL] at ih1 ih2 ih3 ih4 ih5 β’
exact .extra h1 (by simp [h2, VLevel.WF.inst hls]) (by simp [h3])
(.inst hls) ih1 ih2 ih3 ih4 ih5 | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Ξ e1 e2 A
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξ) (VExpr.instL ls e1) (VExpr.instL ls e2) (VExpr.instL ls A) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Ξ e1 e2 A
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξ) (VExpr.instL ls e1) (VExpr.instL ls e2) (VExpr.instL ls A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .bvar h.instL (.inst hls) ih | case bvar
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h : Lookup Ξβ iβ Aβ
aβΒΉ : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
ih :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.bvar iβ)) (VExpr.instL ls (VExpr.bvar iβ))
(VExpr.instL ls Aβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
iβ : Nat
Aβ : VExpr
uβ : VLevel
h : Lookup Ξβ iβ Aβ
aβΒΉ : VLevel.WF U uβ
aβ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
ih :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.bvar iβ)) (VExpr.instL ls (VExpr.bvar iβ))
(VExpr.instL ls Aβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [VExpr.instL, VExpr.instL_instL] at ih1 ih2 ih3 ih4 β’ | case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ ciβ.type))
(VExpr.instL ls (VExpr.instL lsβ ciβ.type)) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL ls'β ciβ.type))
(VExpr.instL ls (VExpr.instL ls'β ciβ.type)) (VExpr.instL ls (sort uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ ciβ.type))
(VExpr.instL ls (VExpr.instL lsβ ciβ.type)) (VExpr.instL ls (sort uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL ls'β ciβ.type))
(VExpr.instL ls (VExpr.instL ls'β ciβ.type)) (VExpr.instL ls (sort uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (const cβ lsβ)) (VExpr.instL ls (const cβ ls'β))
(VExpr.instL ls (VExpr.instL lsβ ciβ.type)) | case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (const cβ (List.map (VLevel.inst ls) lsβ))
(const cβ (List.map (VLevel.inst ls) ls'β)) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ ciβ.type))
(VExpr.instL ls (VExpr.instL lsβ ciβ.type)) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL ls'β ciβ.type))
(VExpr.instL ls (VExpr.instL ls'β ciβ.type)) (VExpr.instL ls (sort uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ ciβ.type))
(VExpr.instL ls (VExpr.instL lsβ ciβ.type)) (VExpr.instL ls (sort uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL ls'β ciβ.type))
(VExpr.instL ls (VExpr.instL ls'β ciβ.type)) (VExpr.instL ls (sort uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (const cβ lsβ)) (VExpr.instL ls (const cβ ls'β))
(VExpr.instL ls (VExpr.instL lsβ ciβ.type))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .constDF h1
(by simp [h2, VLevel.WF.inst hls]) (by simp [h3, VLevel.WF.inst hls]) (by simp [h4])
(by simpa using h5.imp fun _ _ => VLevel.inst_congr_l) (.inst hls) ih1 ih2 ih3 ih4 | case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (const cβ (List.map (VLevel.inst ls) lsβ))
(const cβ (List.map (VLevel.inst ls) ls'β)) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (const cβ (List.map (VLevel.inst ls) lsβ))
(const cβ (List.map (VLevel.inst ls) ls'β)) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [h2, VLevel.WF.inst hls] | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ β (l : VLevel), l β List.map (VLevel.inst ls) lsβ β VLevel.WF U' l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ β (l : VLevel), l β List.map (VLevel.inst ls) lsβ β VLevel.WF U' l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [h3, VLevel.WF.inst hls] | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ β (l : VLevel), l β List.map (VLevel.inst ls) ls'β β VLevel.WF U' l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ β (l : VLevel), l β List.map (VLevel.inst ls) ls'β β VLevel.WF U' l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [h4] | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ List.length (List.map (VLevel.inst ls) lsβ) = ciβ.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ List.length (List.map (VLevel.inst ls) lsβ) = ciβ.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa using h5.imp fun _ _ => VLevel.inst_congr_l | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ List.Forallβ (fun x x_1 => x β x_1) (List.map (VLevel.inst ls) lsβ) (List.map (VLevel.inst ls) ls'β) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
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) (sort uβ)
aβΒ² : IsDefEqStrong env U [] (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
aβΒΉ : IsDefEqStrong env U Ξβ (VExpr.instL lsβ ciβ.type) (VExpr.instL lsβ ciβ.type) (sort uβ)
aβ : IsDefEqStrong env U Ξβ (VExpr.instL ls'β ciβ.type) (VExpr.instL ls'β ciβ.type) (sort uβ)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) ciβ.type) (sort (VLevel.inst ls uβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type)
(VExpr.instL (List.map (VLevel.inst ls) ls'β) ciβ.type) (sort (VLevel.inst ls uβ))
β’ List.Forallβ (fun x x_1 => x β x_1) (List.map (VLevel.inst ls) lsβ) (List.map (VLevel.inst ls) ls'β)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .symm ih | case symm
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls eβ) (VExpr.instL ls Aβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eβ e'β Aβ : VExpr
aβ : IsDefEqStrong env U Ξβ eβ e'β Aβ
ih : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls eβ) (VExpr.instL ls Aβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .trans ih1 ih2 | case trans
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eββ) (VExpr.instL ls eββ) (VExpr.instL ls Aβ)
ih2 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eββ) (VExpr.instL ls eββ) (VExpr.instL ls Aβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eββ) (VExpr.instL ls eββ) (VExpr.instL ls Aβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
eββ eββ Aβ eββ : VExpr
aβΒΉ : IsDefEqStrong env U Ξβ eββ eββ Aβ
aβ : IsDefEqStrong env U Ξβ eββ eββ Aβ
ih1 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eββ) (VExpr.instL ls eββ) (VExpr.instL ls Aβ)
ih2 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eββ) (VExpr.instL ls eββ) (VExpr.instL ls Aβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eββ) (VExpr.instL ls eββ) (VExpr.instL ls Aβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .sortDF (VLevel.WF.inst hls) (VLevel.WF.inst hls) (VLevel.inst_congr_l h3) | case sortDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
aβΒΉ : VLevel.WF U lβ
aβ : VLevel.WF U l'β
h3 : lβ β l'β
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (sort lβ)) (VExpr.instL ls (sort l'β))
(VExpr.instL ls (sort (VLevel.succ lβ))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
lβ l'β : VLevel
Ξβ : List VExpr
aβΒΉ : VLevel.WF U lβ
aβ : VLevel.WF U l'β
h3 : lβ β l'β
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (sort lβ)) (VExpr.instL ls (sort l'β))
(VExpr.instL ls (sort (VLevel.succ lβ)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact instL_instN βΈ .appDF (.inst hls) (.inst hls)
ih1 ih2 ih3 ih4 (instL_instN βΈ instL_instN βΈ ih5) | case appDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (sort vβ)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls fβ) (VExpr.instL ls f'β)
(VExpr.instL ls (forallE Aβ Bβ))
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls aββ·) (VExpr.instL ls a'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ aββ·)) (VExpr.instL ls (inst Bβ a'β))
(VExpr.instL ls (sort vβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (app fβ aββ·)) (VExpr.instL ls (app f'β a'β))
(VExpr.instL ls (inst Bβ aββ·)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U Ξβ fβ f'β (forallE Aβ Bβ)
aβΒΉ : IsDefEqStrong env U Ξβ aββ· a'β Aβ
aβ : IsDefEqStrong env U Ξβ (inst Bβ aββ·) (inst Bβ a'β) (sort vβ)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls fβ) (VExpr.instL ls f'β)
(VExpr.instL ls (forallE Aβ Bβ))
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls aββ·) (VExpr.instL ls a'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ aββ·)) (VExpr.instL ls (inst Bβ a'β))
(VExpr.instL ls (sort vβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (app fβ aββ·)) (VExpr.instL ls (app f'β a'β))
(VExpr.instL ls (inst Bβ aββ·))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .lamDF (.inst hls) (.inst hls) ih1 ih2 ih3 ih4 ih5 | case lamDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : 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β
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls A'β)
(VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (A'β :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls Bβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (A'β :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls Bβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (lam Aβ bodyβ)) (VExpr.instL ls (lam A'β body'β))
(VExpr.instL ls (forallE Aβ Bβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : 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β
aββ΄ : IsDefEqStrong env U Ξβ Aβ A'β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (A'β :: Ξβ) Bβ Bβ (sort vβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β Bβ
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β Bβ
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls A'β)
(VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (A'β :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls Bβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (A'β :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls Bβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (lam Aβ bodyβ)) (VExpr.instL ls (lam A'β body'β))
(VExpr.instL ls (forallE Aβ Bβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .forallEDF (.inst hls) (.inst hls) ih1 ih2 ih3 | case forallEDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls A'β)
(VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (A'β :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls (sort vβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (forallE Aβ bodyβ))
(VExpr.instL ls (forallE A'β body'β)) (VExpr.instL ls (sort (VLevel.imax uβ vβ))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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'β (sort uβ)
aβΒΉ : IsDefEqStrong env U (Aβ :: Ξβ) bodyβ body'β (sort vβ)
aβ : IsDefEqStrong env U (A'β :: Ξβ) bodyβ body'β (sort vβ)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls A'β)
(VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (A'β :: Ξβ)) (VExpr.instL ls bodyβ) (VExpr.instL ls body'β)
(VExpr.instL ls (sort vβ))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (forallE Aβ bodyβ))
(VExpr.instL ls (forallE A'β body'β)) (VExpr.instL ls (sort (VLevel.imax uβ vβ)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .defeqDF (.inst hls) ih1 ih2 | case defeqDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
aβΒ² : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Bβ) (VExpr.instL ls (sort uβ))
ih2 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e1β) (VExpr.instL ls e2β) (VExpr.instL ls Aβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e1β) (VExpr.instL ls e2β) (VExpr.instL ls Bβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
Aβ Bβ : VExpr
uβ : VLevel
e1β e2β : VExpr
aβΒ² : VLevel.WF U uβ
aβΒΉ : IsDefEqStrong env U Ξβ Aβ Bβ (sort uβ)
aβ : IsDefEqStrong env U Ξβ e1β e2β Aβ
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Bβ) (VExpr.instL ls (sort uβ))
ih2 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e1β) (VExpr.instL ls e2β) (VExpr.instL ls Aβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e1β) (VExpr.instL ls e2β) (VExpr.instL ls Bβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa using .beta (.inst hls) (.inst hls) ih1 ih2 ih3 ih4
(by simpa using ih5) (by simpa using ih6) | case beta
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls Bβ)
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ e'β)) (VExpr.instL ls (inst Bβ e'β))
(VExpr.instL ls (sort vβ))
ih6 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst eβ e'β))
(VExpr.instL ls (inst Bβ e'β))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (app (lam Aβ eβ) e'β))
(VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst Bβ e'β)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls Bβ)
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ e'β)) (VExpr.instL ls (inst Bβ e'β))
(VExpr.instL ls (sort vβ))
ih6 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst eβ e'β))
(VExpr.instL ls (inst Bβ e'β))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (app (lam Aβ eβ) e'β))
(VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst Bβ e'β))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa using ih5 | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls Bβ)
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ e'β)) (VExpr.instL ls (inst Bβ e'β))
(VExpr.instL ls (sort vβ))
ih6 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst eβ e'β))
(VExpr.instL ls (inst Bβ e'β))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (inst (VExpr.instL ls Bβ) (VExpr.instL ls e'β))
(inst (VExpr.instL ls Bβ) (VExpr.instL ls e'β)) (sort (VLevel.inst ls vβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls Bβ)
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ e'β)) (VExpr.instL ls (inst Bβ e'β))
(VExpr.instL ls (sort vβ))
ih6 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst eβ e'β))
(VExpr.instL ls (inst Bβ e'β))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (inst (VExpr.instL ls Bβ) (VExpr.instL ls e'β))
(inst (VExpr.instL ls Bβ) (VExpr.instL ls e'β)) (sort (VLevel.inst ls vβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa using ih6 | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls Bβ)
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ e'β)) (VExpr.instL ls (inst Bβ e'β))
(VExpr.instL ls (sort vβ))
ih6 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst eβ e'β))
(VExpr.instL ls (inst Bβ e'β))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (inst (VExpr.instL ls eβ) (VExpr.instL ls e'β))
(inst (VExpr.instL ls eβ) (VExpr.instL ls e'β)) (inst (VExpr.instL ls Bβ) (VExpr.instL ls e'β)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β
aββ΅ : IsDefEqStrong env U Ξβ Aβ Aβ (sort uβ)
aββ΄ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (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'β) (sort vβ)
aβ : IsDefEqStrong env U Ξβ (inst eβ e'β) (inst eβ e'β) (inst Bβ e'β)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls Bβ)
ih4 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls e'β) (VExpr.instL ls e'β) (VExpr.instL ls Aβ)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst Bβ e'β)) (VExpr.instL ls (inst Bβ e'β))
(VExpr.instL ls (sort vβ))
ih6 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (inst eβ e'β)) (VExpr.instL ls (inst eβ e'β))
(VExpr.instL ls (inst Bβ e'β))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (inst (VExpr.instL ls eβ) (VExpr.instL ls e'β))
(inst (VExpr.instL ls eβ) (VExpr.instL ls e'β)) (inst (VExpr.instL ls Bβ) (VExpr.instL ls e'β))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa [VExpr.instL] using .eta (.inst hls) (.inst hls) ih1 ih2
(by simpa using ih3) ih4 (by simpa [VExpr.instL] using ih5) | case eta
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (lift Aβ :: Aβ :: Ξβ)) (VExpr.instL ls (liftN 1 Bβ 1))
(VExpr.instL ls (liftN 1 Bβ 1)) (VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls (forallE Aβ Bβ))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls (lift eβ)) (VExpr.instL ls (lift eβ))
(VExpr.instL ls (forallE (lift Aβ) (liftN 1 Bβ 1)))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (lam Aβ (app (lift eβ) (VExpr.bvar 0))))
(VExpr.instL ls eβ) (VExpr.instL ls (forallE Aβ Bβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (lift Aβ :: Aβ :: Ξβ)) (VExpr.instL ls (liftN 1 Bβ 1))
(VExpr.instL ls (liftN 1 Bβ 1)) (VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls (forallE Aβ Bβ))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls (lift eβ)) (VExpr.instL ls (lift eβ))
(VExpr.instL ls (forallE (lift Aβ) (liftN 1 Bβ 1)))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (lam Aβ (app (lift eβ) (VExpr.bvar 0))))
(VExpr.instL ls eβ) (VExpr.instL ls (forallE Aβ Bβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa using ih3 | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (lift Aβ :: Aβ :: Ξβ)) (VExpr.instL ls (liftN 1 Bβ 1))
(VExpr.instL ls (liftN 1 Bβ 1)) (VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls (forallE Aβ Bβ))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls (lift eβ)) (VExpr.instL ls (lift eβ))
(VExpr.instL ls (forallE (lift Aβ) (liftN 1 Bβ 1)))
β’ IsDefEqStrong env U' (lift (VExpr.instL ls Aβ) :: VExpr.instL ls Aβ :: List.map (VExpr.instL ls) Ξβ)
(liftN 1 (VExpr.instL ls Bβ) 1) (liftN 1 (VExpr.instL ls Bβ) 1) (sort (VLevel.inst ls vβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (lift Aβ :: Aβ :: Ξβ)) (VExpr.instL ls (liftN 1 Bβ 1))
(VExpr.instL ls (liftN 1 Bβ 1)) (VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls (forallE Aβ Bβ))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls (lift eβ)) (VExpr.instL ls (lift eβ))
(VExpr.instL ls (forallE (lift Aβ) (liftN 1 Bβ 1)))
β’ IsDefEqStrong env U' (lift (VExpr.instL ls Aβ) :: VExpr.instL ls Aβ :: List.map (VExpr.instL ls) Ξβ)
(liftN 1 (VExpr.instL ls Bβ) 1) (liftN 1 (VExpr.instL ls Bβ) 1) (sort (VLevel.inst ls vβ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simpa [VExpr.instL] using ih5 | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (lift Aβ :: Aβ :: Ξβ)) (VExpr.instL ls (liftN 1 Bβ 1))
(VExpr.instL ls (liftN 1 Bβ 1)) (VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls (forallE Aβ Bβ))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls (lift eβ)) (VExpr.instL ls (lift eβ))
(VExpr.instL ls (forallE (lift Aβ) (liftN 1 Bβ 1)))
β’ IsDefEqStrong env U' (VExpr.instL ls Aβ :: List.map (VExpr.instL ls) Ξβ) (lift (VExpr.instL ls eβ))
(lift (VExpr.instL ls eβ)) (forallE (lift (VExpr.instL ls Aβ)) (liftN 1 (VExpr.instL ls Bβ) 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 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β (sort uβ)
aβΒ³ : IsDefEqStrong env U (Aβ :: Ξβ) Bβ Bβ (sort vβ)
aβΒ² : IsDefEqStrong env U (lift Aβ :: Aβ :: Ξβ) (liftN 1 Bβ 1) (liftN 1 Bβ 1) (sort vβ)
aβΒΉ : IsDefEqStrong env U Ξβ eβ eβ (forallE Aβ Bβ)
aβ : IsDefEqStrong env U (Aβ :: Ξβ) (lift eβ) (lift eβ) (forallE (lift Aβ) (liftN 1 Bβ 1))
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls Aβ) (VExpr.instL ls Aβ) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls Bβ) (VExpr.instL ls Bβ)
(VExpr.instL ls (sort vβ))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (lift Aβ :: Aβ :: Ξβ)) (VExpr.instL ls (liftN 1 Bβ 1))
(VExpr.instL ls (liftN 1 Bβ 1)) (VExpr.instL ls (sort vβ))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls eβ) (VExpr.instL ls eβ)
(VExpr.instL ls (forallE Aβ Bβ))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) (Aβ :: Ξβ)) (VExpr.instL ls (lift eβ)) (VExpr.instL ls (lift eβ))
(VExpr.instL ls (forallE (lift Aβ) (liftN 1 Bβ 1)))
β’ IsDefEqStrong env U' (VExpr.instL ls Aβ :: List.map (VExpr.instL ls) Ξβ) (lift (VExpr.instL ls eβ))
(lift (VExpr.instL ls eβ)) (forallE (lift (VExpr.instL ls Aβ)) (liftN 1 (VExpr.instL ls Bβ) 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .proofIrrel ih1 ih2 ih3 | case proofIrrel
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls pβ) (VExpr.instL ls pβ)
(VExpr.instL ls (sort VLevel.zero))
ih2 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls hβ) (VExpr.instL ls hβ) (VExpr.instL ls pβ)
ih3 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls h'β) (VExpr.instL ls h'β) (VExpr.instL ls pβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls hβ) (VExpr.instL ls h'β) (VExpr.instL ls pβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
pβ hβ h'β : VExpr
aβΒ² : IsDefEqStrong env U Ξβ pβ pβ (sort VLevel.zero)
aβΒΉ : IsDefEqStrong env U Ξβ hβ hβ pβ
aβ : IsDefEqStrong env U Ξβ h'β h'β pβ
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls pβ) (VExpr.instL ls pβ)
(VExpr.instL ls (sort VLevel.zero))
ih2 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls hβ) (VExpr.instL ls hβ) (VExpr.instL ls pβ)
ih3 : IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls h'β) (VExpr.instL ls h'β) (VExpr.instL ls pβ)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls hβ) (VExpr.instL ls h'β) (VExpr.instL ls pβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [VExpr.instL, VExpr.instL_instL] at ih1 ih2 ih3 ih4 ih5 β’ | case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
(VExpr.instL ls (VExpr.instL lsβ dfβ.type)) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ dfβ.lhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.lhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ dfβ.rhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.rhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ dfβ.lhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.lhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ dfβ.rhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.rhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ dfβ.lhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.rhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type)) | case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
(VExpr.instL ls (VExpr.instL lsβ dfβ.type)) (VExpr.instL ls (sort uβ))
ih2 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ dfβ.lhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.lhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
ih3 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) []) (VExpr.instL ls (VExpr.instL lsβ dfβ.rhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.rhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ dfβ.lhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.lhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ dfβ.rhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.rhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL ls (VExpr.instL lsβ dfβ.lhs))
(VExpr.instL ls (VExpr.instL lsβ dfβ.rhs)) (VExpr.instL ls (VExpr.instL lsβ dfβ.type))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | exact .extra h1 (by simp [h2, VLevel.WF.inst hls]) (by simp [h3])
(.inst hls) ih1 ih2 ih3 ih4 ih5 | case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [h2, VLevel.WF.inst hls] | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ β (l : VLevel), l β List.map (VLevel.inst ls) lsβ β VLevel.WF U' l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ β (l : VLevel), l β List.map (VLevel.inst ls) lsβ β VLevel.WF U' l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instL | [175, 1] | [209, 38] | simp [h3] | U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ List.length (List.map (VLevel.inst ls) lsβ) = dfβ.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : β (l : VLevel), l β ls β VLevel.WF U' l
U : Nat
Ξ : List VExpr
e1 e2 A : VExpr
dfβ : VDefEq
lsβ : List VLevel
uβ : VLevel
Ξβ : List VExpr
h1 : env.defeqs dfβ
h2 : β (l : VLevel), l β lsβ β VLevel.WF U l
h3 : List.length lsβ = dfβ.uvars
aββ΅ : VLevel.WF U uβ
aββ΄ : IsDefEqStrong env U [] (VExpr.instL lsβ dfβ.type) (VExpr.instL lsβ dfβ.type) (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)
ih1 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type) (sort (VLevel.inst ls uβ))
ih2 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih3 :
IsDefEqStrong env U' [] (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih4 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.lhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
ih5 :
IsDefEqStrong env U' (List.map (VExpr.instL ls) Ξβ) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs)
(VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.rhs) (VExpr.instL (List.map (VLevel.inst ls) lsβ) dfβ.type)
β’ List.length (List.map (VLevel.inst ls) lsβ) = dfβ.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | induction H generalizing Ξ k with
| @bvar _ i ty _ h _ h2 ih =>
dsimp [inst]; clear h2 ih
induction W generalizing i ty with
| zero =>
cases h with simp [inst_lift]
| zero => exact hβ
| succ h =>
let β¨u, htyβ© := hΞβ.lookup henv h
exact .bvar h (hty.defeq.sort_r henv hΞβ.defeq) hty
| succ _ ih =>
cases h with (simp; rw [Nat.add_comm, β liftN_instN_lo (hj := Nat.zero_le _)])
| zero =>
let β¨u, htyβ© := hΞ.lookup henv .zero
exact .bvar .zero (hty.defeq.sort_r henv hΞ.defeq) hty
| succ h => exact (ih h hΞ.1).weakN henv .one
| symm _ ih => exact .symm (ih W hΞ)
| trans _ _ ih1 ih2 => exact .trans (ih1 W hΞ) (ih2 W hΞ)
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 h6 h7 h8 _ _ _ _ ih3 ih4 =>
simp [(henv.closedC h1).instL.instN_eq (Nat.zero_le _)] at ih3 ih4 β’
exact .constDF h1 h2 h3 h4 h5 h6 h7 h8 (ih3 W hΞ) (ih4 W hΞ)
| appDF h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
exact inst0_inst_hi .. βΈ .appDF h1 h2
(ih1 W hΞ) (ih2 W.succ β¨hΞ, _, ih1 W hΞβ©)
(ih3 W hΞ) (ih4 W hΞ) (inst0_inst_hi .. βΈ inst0_inst_hi .. βΈ ih5 W hΞ)
| lamDF h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
exact
have hΞ' := β¨hΞ, _, (ih1 W hΞ).hasType.1β©
have hΞ'' := β¨hΞ, _, (ih1 W hΞ).hasType.2β©
.lamDF h1 h2 (ih1 W hΞ) (ih2 W.succ hΞ') (ih3 W.succ hΞ'') (ih4 W.succ hΞ') (ih5 W.succ hΞ'')
| forallEDF h1 h2 _ _ _ ih1 ih2 ih3 =>
exact .forallEDF h1 h2 (ih1 W hΞ)
(ih2 W.succ β¨hΞ, _, (ih1 W hΞ).hasType.1β©) (ih3 W.succ β¨hΞ, _, (ih1 W hΞ).hasType.2β©)
| defeqDF h1 _ _ ih1 ih2 => exact .defeqDF h1 (ih1 W hΞ) (ih2 W hΞ)
| beta h1 h2 _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 ih6 =>
rw [inst0_inst_hi, inst0_inst_hi]; exact
have hΞ' := β¨hΞ, _, ih1 W hΞβ©
.beta h1 h2
(ih1 W hΞ) (ih2 W.succ hΞ') (ih3 W.succ hΞ') (ih4 W hΞ)
(inst0_inst_hi .. βΈ ih5 W hΞ) (inst0_inst_hi .. βΈ inst0_inst_hi .. βΈ ih6 W hΞ)
| eta h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
have :=
have hΞ' := β¨hΞ, _, (ih1 W hΞ).hasType.1β©
IsDefEqStrong.eta h1 h2 (ih1 W hΞ) (ih2 W.succ hΞ')
(by
have := ih3 W.succ.succ β¨hΞ', _, by
rw [β lift_instN_lo]; exact (ih1 W hΞ).hasType.1.weakN henv .oneβ©
rwa [lift_instN_lo, liftN_instN_lo (hj := Nat.le_add_left ..), Nat.add_comm 1])
(ih4 W hΞ)
(by
have := ih5 W.succ hΞ'
simp only [inst, β lift_instN_lo] at this
rwa [liftN_instN_lo (hj := Nat.le_add_left ..), Nat.add_comm 1])
rw [lift, liftN_instN_lo (hj := Nat.zero_le _), Nat.add_comm] at this
simpa [inst]
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel (ih1 W hΞ) (ih2 W hΞ) (ih3 W hΞ)
| extra h1 h2 h3 h4 h5 h6 h7 _ _ _ _ _ ih4 ih5 =>
have β¨β¨hA1, _β©, hA2, hA3β© := henv.closed.2 h1
simp [
hA1.instL.instN_eq (Nat.zero_le _),
hA2.instL.instN_eq (Nat.zero_le _),
hA3.instL.instN_eq (Nat.zero_le _)] at ih4 ih5 β’
exact .extra h1 h2 h3 h4 h5 h6 h7 (ih4 W hΞ) (ih5 W hΞ) | env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
k : Nat
Ξβ Ξ : List VExpr
e1 e2 A : VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
H : IsDefEqStrong env U Ξβ e1 e2 A
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (inst e1 eβ k) (inst e2 eβ k) (inst A eβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
k : Nat
Ξβ Ξ : List VExpr
e1 e2 A : VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
H : IsDefEqStrong env U Ξβ e1 e2 A
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (inst e1 eβ k) (inst e2 eβ k) (inst A eβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | dsimp [inst] | case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
h2 : IsDefEqStrong env U Ξβ ty ty (sort uβ)
ih :
β {k : Nat} {Ξ : List VExpr},
Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ β
CtxStrong env U Ξ β IsDefEqStrong env U Ξ (inst ty eβ k) (inst ty eβ k) (inst (sort uβ) eβ k)
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (inst (VExpr.bvar i) eβ k) (inst (VExpr.bvar i) eβ k) (inst ty eβ k) | case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
h2 : IsDefEqStrong env U Ξβ ty ty (sort uβ)
ih :
β {k : Nat} {Ξ : List VExpr},
Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ β
CtxStrong env U Ξ β IsDefEqStrong env U Ξ (inst ty eβ k) (inst ty eβ k) (inst (sort uβ) eβ k)
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (instVar i eβ k) (instVar i eβ k) (inst ty eβ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
h2 : IsDefEqStrong env U Ξβ ty ty (sort uβ)
ih :
β {k : Nat} {Ξ : List VExpr},
Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ β
CtxStrong env U Ξ β IsDefEqStrong env U Ξ (inst ty eβ k) (inst ty eβ k) (inst (sort uβ) eβ k)
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (inst (VExpr.bvar i) eβ k) (inst (VExpr.bvar i) eβ k) (inst ty eβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | clear h2 ih | case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
h2 : IsDefEqStrong env U Ξβ ty ty (sort uβ)
ih :
β {k : Nat} {Ξ : List VExpr},
Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ β
CtxStrong env U Ξ β IsDefEqStrong env U Ξ (inst ty eβ k) (inst ty eβ k) (inst (sort uβ) eβ k)
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (instVar i eβ k) (instVar i eβ k) (inst ty eβ k) | case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (instVar i eβ k) (instVar i eβ k) (inst ty eβ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
h2 : IsDefEqStrong env U Ξβ ty ty (sort uβ)
ih :
β {k : Nat} {Ξ : List VExpr},
Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ β
CtxStrong env U Ξ β IsDefEqStrong env U Ξ (inst ty eβ k) (inst ty eβ k) (inst (sort uβ) eβ k)
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (instVar i eβ k) (instVar i eβ k) (inst ty eβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | induction W generalizing i ty with
| zero =>
cases h with simp [inst_lift]
| zero => exact hβ
| succ h =>
let β¨u, htyβ© := hΞβ.lookup henv h
exact .bvar h (hty.defeq.sort_r henv hΞβ.defeq) hty
| succ _ ih =>
cases h with (simp; rw [Nat.add_comm, β liftN_instN_lo (hj := Nat.zero_le _)])
| zero =>
let β¨u, htyβ© := hΞ.lookup henv .zero
exact .bvar .zero (hty.defeq.sort_r henv hΞ.defeq) hty
| succ h => exact (ih h hΞ.1).weakN henv .one | case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (instVar i eβ k) (instVar i eβ k) (inst ty eβ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
i : Nat
ty : VExpr
uβ : VLevel
h : Lookup Ξβ i ty
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
W : Ctx.InstN Ξβ eβ Aβ k Ξβ Ξ
hΞ : CtxStrong env U Ξ
β’ IsDefEqStrong env U Ξ (instVar i eβ k) (instVar i eβ k) (inst ty eβ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | cases h with simp [inst_lift]
| zero => exact hβ
| succ h =>
let β¨u, htyβ© := hΞβ.lookup henv h
exact .bvar h (hty.defeq.sort_r henv hΞβ.defeq) hty | case bvar.zero
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
i : Nat
ty : VExpr
h : Lookup (Aβ :: Ξβ) i ty
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (instVar i eβ) (instVar i eβ) (inst ty eβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
i : Nat
ty : VExpr
h : Lookup (Aβ :: Ξβ) i ty
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ (instVar i eβ) (instVar i eβ) (inst ty eβ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | exact hβ | case bvar.zero.zero
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ eβ eβ Aβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero.zero
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
β’ IsDefEqStrong env U Ξβ eβ eβ Aβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | let β¨u, htyβ© := hΞβ.lookup henv h | case bvar.zero.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U Ξβ (VExpr.bvar nβ) (VExpr.bvar nβ) tyβ | case bvar.zero.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
u : VLevel
hty : IsDefEqStrong env U Ξβ tyβ tyβ (sort u)
β’ IsDefEqStrong env U Ξβ (VExpr.bvar nβ) (VExpr.bvar nβ) tyβ | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U Ξβ (VExpr.bvar nβ) (VExpr.bvar nβ) tyβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | exact .bvar h (hty.defeq.sort_r henv hΞβ.defeq) hty | case bvar.zero.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
u : VLevel
hty : IsDefEqStrong env U Ξβ tyβ tyβ (sort u)
β’ IsDefEqStrong env U Ξβ (VExpr.bvar nβ) (VExpr.bvar nβ) tyβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
Ξβ : List VExpr
uβ : VLevel
aβ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
hΞ : CtxStrong env U Ξβ
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
u : VLevel
hty : IsDefEqStrong env U Ξβ tyβ tyβ (sort u)
β’ IsDefEqStrong env U Ξβ (VExpr.bvar nβ) (VExpr.bvar nβ) tyβ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | cases h with (simp; rw [Nat.add_comm, β liftN_instN_lo (hj := Nat.zero_le _)])
| zero =>
let β¨u, htyβ© := hΞ.lookup henv .zero
exact .bvar .zero (hty.defeq.sort_r henv hΞ.defeq) hty
| succ h => exact (ih h hΞ.1).weakN henv .one | case bvar.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
i : Nat
ty : VExpr
h : Lookup (Aβ :: Ξβ) i ty
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (instVar i eβ (kβ + 1)) (instVar i eβ (kβ + 1)) (inst ty eβ (kβ + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
i : Nat
ty : VExpr
h : Lookup (Aβ :: Ξβ) i ty
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (instVar i eβ (kβ + 1)) (instVar i eβ (kβ + 1)) (inst ty eβ (kβ + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | simp | case bvar.succ.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (instVar (nβ + 1) eβ (kβ + 1)) (instVar (nβ + 1) eβ (kβ + 1))
(inst (lift tyβ) eβ (kβ + 1)) | case bvar.succ.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (lift (instVar nβ eβ kβ)) (lift (instVar nβ eβ kβ))
(inst (lift tyβ) eβ (kβ + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (instVar (nβ + 1) eβ (kβ + 1)) (instVar (nβ + 1) eβ (kβ + 1))
(inst (lift tyβ) eβ (kβ + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Strong.lean | Lean4Lean.VEnv.IsDefEqStrong.instN | [223, 1] | [289, 60] | rw [Nat.add_comm, β liftN_instN_lo (hj := Nat.zero_le _)] | case bvar.succ.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (lift (instVar nβ eβ kβ)) (lift (instVar nβ eβ kβ))
(inst (lift tyβ) eβ (kβ + 1)) | case bvar.succ.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (lift (instVar nβ eβ kβ)) (lift (instVar nβ eβ kβ))
(liftN 1 (inst tyβ eβ kβ)) | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ.succ
env : VEnv
U : Nat
Ξβ : List VExpr
eβ Aβ : VExpr
henv : Ordered env
hβ : IsDefEqStrong env U Ξβ eβ eβ Aβ
hΞβ : CtxStrong env U Ξβ
Ξβ : List VExpr
e1 e2 A : VExpr
ΞβΒΉ : List VExpr
uβ : VLevel
aβΒΉ : VLevel.WF U uβ
k : Nat
Ξ : List VExpr
kβ : Nat
Ξβ Ξ'β : List VExpr
Aβ : VExpr
aβ : Ctx.InstN Ξβ eβ Aβ kβ Ξβ Ξ'β
ih :
β {i : Nat} {ty : VExpr},
Lookup Ξβ i ty β CtxStrong env U Ξ'β β IsDefEqStrong env U Ξ'β (instVar i eβ kβ) (instVar i eβ kβ) (inst ty eβ kβ)
hΞ : CtxStrong env U (inst Aβ eβ kβ :: Ξ'β)
nβ : Nat
tyβ : VExpr
h : Lookup Ξβ nβ tyβ
β’ IsDefEqStrong env U (inst Aβ eβ kβ :: Ξ'β) (lift (instVar nβ eβ kβ)) (lift (instVar nβ eβ kβ))
(inst (lift tyβ) eβ (kβ + 1))
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.