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.instN | [569, 1] | [606, 26] | exact .bvar h | case bvar.zero.succ
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ₀ n✝ ty✝
⊢ IsDefEq 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ₀ n✝ ty✝
⊢ IsDefEq env U Γ₀ (VExpr.bvar n✝) (VExpr.bvar n✝) ty✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | cases h with (simp; rw [Nat.add_comm, ← VExpr.liftN_instN_lo (hj := Nat.zero_le _)])
| zero => exact .bvar .zero
| succ h => exact (ih h).weak henv | case bvar.succ
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
i : Nat
ty : VExpr
h : Lookup (A✝ :: Γ✝) i ty
⊢ IsDefEq 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
i : Nat
ty : VExpr
h : Lookup (A✝ :: Γ✝) i ty
⊢ IsDefEq 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/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | simp | case bvar.succ.succ
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq 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/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | rw [Nat.add_comm, ← VExpr.liftN_instN_lo (hj := Nat.zero_le _)] | case bvar.succ.succ
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq env U (inst A✝ e₀ k✝ :: Γ'✝) (lift (instVar n✝ e₀ k✝)) (lift (instVar n✝ e₀ k✝)) (inst (lift ty✝) e₀ (k✝ + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .bvar .zero | case bvar.succ.zero
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
⊢ IsDefEq env U (inst A✝ e₀ k✝ :: Γ'✝) (VExpr.bvar 0) (VExpr.bvar 0) (liftN 1 (inst A✝ e₀ k✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ.zero
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
⊢ IsDefEq env U (inst A✝ e₀ k✝ :: Γ'✝) (VExpr.bvar 0) (VExpr.bvar 0) (liftN 1 (inst A✝ e₀ k✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact (ih h).weak henv | case bvar.succ.succ
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq env U (inst A✝ e₀ k✝ :: Γ'✝) (lift (instVar n✝ e₀ k✝)) (lift (instVar n✝ e₀ k✝)) (liftN 1 (inst ty✝ e₀ k✝)) | no goals | 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₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ e₀ A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat} {ty : VExpr}, Lookup Γ✝ i ty → IsDefEq env U Γ'✝ (instVar i e₀ k✝) (instVar i e₀ k✝) (inst ty e₀ k✝)
n✝ : Nat
ty✝ : VExpr
h : Lookup Γ✝ n✝ ty✝
⊢ IsDefEq env U (inst A✝ e₀ k✝ :: Γ'✝) (lift (instVar n✝ e₀ k✝)) (lift (instVar n✝ e₀ k✝)) (liftN 1 (inst ty✝ e₀ k✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .symm (ih W) | case symm
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e'✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst e'✝ e₀ k) (inst e✝ e₀ k) (inst A✝ e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e'✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst e'✝ e₀ k) (inst e✝ e₀ k) (inst A✝ e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .trans (ih1 W) (ih2 W) | case trans
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e₁✝ e₀ k) (inst e₂✝ e₀ k) (inst A✝ e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e₂✝ e₀ k) (inst e₃✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst e₁✝ e₀ k) (inst e₃✝ e₀ k) (inst A✝ e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e₁✝ e₀ k) (inst e₂✝ e₀ k) (inst A✝ e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e₂✝ e₀ k) (inst e₃✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst e₁✝ e₀ k) (inst e₃✝ e₀ k) (inst A✝ e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .sortDF h1 h2 h3 | case sortDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.sort l✝) e₀ k) (inst (VExpr.sort l'✝) e₀ k) (inst (VExpr.sort (VLevel.succ l✝)) e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.sort l✝) e₀ k) (inst (VExpr.sort l'✝) e₀ k) (inst (VExpr.sort (VLevel.succ l✝)) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | rw [(henv.closedC h1).instL.instN_eq (Nat.zero_le _)] | case constDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.const c✝ ls✝) e₀ k) (inst (VExpr.const c✝ ls'✝) e₀ k)
(inst (VExpr.instL ls✝ ci✝.type) e₀ k) | case constDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.const c✝ ls✝) e₀ k) (inst (VExpr.const c✝ ls'✝) e₀ k) (VExpr.instL ls✝ ci✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.const c✝ ls✝) e₀ k) (inst (VExpr.const c✝ ls'✝) e₀ k)
(inst (VExpr.instL ls✝ ci✝.type) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .constDF h1 h2 h3 h4 h5 | case constDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.const c✝ ls✝) e₀ k) (inst (VExpr.const c✝ ls'✝) e₀ k) (VExpr.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
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.const c✝ ls✝) e₀ k) (inst (VExpr.const c✝ ls'✝) e₀ k) (VExpr.instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact VExpr.inst_inst_hi .. ▸ .appDF (ih1 W) (ih2 W) | case appDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst f✝ e₀ k) (inst f'✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst a✝² e₀ k) (inst a'✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (app f✝ a✝²) e₀ k) (inst (app f'✝ a'✝) e₀ k) (inst (inst B✝ a✝²) e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst f✝ e₀ k) (inst f'✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst a✝² e₀ k) (inst a'✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (app f✝ a✝²) e₀ k) (inst (app f'✝ a'✝) e₀ k) (inst (inst B✝ a✝²) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .lamDF (ih1 W) (ih2 W.succ) | case lamDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst A✝ e₀ k) (inst A'✝ e₀ k) (inst (VExpr.sort u✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k (A✝ :: Γ✝) Γ → IsDefEq env U Γ (inst body✝ e₀ k) (inst body'✝ e₀ k) (inst B✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (lam A✝ body✝) e₀ k) (inst (lam A'✝ body'✝) e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst A✝ e₀ k) (inst A'✝ e₀ k) (inst (VExpr.sort u✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k (A✝ :: Γ✝) Γ → IsDefEq env U Γ (inst body✝ e₀ k) (inst body'✝ e₀ k) (inst B✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (lam A✝ body✝) e₀ k) (inst (lam A'✝ body'✝) e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .forallEDF (ih1 W) (ih2 W.succ) | case forallEDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst A✝ e₀ k) (inst A'✝ e₀ k) (inst (VExpr.sort u✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k (A✝ :: Γ✝) Γ → IsDefEq env U Γ (inst body✝ e₀ k) (inst body'✝ e₀ k) (inst (VExpr.sort v✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.forallE A✝ body✝) e₀ k) (inst (VExpr.forallE A'✝ body'✝) e₀ k)
(inst (VExpr.sort (VLevel.imax u✝ v✝)) e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst A✝ e₀ k) (inst A'✝ e₀ k) (inst (VExpr.sort u✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k (A✝ :: Γ✝) Γ → IsDefEq env U Γ (inst body✝ e₀ k) (inst body'✝ e₀ k) (inst (VExpr.sort v✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.forallE A✝ body✝) e₀ k) (inst (VExpr.forallE A'✝ body'✝) e₀ k)
(inst (VExpr.sort (VLevel.imax u✝ v✝)) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .defeqDF (ih1 W) (ih2 W) | case defeqDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst A✝ e₀ k) (inst B✝ e₀ k) (inst (VExpr.sort u✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e1✝ e₀ k) (inst e2✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst e1✝ e₀ k) (inst e2✝ e₀ k) (inst B✝ e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst A✝ e₀ k) (inst B✝ e₀ k) (inst (VExpr.sort u✝) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e1✝ e₀ k) (inst e2✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst e1✝ e₀ k) (inst e2✝ e₀ k) (inst B✝ e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact VExpr.inst_inst_hi .. ▸ VExpr.inst_inst_hi .. ▸ .beta (ih1 W.succ) (ih2 W) | case beta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k (A✝ :: Γ✝) Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst B✝ e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e'✝ e₀ k) (inst e'✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (app (lam A✝ e✝) e'✝) e₀ k) (inst (inst e✝ e'✝) e₀ k) (inst (inst B✝ e'✝) e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k (A✝ :: Γ✝) Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst B✝ e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e'✝ e₀ k) (inst e'✝ e₀ k) (inst A✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (app (lam A✝ e✝) e'✝) e₀ k) (inst (inst e✝ e'✝) e₀ k) (inst (inst B✝ e'✝) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | have := IsDefEq.eta (ih W) | case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k) | case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
this :
IsDefEq env U Γ (lam (inst A✝ e₀ k) (app (lift (inst e✝ e₀ k)) (VExpr.bvar 0))) (inst e✝ e₀ k)
(VExpr.forallE (inst A✝ e₀ k) (inst B✝ e₀ (k + 1)))
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | rw [lift, VExpr.liftN_instN_lo (hj := Nat.zero_le _), Nat.add_comm] at this | case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
this :
IsDefEq env U Γ (lam (inst A✝ e₀ k) (app (lift (inst e✝ e₀ k)) (VExpr.bvar 0))) (inst e✝ e₀ k)
(VExpr.forallE (inst A✝ e₀ k) (inst B✝ e₀ (k + 1)))
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k) | case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
this :
IsDefEq env U Γ (lam (inst A✝ e₀ k) (app (inst (liftN 1 e✝) e₀ (k + 1)) (VExpr.bvar 0))) (inst e✝ e₀ k)
(VExpr.forallE (inst A✝ e₀ k) (inst B✝ e₀ (k + 1)))
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
this :
IsDefEq env U Γ (lam (inst A✝ e₀ k) (app (lift (inst e✝ e₀ k)) (VExpr.bvar 0))) (inst e✝ e₀ k)
(VExpr.forallE (inst A✝ e₀ k) (inst B✝ e₀ (k + 1)))
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | simpa [inst] | case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
this :
IsDefEq env U Γ (lam (inst A✝ e₀ k) (app (inst (liftN 1 e✝) e₀ (k + 1)) (VExpr.bvar 0))) (inst e✝ e₀ k)
(VExpr.forallE (inst A✝ e₀ k) (inst B✝ e₀ (k + 1)))
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst e✝ e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
this :
IsDefEq env U Γ (lam (inst A✝ e₀ k) (app (inst (liftN 1 e✝) e₀ (k + 1)) (VExpr.bvar 0))) (inst e✝ e₀ k)
(VExpr.forallE (inst A✝ e₀ k) (inst B✝ e₀ (k + 1)))
⊢ IsDefEq env U Γ (inst (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e₀ k) (inst e✝ e₀ k) (inst (VExpr.forallE A✝ B✝) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .proofIrrel (ih1 W) (ih2 W) (ih3 W) | case proofIrrel
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst p✝ e₀ k) (inst p✝ e₀ k) (inst (VExpr.sort VLevel.zero) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst h✝ e₀ k) (inst h✝ e₀ k) (inst p✝ e₀ k)
ih3 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst h'✝ e₀ k) (inst h'✝ e₀ k) (inst p✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst h✝ e₀ k) (inst h'✝ e₀ k) (inst p✝ e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
ih1 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst p✝ e₀ k) (inst p✝ e₀ k) (inst (VExpr.sort VLevel.zero) e₀ k)
ih2 :
∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst h✝ e₀ k) (inst h✝ e₀ k) (inst p✝ e₀ k)
ih3 :
∀ {k : Nat} {Γ : List VExpr},
Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ → IsDefEq env U Γ (inst h'✝ e₀ k) (inst h'✝ e₀ k) (inst p✝ e₀ k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst h✝ e₀ k) (inst h'✝ e₀ k) (inst p✝ e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | have ⟨⟨hA1, _⟩, hA2, hA3⟩ := henv.closed.2 h1 | case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.instL ls✝ df✝.lhs) e₀ k) (inst (VExpr.instL ls✝ df✝.rhs) e₀ k)
(inst (VExpr.instL ls✝ df✝.type) e₀ k) | case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ (inst (VExpr.instL ls✝ df✝.lhs) e₀ k) (inst (VExpr.instL ls✝ df✝.rhs) e₀ k)
(inst (VExpr.instL ls✝ df✝.type) e₀ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.instL ls✝ df✝.lhs) e₀ k) (inst (VExpr.instL ls✝ df✝.rhs) e₀ k)
(inst (VExpr.instL ls✝ df✝.type) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | rw [
hA1.instL.instN_eq (Nat.zero_le _),
hA2.instL.instN_eq (Nat.zero_le _),
hA3.instL.instN_eq (Nat.zero_le _)] | case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ (inst (VExpr.instL ls✝ df✝.lhs) e₀ k) (inst (VExpr.instL ls✝ df✝.rhs) e₀ k)
(inst (VExpr.instL ls✝ df✝.type) e₀ k) | case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ (inst (VExpr.instL ls✝ df✝.lhs) e₀ k) (inst (VExpr.instL ls✝ df✝.rhs) e₀ k)
(inst (VExpr.instL ls✝ df✝.type) e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact .extra h1 h2 h3 | case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | have ⟨_, H1, H2⟩ : ∃ Γ', Ctx.LiftN 1 (Δ.length + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) Δ.length Γ' (Δ ++ A' :: Γ) := by
clear h1 h2
induction Δ with
| nil => exact ⟨_, .succ (.one (A := A')), .zero⟩
| cons B Δ ih =>
have ⟨Γ', h1, h2⟩ := ih
exact ⟨_, .succ h1, by simpa [instN_bvar0] using h2.succ (A := liftN 1 B (Δ.length + 1))⟩ | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
⊢ IsDefEq env U (Δ ++ A' :: Γ) e1 e2 B | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
w✝ : List VExpr
H1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) w✝
H2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) w✝ (Δ ++ A' :: Γ)
⊢ IsDefEq env U (Δ ++ A' :: Γ) e1 e2 B | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
⊢ IsDefEq env U (Δ ++ A' :: Γ) e1 e2 B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | simpa [instN_bvar0] using
instN henv (h1.weakN henv (.one (A := A')) |>.symm.defeq (.bvar .zero)) H2 (.weakN henv H1 h2) | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
w✝ : List VExpr
H1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) w✝
H2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) w✝ (Δ ++ A' :: Γ)
⊢ IsDefEq env U (Δ ++ A' :: Γ) e1 e2 B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
w✝ : List VExpr
H1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) w✝
H2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) w✝ (Δ ++ A' :: Γ)
⊢ IsDefEq env U (Δ ++ A' :: Γ) e1 e2 B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | clear h1 h2 | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ) | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
h1 : IsDefEq env U Γ A A' (VExpr.sort u)
h2 : IsDefEq env U (Δ ++ A :: Γ) e1 e2 B
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | induction Δ with
| nil => exact ⟨_, .succ (.one (A := A')), .zero⟩
| cons B Δ ih =>
have ⟨Γ', h1, h2⟩ := ih
exact ⟨_, .succ h1, by simpa [instN_bvar0] using h2.succ (A := liftN 1 B (Δ.length + 1))⟩ | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
Δ : List VExpr
e1 e2 B : VExpr
henv : Ordered env
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | exact ⟨_, .succ (.one (A := A')), .zero⟩ | case nil
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B : VExpr
henv : Ordered env
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length [] + 1) ([] ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length []) Γ' ([] ++ A' :: Γ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B : VExpr
henv : Ordered env
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length [] + 1) ([] ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length []) Γ' ([] ++ A' :: Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | have ⟨Γ', h1, h2⟩ := ih | case cons
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length (B :: Δ) + 1) (B :: Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) Γ' (B :: Δ ++ A' :: Γ) | case cons
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
Γ' : List VExpr
h1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ'
h2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length (B :: Δ) + 1) (B :: Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) Γ' (B :: Δ ++ A' :: Γ) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length (B :: Δ) + 1) (B :: Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) Γ' (B :: Δ ++ A' :: Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | exact ⟨_, .succ h1, by simpa [instN_bvar0] using h2.succ (A := liftN 1 B (Δ.length + 1))⟩ | case cons
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
Γ' : List VExpr
h1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ'
h2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length (B :: Δ) + 1) (B :: Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) Γ' (B :: Δ ++ A' :: Γ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
Γ' : List VExpr
h1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ'
h2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ ∃ Γ',
Ctx.LiftN 1 (List.length (B :: Δ) + 1) (B :: Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) Γ' (B :: Δ ++ A' :: Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDF_l' | [616, 1] | [627, 99] | simpa [instN_bvar0] using h2.succ (A := liftN 1 B (Δ.length + 1)) | env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
Γ' : List VExpr
h1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ'
h2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) (liftN 1 B (List.length (B :: Δ)) :: Γ')
(B :: Δ ++ A' :: Γ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
A A' : VExpr
u : VLevel
e1 e2 B✝ : VExpr
henv : Ordered env
B : VExpr
Δ : List VExpr
ih :
∃ Γ',
Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ' ∧
Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
Γ' : List VExpr
h1 : Ctx.LiftN 1 (List.length Δ + 1) (Δ ++ A :: Γ) Γ'
h2 : Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length Δ) Γ' (Δ ++ A' :: Γ)
⊢ Ctx.InstN (A' :: Γ) (VExpr.bvar 0) (liftN 1 A) (List.length (B :: Δ)) (liftN 1 B (List.length (B :: Δ)) :: Γ')
(B :: Δ ++ A' :: Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDFC' | [636, 1] | [641, 75] | induction h1 generalizing e₁ e₂ A Δ with
| zero => exact h2
| @succ _ _ _ A₂ _ _ AA ih =>
simpa using ih (Δ := Δ ++ [A₂]) (by simpa using AA.defeqDF_l' henv h2) | env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ Δ : List VExpr
e₁ e₂ A : VExpr
henv : Ordered env
h1 : IsDefEqCtx env U Γ₀ Γ₁ Γ₂
h2 : 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:
env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ Δ : List VExpr
e₁ e₂ A : VExpr
henv : Ordered env
h1 : IsDefEqCtx env U Γ₀ Γ₁ Γ₂
h2 : IsDefEq env U (Δ ++ Γ₁) e₁ e₂ A
⊢ IsDefEq env U (Δ ++ Γ₂) e₁ e₂ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDFC' | [636, 1] | [641, 75] | exact h2 | case zero
env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ : List VExpr
henv : Ordered env
Δ : List VExpr
e₁ e₂ A : VExpr
h2 : 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 zero
env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ : List VExpr
henv : Ordered env
Δ : List VExpr
e₁ e₂ A : VExpr
h2 : IsDefEq env U (Δ ++ Γ₀) e₁ e₂ A
⊢ IsDefEq env U (Δ ++ Γ₀) e₁ e₂ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDFC' | [636, 1] | [641, 75] | simpa using ih (Δ := Δ ++ [A₂]) (by simpa using AA.defeqDF_l' henv h2) | case succ
env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ : List VExpr
henv : Ordered env
Γ₁✝ Γ₂✝ : List VExpr
A₁✝ A₂ : VExpr
u✝ : VLevel
a✝ : IsDefEqCtx env U Γ₀ Γ₁✝ Γ₂✝
AA : IsDefEq env U Γ₁✝ A₁✝ A₂ (VExpr.sort u✝)
ih : ∀ {Δ : List VExpr} {e₁ e₂ A : VExpr}, IsDefEq env U (Δ ++ Γ₁✝) e₁ e₂ A → IsDefEq env U (Δ ++ Γ₂✝) e₁ e₂ A
Δ : List VExpr
e₁ e₂ A : VExpr
h2 : IsDefEq env U (Δ ++ A₁✝ :: Γ₁✝) e₁ e₂ A
⊢ IsDefEq env U (Δ ++ A₂ :: Γ₂✝) e₁ e₂ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ : List VExpr
henv : Ordered env
Γ₁✝ Γ₂✝ : List VExpr
A₁✝ A₂ : VExpr
u✝ : VLevel
a✝ : IsDefEqCtx env U Γ₀ Γ₁✝ Γ₂✝
AA : IsDefEq env U Γ₁✝ A₁✝ A₂ (VExpr.sort u✝)
ih : ∀ {Δ : List VExpr} {e₁ e₂ A : VExpr}, IsDefEq env U (Δ ++ Γ₁✝) e₁ e₂ A → IsDefEq env U (Δ ++ Γ₂✝) e₁ e₂ A
Δ : List VExpr
e₁ e₂ A : VExpr
h2 : IsDefEq env U (Δ ++ A₁✝ :: Γ₁✝) e₁ e₂ A
⊢ IsDefEq env U (Δ ++ A₂ :: Γ₂✝) e₁ e₂ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.defeqDFC' | [636, 1] | [641, 75] | simpa using AA.defeqDF_l' henv h2 | env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ : List VExpr
henv : Ordered env
Γ₁✝ Γ₂✝ : List VExpr
A₁✝ A₂ : VExpr
u✝ : VLevel
a✝ : IsDefEqCtx env U Γ₀ Γ₁✝ Γ₂✝
AA : IsDefEq env U Γ₁✝ A₁✝ A₂ (VExpr.sort u✝)
ih : ∀ {Δ : List VExpr} {e₁ e₂ A : VExpr}, IsDefEq env U (Δ ++ Γ₁✝) e₁ e₂ A → IsDefEq env U (Δ ++ Γ₂✝) e₁ e₂ A
Δ : List VExpr
e₁ e₂ A : VExpr
h2 : IsDefEq env U (Δ ++ A₁✝ :: Γ₁✝) e₁ e₂ A
⊢ IsDefEq env U (Δ ++ [A₂] ++ Γ₁✝) e₁ e₂ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ₀ Γ₁ Γ₂ : List VExpr
henv : Ordered env
Γ₁✝ Γ₂✝ : List VExpr
A₁✝ A₂ : VExpr
u✝ : VLevel
a✝ : IsDefEqCtx env U Γ₀ Γ₁✝ Γ₂✝
AA : IsDefEq env U Γ₁✝ A₁✝ A₂ (VExpr.sort u✝)
ih : ∀ {Δ : List VExpr} {e₁ e₂ A : VExpr}, IsDefEq env U (Δ ++ Γ₁✝) e₁ e₂ A → IsDefEq env U (Δ ++ Γ₂✝) e₁ e₂ A
Δ : List VExpr
e₁ e₂ A : VExpr
h2 : IsDefEq env U (Δ ++ A₁✝ :: Γ₁✝) e₁ e₂ A
⊢ IsDefEq env U (Δ ++ [A₂] ++ Γ₁✝) e₁ e₂ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ih eq.symm | case symm
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e'✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e'✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | obtain eq | eq := eq | case proofIrrel
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | case proofIrrel.inl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
case proofIrrel.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ih1 (.inl eq) | case proofIrrel.inl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel.inl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ih2 (.inr eq) | case proofIrrel.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝ : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
h1 : IsDefEq env U Γ✝ h✝ h✝ p✝
h2 : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : ∀ {A B : VExpr}, p✝ = VExpr.forallE A B ∨ p✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih1 : ∀ {A B : VExpr}, h✝ = VExpr.forallE A B ∨ h✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, h'✝ = VExpr.forallE A B ∨ h'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : h'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | obtain ⟨⟨⟩⟩ | ⟨⟨⟩⟩ := eq | case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
A B : VExpr
eq : VExpr.forallE A✝ body✝ = VExpr.forallE A B ∨ VExpr.forallE A'✝ body'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | case forallEDF.inl.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ A✝ ∧ IsType env U (A✝ :: Γ✝) body✝
case forallEDF.inr.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ A'✝ ∧ IsType env U (A'✝ :: Γ✝) body'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
A B : VExpr
eq : VExpr.forallE A✝ body✝ = VExpr.forallE A B ∨ VExpr.forallE A'✝ body'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ⟨⟨_, h1.hasType.1⟩, _, h2.hasType.1⟩ | case forallEDF.inl.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ A✝ ∧ IsType env U (A✝ :: Γ✝) body✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF.inl.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ A✝ ∧ IsType env U (A✝ :: Γ✝) body✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ⟨⟨_, h1.hasType.2⟩, _, h2.hasType.2.defeq_l henv h1⟩ | case forallEDF.inr.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ A'✝ ∧ IsType env U (A'✝ :: Γ✝) body'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF.inr.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
h1 : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
h2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ A'✝ ∧ IsType env U (A'✝ :: Γ✝) body'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ih2 eq | case defeqDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
a_ih✝ : ∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ B✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e1✝ = VExpr.forallE A B ∨ e2✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e1✝ = VExpr.forallE A B ∨ e2✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) 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 x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
a_ih✝ : ∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ B✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e1✝ = VExpr.forallE A B ∨ e2✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e1✝ = VExpr.forallE A B ∨ e2✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | obtain ⟨⟨⟩⟩ | eq := eq | case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {A B : VExpr},
e = VExpr.forallE A B ∨ e = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : app (lam A✝ e) e'✝ = VExpr.forallE A B ∨ inst e e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | case beta.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {A B : VExpr},
e = VExpr.forallE A B ∨ e = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : inst e e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {A B : VExpr},
e = VExpr.forallE A B ∨ e = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : app (lam A✝ e) e'✝ = VExpr.forallE A B ∨ inst e e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | cases e with
| bvar i =>
cases i with simp [inst] at eq
| zero => exact ih2 (.inl eq)
| forallE A B =>
cases eq
let ⟨A1, A2⟩ := ih1 (.inl rfl)
exact ⟨A1.instN henv .zero h2, A2.instN henv (.succ .zero) h2⟩
| _ => cases eq | case beta.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {A B : VExpr},
e = VExpr.forallE A B ∨ e = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : inst e e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
∀ {A B : VExpr},
e = VExpr.forallE A B ∨ e = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : inst e e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | cases i with simp [inst] at eq
| zero => exact ih2 (.inl eq) | case beta.inr.bvar
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
i : Nat
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar i) (VExpr.bvar i) B✝
ih1 :
∀ {A B : VExpr},
VExpr.bvar i = VExpr.forallE A B ∨ VExpr.bvar i = VExpr.forallE A B →
IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
eq : inst (VExpr.bvar i) e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.bvar
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
i : Nat
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar i) (VExpr.bvar i) B✝
ih1 :
∀ {A B : VExpr},
VExpr.bvar i = VExpr.forallE A B ∨ VExpr.bvar i = VExpr.forallE A B →
IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
eq : inst (VExpr.bvar i) e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ih2 (.inl eq) | case beta.inr.bvar.zero
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar Nat.zero) (VExpr.bvar Nat.zero) B✝
ih1 :
∀ {A B : VExpr},
VExpr.bvar Nat.zero = VExpr.forallE A B ∨ VExpr.bvar Nat.zero = VExpr.forallE A B →
IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
eq : e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.bvar.zero
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar Nat.zero) (VExpr.bvar Nat.zero) B✝
ih1 :
∀ {A B : VExpr},
VExpr.bvar Nat.zero = VExpr.forallE A B ∨ VExpr.bvar Nat.zero = VExpr.forallE A B →
IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
eq : e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | cases eq | case beta.inr.forallE
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝¹ : VExpr
Γ✝ : List VExpr
B✝¹ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝¹
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A✝ B✝ A B : VExpr
h1 : IsDefEq env U (A✝¹ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝¹
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝¹ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝¹ :: Γ✝) B_1
eq : inst (VExpr.forallE A B) e'✝ = VExpr.forallE A✝ B✝
⊢ IsType env U Γ✝ A✝ ∧ IsType env U (A✝ :: Γ✝) B✝ | case beta.inr.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝ :: Γ✝) B_1
⊢ IsType env U Γ✝ (inst A e'✝) ∧ IsType env U (inst A e'✝ :: Γ✝) (inst B e'✝ (0 + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.forallE
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝¹ : VExpr
Γ✝ : List VExpr
B✝¹ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝¹
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A✝ B✝ A B : VExpr
h1 : IsDefEq env U (A✝¹ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝¹
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝¹ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝¹ :: Γ✝) B_1
eq : inst (VExpr.forallE A B) e'✝ = VExpr.forallE A✝ B✝
⊢ IsType env U Γ✝ A✝ ∧ IsType env U (A✝ :: Γ✝) B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | let ⟨A1, A2⟩ := ih1 (.inl rfl) | case beta.inr.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝ :: Γ✝) B_1
⊢ IsType env U Γ✝ (inst A e'✝) ∧ IsType env U (inst A e'✝ :: Γ✝) (inst B e'✝ (0 + 1)) | case beta.inr.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝ :: Γ✝) B_1
A1 : IsType env U (A✝ :: Γ✝) A
A2 : IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ (inst A e'✝) ∧ IsType env U (inst A e'✝ :: Γ✝) (inst B e'✝ (0 + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝ :: Γ✝) B_1
⊢ IsType env U Γ✝ (inst A e'✝) ∧ IsType env U (inst A e'✝ :: Γ✝) (inst B e'✝ (0 + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ⟨A1.instN henv .zero h2, A2.instN henv (.succ .zero) h2⟩ | case beta.inr.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝ :: Γ✝) B_1
A1 : IsType env U (A✝ :: Γ✝) A
A2 : IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ (inst A e'✝) ∧ IsType env U (inst A e'✝ :: Γ✝) (inst B e'✝ (0 + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE A B) (VExpr.forallE A B) B✝
ih1 :
∀ {A_1 B_1 : VExpr},
VExpr.forallE A B = VExpr.forallE A_1 B_1 ∨ VExpr.forallE A B = VExpr.forallE A_1 B_1 →
IsType env U (A✝ :: Γ✝) A_1 ∧ IsType env U (A_1 :: A✝ :: Γ✝) B_1
A1 : IsType env U (A✝ :: Γ✝) A
A2 : IsType env U (A :: A✝ :: Γ✝) B
⊢ IsType env U Γ✝ (inst A e'✝) ∧ IsType env U (inst A e'✝ :: Γ✝) (inst B e'✝ (0 + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | cases eq | case beta.inr.lam
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B binderType✝ body✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (lam binderType✝ body✝) (lam binderType✝ body✝) B✝
ih1 :
∀ {A B : VExpr},
lam binderType✝ body✝ = VExpr.forallE A B ∨ lam binderType✝ body✝ = VExpr.forallE A B →
IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
eq : inst (lam binderType✝ body✝) e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.lam
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
h2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : ∀ {A B : VExpr}, e'✝ = VExpr.forallE A B ∨ e'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B binderType✝ body✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (lam binderType✝ body✝) (lam binderType✝ body✝) B✝
ih1 :
∀ {A B : VExpr},
lam binderType✝ body✝ = VExpr.forallE A B ∨ lam binderType✝ body✝ = VExpr.forallE A B →
IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
eq : inst (lam binderType✝ body✝) e'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | obtain ⟨⟨⟩⟩ | eq := eq | case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : lam A✝ (app (lift e✝) (VExpr.bvar 0)) = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | case eta.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : lam A✝ (app (lift e✝) (VExpr.bvar 0)) = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact ih (.inl eq) | case eta.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.inr
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : ∀ {A B : VExpr}, e✝ = VExpr.forallE A B ∨ e✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
A B : VExpr
eq : e✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | suffices ∀ e, VExpr.instL ls e = VExpr.forallE A B →
(∀ A B, e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B by
have ⟨A1, A2⟩ := envIH.2 h1
cases eq <;> exact this _ ‹_› ‹_› | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
⊢ ∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | intro e eq IH | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
⊢ ∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq✝ : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
e : VExpr
eq : VExpr.instL ls e = VExpr.forallE A B
IH : ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
⊢ ∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | cases e <;> cases eq | case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq✝ : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
e : VExpr
eq : VExpr.instL ls e = VExpr.forallE A B
IH : ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
binderType✝ body✝ : VExpr
IH :
∀ (A B : VExpr),
VExpr.forallE binderType✝ body✝ = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls binderType✝) (VExpr.instL ls body✝) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls binderType✝) (VExpr.instL ls body✝)
⊢ IsType env U Γ (VExpr.instL ls binderType✝) ∧ IsType env U (VExpr.instL ls binderType✝ :: Γ) (VExpr.instL ls body✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq✝ : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
e : VExpr
eq : VExpr.instL ls e = VExpr.forallE A B
IH : ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | rename_i A B | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
binderType✝ body✝ : VExpr
IH :
∀ (A B : VExpr),
VExpr.forallE binderType✝ body✝ = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls binderType✝) (VExpr.instL ls body✝) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls binderType✝) (VExpr.instL ls body✝)
⊢ IsType env U Γ (VExpr.instL ls binderType✝) ∧ IsType env U (VExpr.instL ls binderType✝ :: Γ) (VExpr.instL ls body✝) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
⊢ IsType env U Γ (VExpr.instL ls A) ∧ IsType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
binderType✝ body✝ : VExpr
IH :
∀ (A B : VExpr),
VExpr.forallE binderType✝ body✝ = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls binderType✝) (VExpr.instL ls body✝) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls binderType✝) (VExpr.instL ls body✝)
⊢ IsType env U Γ (VExpr.instL ls binderType✝) ∧ IsType env U (VExpr.instL ls binderType✝ :: Γ) (VExpr.instL ls body✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | let ⟨⟨_, A1⟩, v, A2⟩ := IH _ _ rfl | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
⊢ IsType env U Γ (VExpr.instL ls A) ∧ IsType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
⊢ IsType env U Γ (VExpr.instL ls A) ∧ IsType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
⊢ IsType env U Γ (VExpr.instL ls A) ∧ IsType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | refine ⟨⟨_, (A1.instL h2).weak0 henv⟩, v.inst ls, ?_⟩ | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
⊢ IsType env U Γ (VExpr.instL ls A) ∧ IsType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
⊢ IsType env U Γ (VExpr.instL ls A) ∧ IsType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | have := (A2.instL h2).weakN henv (.succ (.zero Γ)) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | have C1 := (A1.instL h2).closedN henv ⟨⟩ | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | have C2 := (A2.instL h2).closedN henv ⟨⟨⟩, C1⟩ | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | rw [C1.liftN_eq (Nat.zero_le _), C2.liftN_eq (by exact Nat.le_refl _)] at this | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (VExpr.instL ls A :: (Γ ++ List.map (VExpr.instL ls) [])) (VExpr.instL ls B)
(liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (liftN (List.length Γ) (VExpr.instL ls A) :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | simpa [liftN] | case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (VExpr.instL ls A :: (Γ ++ List.map (VExpr.instL ls) [])) (VExpr.instL ls B)
(liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.forallE.refl
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (VExpr.instL ls A :: (Γ ++ List.map (VExpr.instL ls) [])) (VExpr.instL ls B)
(liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ HasType env U (VExpr.instL ls A :: Γ) (VExpr.instL ls B) (VExpr.sort (VLevel.inst ls v))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | have ⟨A1, A2⟩ := envIH.2 h1 | env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
this :
∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
this :
∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B
A1 :
(fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B) df.uvars df.lhs df.type
A2 :
(fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B) df.uvars df.rhs df.type
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
this :
∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | cases eq <;> exact this _ ‹_› ‹_› | env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
this :
∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B
A1 :
(fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B) df.uvars df.lhs df.type
A2 :
(fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B) df.uvars df.rhs df.type
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
eq : VExpr.instL ls df.lhs = VExpr.forallE A B ∨ VExpr.instL ls df.rhs = VExpr.forallE A B
this :
∀ (e : VExpr),
VExpr.instL ls e = VExpr.forallE A B →
(∀ (A B : VExpr), e = VExpr.forallE A B → IsType env df.uvars [] A ∧ IsType env df.uvars [A] B) →
IsType env U Γ A ∧ IsType env U (A :: Γ) B
A1 :
(fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B) df.uvars df.lhs df.type
A2 :
(fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B) df.uvars df.rhs df.type
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | exact Nat.le_refl _ | env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (VExpr.instL ls A :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ List.length (List.map (VExpr.instL ls) [A]) ≤ 0 + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ✝ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
A B : VExpr
IH :
∀ (A_1 B_1 : VExpr),
VExpr.forallE A B = VExpr.forallE A_1 B_1 → IsType env df.uvars [] A_1 ∧ IsType env df.uvars [A_1] B_1
eq :
VExpr.instL ls df.lhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B) ∨
VExpr.instL ls df.rhs = VExpr.forallE (VExpr.instL ls A) (VExpr.instL ls B)
w✝ : VLevel
A1 : HasType env df.uvars [] A (VExpr.sort w✝)
v : VLevel
A2 : HasType env df.uvars [A] B (VExpr.sort v)
this :
HasType env U (VExpr.instL ls A :: (Γ ++ List.map (VExpr.instL ls) []))
(liftN (List.length Γ) (VExpr.instL ls B) (0 + 1)) (liftN (List.length Γ) (VExpr.instL ls (VExpr.sort v)) (0 + 1))
C1 : ClosedN (VExpr.instL ls A) (List.length (List.map (VExpr.instL ls) []))
C2 : ClosedN (VExpr.instL ls B) (List.length (List.map (VExpr.instL ls) [A]))
⊢ List.length (List.map (VExpr.instL ls) [A]) ≤ 0 + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.forallE_inv' | [657, 1] | [701, 20] | nomatch eq | case lamDF
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
A B : VExpr
eq : lam A✝ body✝ = VExpr.forallE A B ∨ lam A'✝ body'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (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 x => ∀ (A B : VExpr), e = VExpr.forallE A B → IsType env U [] A ∧ IsType env U [A] B
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
a_ih✝¹ :
∀ {A B : VExpr}, A✝ = VExpr.forallE A B ∨ A'✝ = VExpr.forallE A B → IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
a_ih✝ :
∀ {A B : VExpr},
body✝ = VExpr.forallE A B ∨ body'✝ = VExpr.forallE A B → IsType env U (A✝ :: Γ✝) A ∧ IsType env U (A :: A✝ :: Γ✝) B
A B : VExpr
eq : lam A✝ body✝ = VExpr.forallE A B ∨ lam A'✝ body'✝ = VExpr.forallE A B
⊢ IsType env U Γ✝ A ∧ IsType env U (A :: Γ✝) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.HasType.forallE_inv | [703, 1] | [709, 63] | refine H.forallE_inv' henv ?_ (.inl rfl) | env : VEnv
U : Nat
Γ : List VExpr
V A B : VExpr
henv : Ordered env
H : HasType env U Γ (forallE A B) V
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B | env : VEnv
U : Nat
Γ : List VExpr
V A B : VExpr
henv : Ordered env
H : HasType env U Γ (forallE A B) V
⊢ OnTypes env fun U e x => ∀ (A B : VExpr), e = forallE A B → IsType env U [] A ∧ IsType env U [A] B | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
V A B : VExpr
henv : Ordered env
H : HasType env U Γ (forallE A B) V
⊢ IsType env U Γ A ∧ IsType env U (A :: Γ) B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.HasType.forallE_inv | [703, 1] | [709, 63] | exact henv.induction
(fun env U e _ => ∀ A B, e = forallE A B → IsType env U [] A ∧ IsType env U [A] B)
(fun le H A B eq => (H A B eq).imp (.mono le) (.mono le))
(fun henv IH H A B eq => H.forallE_inv' henv IH (.inl eq)) | env : VEnv
U : Nat
Γ : List VExpr
V A B : VExpr
henv : Ordered env
H : HasType env U Γ (forallE A B) V
⊢ OnTypes env fun U e x => ∀ (A B : VExpr), e = forallE A B → IsType env U [] A ∧ IsType env U [A] B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
V A B : VExpr
henv : Ordered env
H : HasType env U Γ (forallE A B) V
⊢ OnTypes env fun U e x => ∀ (A B : VExpr), e = forallE A B → IsType env U [] A ∧ IsType env U [A] B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | induction H with
| symm _ ih => exact ih eq.symm
| trans _ _ ih1 ih2
| proofIrrel _ _ _ _ ih1 ih2 =>
obtain eq | eq := eq <;> [exact ih1 (.inl eq); exact ih2 (.inr eq)]
| sortDF => obtain ⟨⟨⟩⟩ | ⟨⟨⟩⟩ := eq <;> assumption
| defeqDF _ _ _ ih2 => exact ih2 eq
| @beta _ _ e _ _ h1 _ ih1 ih2 =>
obtain ⟨⟨⟩⟩ | eq := eq
cases e with
| bvar i =>
cases i with simp [inst] at eq
| zero => exact ih2 (.inl eq)
| _ => cases eq <;> exact ih1 (.inl rfl)
| eta _ ih =>
obtain ⟨⟨⟩⟩ | eq := eq
exact ih (.inl eq)
| @extra df ls _ h1 h2 =>
suffices ∀ e, VExpr.instL ls e = .sort u → HasType env df.uvars [] e df.type → u.WF U by
have ⟨A1, A2⟩ := henv.defEqWF h1
cases eq <;> exact this _ ‹_› ‹_›
intro e eq IH
cases e <;> cases eq; rename_i u
exact VLevel.WF.inst h2
| _ => nomatch eq | env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
H : IsDefEq env U Γ e1 e2 V
eq : e1 = VExpr.sort u ∨ e2 = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
H : IsDefEq env U Γ e1 e2 V
eq : e1 = VExpr.sort u ∨ e2 = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | exact ih eq.symm | case symm
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : e✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : e'✝ = VExpr.sort u ∨ e✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : e✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : e'✝ = VExpr.sort u ∨ e✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | obtain eq | eq := eq <;> [exact ih1 (.inl eq); exact ih2 (.inr eq)] | case proofIrrel
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : p✝ = VExpr.sort u ∨ p✝ = VExpr.sort u → VLevel.WF U u
ih1 : h✝ = VExpr.sort u ∨ h✝ = VExpr.sort u → VLevel.WF U u
ih2 : h'✝ = VExpr.sort u ∨ h'✝ = VExpr.sort u → VLevel.WF U u
eq : h✝ = VExpr.sort u ∨ h'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ : p✝ = VExpr.sort u ∨ p✝ = VExpr.sort u → VLevel.WF U u
ih1 : h✝ = VExpr.sort u ∨ h✝ = VExpr.sort u → VLevel.WF U u
ih2 : h'✝ = VExpr.sort u ∨ h'✝ = VExpr.sort u → VLevel.WF U u
eq : h✝ = VExpr.sort u ∨ h'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | obtain ⟨⟨⟩⟩ | ⟨⟨⟩⟩ := eq <;> assumption | case sortDF
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u l✝ l'✝ : VLevel
Γ✝ : List VExpr
a✝² : VLevel.WF U l✝
a✝¹ : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
eq : VExpr.sort l✝ = VExpr.sort u ∨ VExpr.sort l'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u l✝ l'✝ : VLevel
Γ✝ : List VExpr
a✝² : VLevel.WF U l✝
a✝¹ : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
eq : VExpr.sort l✝ = VExpr.sort u ∨ VExpr.sort l'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | exact ih2 eq | case defeqDF
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
a_ih✝ : A✝ = VExpr.sort u ∨ B✝ = VExpr.sort u → VLevel.WF U u
ih2 : e1✝ = VExpr.sort u ∨ e2✝ = VExpr.sort u → VLevel.WF U u
eq : e1✝ = VExpr.sort u ∨ e2✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
a_ih✝ : A✝ = VExpr.sort u ∨ B✝ = VExpr.sort u → VLevel.WF U u
ih2 : e1✝ = VExpr.sort u ∨ e2✝ = VExpr.sort u → VLevel.WF U u
eq : e1✝ = VExpr.sort u ∨ e2✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | obtain ⟨⟨⟩⟩ | eq := eq | case beta
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : e = VExpr.sort u ∨ e = VExpr.sort u → VLevel.WF U u
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : app (lam A✝ e) e'✝ = VExpr.sort u ∨ inst e e'✝ = VExpr.sort u
⊢ VLevel.WF U u | case beta.inr
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : e = VExpr.sort u ∨ e = VExpr.sort u → VLevel.WF U u
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : inst e e'✝ = VExpr.sort u
⊢ VLevel.WF U u | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : e = VExpr.sort u ∨ e = VExpr.sort u → VLevel.WF U u
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : app (lam A✝ e) e'✝ = VExpr.sort u ∨ inst e e'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | cases e with
| bvar i =>
cases i with simp [inst] at eq
| zero => exact ih2 (.inl eq)
| _ => cases eq <;> exact ih1 (.inl rfl) | case beta.inr
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : e = VExpr.sort u ∨ e = VExpr.sort u → VLevel.WF U u
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : inst e e'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
e B✝ e'✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) e e B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : e = VExpr.sort u ∨ e = VExpr.sort u → VLevel.WF U u
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
eq : inst e e'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | cases i with simp [inst] at eq
| zero => exact ih2 (.inl eq) | case beta.inr.bvar
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
i : Nat
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar i) (VExpr.bvar i) B✝
ih1 : VExpr.bvar i = VExpr.sort u ∨ VExpr.bvar i = VExpr.sort u → VLevel.WF U u
eq : inst (VExpr.bvar i) e'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.bvar
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
i : Nat
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar i) (VExpr.bvar i) B✝
ih1 : VExpr.bvar i = VExpr.sort u ∨ VExpr.bvar i = VExpr.sort u → VLevel.WF U u
eq : inst (VExpr.bvar i) e'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | exact ih2 (.inl eq) | case beta.inr.bvar.zero
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar Nat.zero) (VExpr.bvar Nat.zero) B✝
ih1 : VExpr.bvar Nat.zero = VExpr.sort u ∨ VExpr.bvar Nat.zero = VExpr.sort u → VLevel.WF U u
eq : e'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.bvar.zero
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.bvar Nat.zero) (VExpr.bvar Nat.zero) B✝
ih1 : VExpr.bvar Nat.zero = VExpr.sort u ∨ VExpr.bvar Nat.zero = VExpr.sort u → VLevel.WF U u
eq : e'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | cases eq <;> exact ih1 (.inl rfl) | case beta.inr.forallE
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
binderType✝ body✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE binderType✝ body✝) (VExpr.forallE binderType✝ body✝) B✝
ih1 : VExpr.forallE binderType✝ body✝ = VExpr.sort u ∨ VExpr.forallE binderType✝ body✝ = VExpr.sort u → VLevel.WF U u
eq : inst (VExpr.forallE binderType✝ body✝) e'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta.inr.forallE
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
A✝ : VExpr
Γ✝ : List VExpr
B✝ e'✝ : VExpr
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih2 : e'✝ = VExpr.sort u ∨ e'✝ = VExpr.sort u → VLevel.WF U u
binderType✝ body✝ : VExpr
h1 : IsDefEq env U (A✝ :: Γ✝) (VExpr.forallE binderType✝ body✝) (VExpr.forallE binderType✝ body✝) B✝
ih1 : VExpr.forallE binderType✝ body✝ = VExpr.sort u ∨ VExpr.forallE binderType✝ body✝ = VExpr.sort u → VLevel.WF U u
eq : inst (VExpr.forallE binderType✝ body✝) e'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | obtain ⟨⟨⟩⟩ | eq := eq | case eta
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : e✝ = VExpr.sort u ∨ e✝ = VExpr.sort u → VLevel.WF U u
eq : lam A✝ (app (lift e✝) (VExpr.bvar 0)) = VExpr.sort u ∨ e✝ = VExpr.sort u
⊢ VLevel.WF U u | case eta.inr
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : e✝ = VExpr.sort u ∨ e✝ = VExpr.sort u → VLevel.WF U u
eq : e✝ = VExpr.sort u
⊢ VLevel.WF U u | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : e✝ = VExpr.sort u ∨ e✝ = VExpr.sort u → VLevel.WF U u
eq : lam A✝ (app (lift e✝) (VExpr.bvar 0)) = VExpr.sort u ∨ e✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | exact ih (.inl eq) | case eta.inr
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : e✝ = VExpr.sort u ∨ e✝ = VExpr.sort u → VLevel.WF U u
eq : e✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta.inr
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : e✝ = VExpr.sort u ∨ e✝ = VExpr.sort u → VLevel.WF U u
eq : e✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | suffices ∀ e, VExpr.instL ls e = .sort u → HasType env df.uvars [] e df.type → u.WF U by
have ⟨A1, A2⟩ := henv.defEqWF h1
cases eq <;> exact this _ ‹_› ‹_› | case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
⊢ VLevel.WF U u | case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
⊢ ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | intro e eq IH | case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
⊢ ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u | case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq✝ : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
e : VExpr
eq : VExpr.instL ls e = VExpr.sort u
IH : HasType env df.uvars [] e df.type
⊢ VLevel.WF U u | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
⊢ ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | cases e <;> cases eq | case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq✝ : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
e : VExpr
eq : VExpr.instL ls e = VExpr.sort u
IH : HasType env df.uvars [] e df.type
⊢ VLevel.WF U u | case extra.sort.refl
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
u✝ : VLevel
IH : HasType env df.uvars [] (VExpr.sort u✝) df.type
eq : VExpr.instL ls df.lhs = VExpr.sort (VLevel.inst ls u✝) ∨ VExpr.instL ls df.rhs = VExpr.sort (VLevel.inst ls u✝)
⊢ VLevel.WF U (VLevel.inst ls u✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq✝ : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
e : VExpr
eq : VExpr.instL ls e = VExpr.sort u
IH : HasType env df.uvars [] e df.type
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | rename_i u | case extra.sort.refl
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
u✝ : VLevel
IH : HasType env df.uvars [] (VExpr.sort u✝) df.type
eq : VExpr.instL ls df.lhs = VExpr.sort (VLevel.inst ls u✝) ∨ VExpr.instL ls df.rhs = VExpr.sort (VLevel.inst ls u✝)
⊢ VLevel.WF U (VLevel.inst ls u✝) | case extra.sort.refl
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
u : VLevel
IH : HasType env df.uvars [] (VExpr.sort u) df.type
eq : VExpr.instL ls df.lhs = VExpr.sort (VLevel.inst ls u) ∨ VExpr.instL ls df.rhs = VExpr.sort (VLevel.inst ls u)
⊢ VLevel.WF U (VLevel.inst ls u) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.sort.refl
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
u✝ : VLevel
IH : HasType env df.uvars [] (VExpr.sort u✝) df.type
eq : VExpr.instL ls df.lhs = VExpr.sort (VLevel.inst ls u✝) ∨ VExpr.instL ls df.rhs = VExpr.sort (VLevel.inst ls u✝)
⊢ VLevel.WF U (VLevel.inst ls u✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | exact VLevel.WF.inst h2 | case extra.sort.refl
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
u : VLevel
IH : HasType env df.uvars [] (VExpr.sort u) df.type
eq : VExpr.instL ls df.lhs = VExpr.sort (VLevel.inst ls u) ∨ VExpr.instL ls df.rhs = VExpr.sort (VLevel.inst ls u)
⊢ VLevel.WF U (VLevel.inst ls u) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.sort.refl
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
u : VLevel
IH : HasType env df.uvars [] (VExpr.sort u) df.type
eq : VExpr.instL ls df.lhs = VExpr.sort (VLevel.inst ls u) ∨ VExpr.instL ls df.rhs = VExpr.sort (VLevel.inst ls u)
⊢ VLevel.WF U (VLevel.inst ls u)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | have ⟨A1, A2⟩ := henv.defEqWF h1 | env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
this : ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u
⊢ VLevel.WF U u | env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
this : ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u
A1 : HasType env df.uvars [] df.lhs df.type
A2 : HasType env df.uvars [] df.rhs df.type
⊢ VLevel.WF U u | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
this : ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | cases eq <;> exact this _ ‹_› ‹_› | env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
this : ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u
A1 : HasType env df.uvars [] df.lhs df.type
A2 : HasType env df.uvars [] df.rhs df.type
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
df : VDefEq
ls : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df
h2 : ∀ (l : VLevel), l ∈ ls → VLevel.WF U l
a✝ : List.length ls = df.uvars
eq : VExpr.instL ls df.lhs = VExpr.sort u ∨ VExpr.instL ls df.rhs = VExpr.sort u
this : ∀ (e : VExpr), VExpr.instL ls e = VExpr.sort u → HasType env df.uvars [] e df.type → VLevel.WF U u
A1 : HasType env df.uvars [] df.lhs df.type
A2 : HasType env df.uvars [] df.rhs df.type
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.sort_inv' | [715, 1] | [741, 20] | nomatch eq | case forallEDF
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ : A✝ = VExpr.sort u ∨ A'✝ = VExpr.sort u → VLevel.WF U u
a_ih✝ : body✝ = VExpr.sort u ∨ body'✝ = VExpr.sort u → VLevel.WF U u
eq : VExpr.forallE A✝ body✝ = VExpr.sort u ∨ VExpr.forallE A'✝ body'✝ = VExpr.sort u
⊢ VLevel.WF U u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : Ordered env
U : Nat
Γ : List VExpr
e1 e2 V : VExpr
u : VLevel
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a_ih✝¹ : A✝ = VExpr.sort u ∨ A'✝ = VExpr.sort u → VLevel.WF U u
a_ih✝ : body✝ = VExpr.sort u ∨ body'✝ = VExpr.sort u → VLevel.WF U u
eq : VExpr.forallE A✝ body✝ = VExpr.sort u ∨ VExpr.forallE A'✝ body'✝ = VExpr.sort u
⊢ VLevel.WF U u
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | induction H with
| bvar h => exact .lookup henv hΓ h
| proofIrrel h1 => exact ⟨_, h1⟩
| extra h1 h2 =>
have ⟨_, _, _, h⟩ := envIH.2 h1
exact ⟨_, (h.instL h2).weak0 henv⟩
| sortDF h1 => exact ⟨_, .sort h1⟩
| constDF h1 h2 =>
let ⟨_, h, _⟩ := envIH.1 h1
exact ⟨_, (h.instL h2).weak0 henv⟩
| symm _ ih => exact ih hΓ
| trans _ _ ih1 => exact ih1 hΓ
| appDF _ h2 ih1 => exact ((ih1 hΓ).forallE_inv henv).2.instN henv .zero h2.hasType.1
| lamDF h1 _ _ ih2 =>
let ⟨_, h⟩ := ih2 ⟨hΓ, _, h1.hasType.1⟩
exact ⟨_, .forallE h1.hasType.1 h⟩
| forallEDF h1 _ ih1 ih2 =>
exact ⟨_, .sort ⟨(ih1 hΓ).sort_inv henv, (ih2 ⟨hΓ, _, h1.hasType.1⟩).sort_inv henv⟩⟩
| defeqDF h1 => exact ⟨_, h1.hasType.2⟩
| beta _ h2 ih1 ih2 =>
have ⟨_, h⟩ := ih2 hΓ
exact (ih1 ⟨hΓ, _, h.hasType.2⟩).instN henv .zero h2
| eta _ ih => exact ih hΓ | 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
hΓ : OnCtx Γ (IsType env U)
H : IsDefEq env U Γ e1 e2 A
⊢ IsType env U Γ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
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
hΓ : OnCtx Γ (IsType env U)
H : IsDefEq env U Γ e1 e2 A
⊢ IsType env U Γ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact .lookup henv hΓ h | case bvar
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
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
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
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ⟨_, h1⟩ | case proofIrrel
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
p✝ h✝ h'✝ : VExpr
h1 : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝² : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ (VExpr.sort VLevel.zero)
a_ih✝¹ a_ih✝ : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ p✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ p✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
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
p✝ h✝ h'✝ : VExpr
h1 : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝² : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ (VExpr.sort VLevel.zero)
a_ih✝¹ a_ih✝ : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ p✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | have ⟨_, _, _, h⟩ := envIH.2 h1 | case extra
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
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ df✝.type) | case extra
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
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
left✝¹ : (fun U e A => HasType env U [] e A ∧ IsType env U [] A) df✝.uvars df✝.lhs df✝.type
left✝ : HasType env df✝.uvars [] df✝.rhs df✝.type
w✝ : VLevel
h : HasType env df✝.uvars [] df✝.type (VExpr.sort w✝)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ df✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A ∧ IsType env U [] A
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ⟨_, (h.instL h2).weak0 henv⟩ | case extra
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
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
left✝¹ : (fun U e A => HasType env U [] e A ∧ IsType env U [] A) df✝.uvars df✝.lhs df✝.type
left✝ : HasType env df✝.uvars [] df✝.rhs df✝.type
w✝ : VLevel
h : HasType env df✝.uvars [] df✝.type (VExpr.sort w✝)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
envIH : OnTypes env fun U e A => HasType env U [] e A ∧ IsType env U [] A
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
left✝¹ : (fun U e A => HasType env U [] e A ∧ IsType env U [] A) df✝.uvars df✝.lhs df✝.type
left✝ : HasType env df✝.uvars [] df✝.rhs df✝.type
w✝ : VLevel
h : HasType env df✝.uvars [] df✝.type (VExpr.sort w✝)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ⟨_, .sort h1⟩ | case sortDF
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
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
a✝¹ : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ (VExpr.sort (VLevel.succ l✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
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
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
a✝¹ : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ (VExpr.sort (VLevel.succ l✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | let ⟨_, h, _⟩ := envIH.1 h1 | case constDF
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
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ ci✝.type) | case constDF
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
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : OnCtx Γ✝ (IsType env U)
w✝ : VLevel
h : HasType env ci✝.uvars [] ci✝.type (VExpr.sort w✝)
right✝ : IsType env ci✝.uvars [] (VExpr.sort w✝)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ ci✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
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
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ⟨_, (h.instL h2).weak0 henv⟩ | case constDF
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
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : OnCtx Γ✝ (IsType env U)
w✝ : VLevel
h : HasType env ci✝.uvars [] ci✝.type (VExpr.sort w✝)
right✝ : IsType env ci✝.uvars [] (VExpr.sort w✝)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
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
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : OnCtx Γ✝ (IsType env U)
w✝ : VLevel
h : HasType env ci✝.uvars [] ci✝.type (VExpr.sort w✝)
right✝ : IsType env ci✝.uvars [] (VExpr.sort w✝)
⊢ IsType env U Γ✝ (VExpr.instL ls✝ ci✝.type)
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 symm
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✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
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✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.isType' | [757, 1] | [781, 28] | exact ih1 hΓ | case trans
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₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 a_ih✝ : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
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₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 a_ih✝ : OnCtx Γ✝ (IsType env U) → IsType env U Γ✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ IsType env U Γ✝ A✝
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.