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/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | refine ⟨.lam ihA.1 ihb.1, .defeq ?_ <| .lam ihA.2.1 ihb'.2.1, .lamDF ihA.2.2 ihb.2.2⟩ | case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ihB :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihB' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) B✝ B✝
ihb :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ihb' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ body✝) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ (lam A'✝ body'✝) (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ body✝) (lam A'✝ body'✝) | case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ihB :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihB' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) B✝ B✝
ihb :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ihb' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ defEq Γ✝ (VExpr.forallE A'✝ B✝) (VExpr.forallE A✝ B✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ihB :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihB' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) B✝ B✝
ihb :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ihb' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ body✝) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ (lam A'✝ body'✝) (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ body✝) (lam A'✝ body'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact hdf (.forallE ihA.2.1 ihB'.1) (.forallE ihA.1 ihB.1) <|
.symm <| .forallEDF ihA.2.2 ihB.2.2 | case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ihB :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihB' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) B✝ B✝
ihb :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ihb' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ defEq Γ✝ (VExpr.forallE A'✝ B✝) (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ihB :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihB' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) B✝ B✝
ihb :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ihb' :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ B✝ ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ B✝ ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ defEq Γ✝ (VExpr.forallE A'✝ B✝) (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.forallE ih1.1 ih2.1, .forallE ih1.2.1 ih3.2.1, .forallEDF ih1.2.2 ih2.2.2⟩ | case forallEDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝⁴ : VLevel.WF U u✝
a✝³ : VLevel.WF U v✝
a✝² : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ih2 :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ih3 :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝⁴ : VLevel.WF U u✝
a✝³ : VLevel.WF U v✝
a✝² : IsDefEqStrong env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A'✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A'✝
ih2 :
HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) body✝ body'✝
ih3 :
HasTypeU1 env U defEq (A'✝ :: Γ✝) body✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A'✝ :: Γ✝) body'✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A'✝ :: Γ✝) body✝ body'✝
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝)) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | have h := hdf ih1.1 ih1.2.1 ih1.2.2 | case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ B✝
ih2 : HasTypeU1 env U defEq Γ✝ e1✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
⊢ HasTypeU1 env U defEq Γ✝ e1✝ B✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝ | case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ B✝
ih2 : HasTypeU1 env U defEq Γ✝ e1✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
h : defEq Γ✝ A✝ B✝
⊢ HasTypeU1 env U defEq Γ✝ e1✝ B✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ B✝
ih2 : HasTypeU1 env U defEq Γ✝ e1✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
⊢ HasTypeU1 env U defEq Γ✝ e1✝ B✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.defeq h ih2.1, .defeq h ih2.2.1, ih2.2.2⟩ | case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ B✝
ih2 : HasTypeU1 env U defEq Γ✝ e1✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
h : defEq Γ✝ A✝ B✝
⊢ HasTypeU1 env U defEq Γ✝ e1✝ B✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ B✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ B✝
ih2 : HasTypeU1 env U defEq Γ✝ e1✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
h : defEq Γ✝ A✝ B✝
⊢ HasTypeU1 env U defEq Γ✝ e1✝ B✝ ∧ HasTypeU1 env U defEq Γ✝ e2✝ B✝ ∧ IsDefEqU1 env U hasType Γ✝ e1✝ e2✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.app (.lam ihA.1 ihe.1) ihe'.1, ihee.1, .beta (hty ihe.1) (hty ihe'.1)⟩ | case beta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ e'✝ : VExpr
a✝⁷ : VLevel.WF U u✝
a✝⁶ : VLevel.WF U v✝
a✝⁵ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝⁴ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝² : IsDefEqStrong env U Γ✝ e'✝ e'✝ A✝
a✝¹ : IsDefEqStrong env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (VExpr.sort v✝)
a✝ : IsDefEqStrong env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihe :
HasTypeU1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) e✝ e✝
ihe' : HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e'✝ e'✝
a_ih✝ :
HasTypeU1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ e'✝) (inst B✝ e'✝)
ihee :
HasTypeU1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
HasTypeU1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst e✝ e'✝) (inst e✝ e'✝)
⊢ HasTypeU1 env U defEq Γ✝ (app (lam A✝ e✝) e'✝) (inst B✝ e'✝) ∧
HasTypeU1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
IsDefEqU1 env U hasType Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ e'✝ : VExpr
a✝⁷ : VLevel.WF U u✝
a✝⁶ : VLevel.WF U v✝
a✝⁵ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝⁴ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝² : IsDefEqStrong env U Γ✝ e'✝ e'✝ A✝
a✝¹ : IsDefEqStrong env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (VExpr.sort v✝)
a✝ : IsDefEqStrong env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
ihe :
HasTypeU1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) e✝ B✝ ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) e✝ e✝
ihe' : HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ HasTypeU1 env U defEq Γ✝ e'✝ A✝ ∧ IsDefEqU1 env U hasType Γ✝ e'✝ e'✝
a_ih✝ :
HasTypeU1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq Γ✝ (inst B✝ e'✝) (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst B✝ e'✝) (inst B✝ e'✝)
ihee :
HasTypeU1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
HasTypeU1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧ IsDefEqU1 env U hasType Γ✝ (inst e✝ e'✝) (inst e✝ e'✝)
⊢ HasTypeU1 env U defEq Γ✝ (app (lam A✝ e✝) e'✝) (inst B✝ e'✝) ∧
HasTypeU1 env U defEq Γ✝ (inst e✝ e'✝) (inst B✝ e'✝) ∧
IsDefEqU1 env U hasType Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | have := HasTypeU1.app ihe'.1 (.bvar .zero) | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
this : HasTypeU1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) (inst (liftN 1 B✝ 1) (VExpr.bvar 0))
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | rw [instN_bvar0] at this | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
this : HasTypeU1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) (inst (liftN 1 B✝ 1) (VExpr.bvar 0))
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
this : HasTypeU1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) B✝
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
this : HasTypeU1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) (inst (liftN 1 B✝ 1) (VExpr.bvar 0))
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨.lam ihA.1 this, ihe.1, .eta⟩ | case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
this : HasTypeU1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) B✝
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (VExpr.sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (VExpr.sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1))
ihA :
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧
HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝) ∧ IsDefEqU1 env U hasType Γ✝ A✝ A✝
a_ih✝¹ :
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) B✝ (VExpr.sort v✝) ∧ IsDefEqU1 env U hasType (A✝ :: Γ✝) B✝ B✝
a_ih✝ :
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
HasTypeU1 env U defEq (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (VExpr.sort v✝) ∧
IsDefEqU1 env U hasType (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1)
ihe :
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧ IsDefEqU1 env U hasType Γ✝ e✝ e✝
ihe' :
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
HasTypeU1 env U defEq (A✝ :: Γ✝) (lift e✝) (VExpr.forallE (lift A✝) (liftN 1 B✝ 1)) ∧
IsDefEqU1 env U hasType (A✝ :: Γ✝) (lift e✝) (lift e✝)
this : HasTypeU1 env U defEq (A✝ :: Γ✝) (app (lift e✝) (VExpr.bvar 0)) B✝
⊢ HasTypeU1 env U defEq Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (VExpr.forallE A✝ B✝) ∧
HasTypeU1 env U defEq Γ✝ e✝ (VExpr.forallE A✝ B✝) ∧
IsDefEqU1 env U hasType Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨ih2.1, ih3.1, .proofIrrel (hty ih1.1) (hty ih2.1) (hty ih3.1)⟩ | case proofIrrel
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEqStrong env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEqStrong env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEqStrong env U Γ✝ h'✝ h'✝ p✝
ih1 :
HasTypeU1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧
HasTypeU1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧ IsDefEqU1 env U hasType Γ✝ p✝ p✝
ih2 : HasTypeU1 env U defEq Γ✝ h✝ p✝ ∧ HasTypeU1 env U defEq Γ✝ h✝ p✝ ∧ IsDefEqU1 env U hasType Γ✝ h✝ h✝
ih3 : HasTypeU1 env U defEq Γ✝ h'✝ p✝ ∧ HasTypeU1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEqU1 env U hasType Γ✝ h'✝ h'✝
⊢ HasTypeU1 env U defEq Γ✝ h✝ p✝ ∧ HasTypeU1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEqU1 env U hasType Γ✝ h✝ h'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEqStrong env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEqStrong env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEqStrong env U Γ✝ h'✝ h'✝ p✝
ih1 :
HasTypeU1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧
HasTypeU1 env U defEq Γ✝ p✝ (VExpr.sort VLevel.zero) ∧ IsDefEqU1 env U hasType Γ✝ p✝ p✝
ih2 : HasTypeU1 env U defEq Γ✝ h✝ p✝ ∧ HasTypeU1 env U defEq Γ✝ h✝ p✝ ∧ IsDefEqU1 env U hasType Γ✝ h✝ h✝
ih3 : HasTypeU1 env U defEq Γ✝ h'✝ p✝ ∧ HasTypeU1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEqU1 env U hasType Γ✝ h'✝ h'✝
⊢ HasTypeU1 env U defEq Γ✝ h✝ p✝ ∧ HasTypeU1 env U defEq Γ✝ h'✝ p✝ ∧ IsDefEqU1 env U hasType Γ✝ h✝ h'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.IsDefEq.inductionU1 | [55, 1] | [97, 44] | exact ⟨ihl'.1, ihr'.1, .extra h1 h2 h3⟩ | case extra
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
df✝ : VDefEq
ls✝ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
a✝⁵ : VLevel.WF U u✝
a✝⁴ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝² : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a✝¹ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a_ih✝² :
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type)
a_ih✝¹ :
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs)
a_ih✝ :
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs)
ihl' :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs)
ihr' :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs)
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
e1 e2 A : VExpr
defEq hasType : List VExpr → VExpr → VExpr → Prop
hty : ∀ {Γ : List VExpr} {e A : VExpr}, HasTypeU1 env U defEq Γ e A → hasType Γ e A
hdf :
∀ {Γ : List VExpr} {e1 e2 A1 A2 : VExpr},
HasTypeU1 env U defEq Γ e1 A1 → HasTypeU1 env U defEq Γ e2 A2 → IsDefEqU1 env U hasType Γ e1 e2 → defEq Γ e1 e2
df✝ : VDefEq
ls✝ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
a✝⁵ : VLevel.WF U u✝
a✝⁴ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝)
a✝³ : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝² : IsDefEqStrong env U [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a✝¹ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type)
a✝ : IsDefEqStrong env U Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type)
a_ih✝² :
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.type) (VExpr.sort u✝) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls✝ df✝.type) (VExpr.instL ls✝ df✝.type)
a_ih✝¹ :
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs)
a_ih✝ :
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType [] (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs)
ihl' :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.lhs)
ihr' :
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.rhs)
⊢ HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.type) ∧
HasTypeU1 env U defEq Γ✝ (VExpr.instL ls✝ df✝.rhs) (VExpr.instL ls✝ df✝.type) ∧
IsDefEqU1 env U hasType Γ✝ (VExpr.instL ls✝ df✝.lhs) (VExpr.instL ls✝ df✝.rhs)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | induction H with
| bvar h => exact .bvar h
| const h1 h2 h3 => exact .const h1 h2 h3
| sort h => exact .sort h
| app _ _ ih1 ih2 => exact .app (ih1 hΓ) (ih2 hΓ)
| lam _ _ ih1 ih2 => exact .lam (ih1 hΓ) (ih2 ⟨hΓ, _, ih1 hΓ⟩)
| forallE _ _ ih1 ih2 => exact .forallE (ih1 hΓ) (ih2 ⟨hΓ, _, ih1 hΓ⟩)
| defeq h1 _ ih =>
let ⟨_, h⟩ := (ih hΓ).isType henv hΓ
exact (IH h h1).defeq (ih hΓ) | env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
H : HasTypeU1 env U defEq Γ e A
⊢ HasType env U Γ e A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
H : HasTypeU1 env U defEq Γ e A
⊢ HasType env U Γ e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact .bvar h | case bvar
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.bvar i✝) A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.bvar i✝) A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact .const h1 h2 h3 | case const
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = ci✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.const c✝ ls✝) (instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = ci✝.uvars
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.const c✝ ls✝) (instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact .sort h | case sort
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
l✝ : VLevel
h : VLevel.WF U l✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.sort l✝) (VExpr.sort (VLevel.succ l✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sort
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
l✝ : VLevel
h : VLevel.WF U l✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.sort l✝) (VExpr.sort (VLevel.succ l✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact .app (ih1 hΓ) (ih2 hΓ) | case app
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
f✝ A✝ B✝ a✝² : VExpr
a✝¹ : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
a✝ : HasTypeU1 env U defEq Γ✝ a✝² A✝
ih1 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ f✝ (VExpr.forallE A✝ B✝)
ih2 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ a✝² A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.app f✝ a✝²) (inst B✝ a✝²) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case app
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
f✝ A✝ B✝ a✝² : VExpr
a✝¹ : HasTypeU1 env U defEq Γ✝ f✝ (VExpr.forallE A✝ B✝)
a✝ : HasTypeU1 env U defEq Γ✝ a✝² A✝
ih1 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ f✝ (VExpr.forallE A✝ B✝)
ih2 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ a✝² A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.app f✝ a✝²) (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact .lam (ih1 hΓ) (ih2 ⟨hΓ, _, ih1 hΓ⟩) | case lam
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ B✝ : VExpr
a✝¹ : HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝
ih1 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : OnCtx (A✝ :: Γ✝) (IsType env U) → HasType env U (A✝ :: Γ✝) body✝ B✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.lam A✝ body✝) (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lam
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ B✝ : VExpr
a✝¹ : HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ B✝
ih1 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : OnCtx (A✝ :: Γ✝) (IsType env U) → HasType env U (A✝ :: Γ✝) body✝ B✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.lam A✝ body✝) (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact .forallE (ih1 hΓ) (ih2 ⟨hΓ, _, ih1 hΓ⟩) | case forallE
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ : VExpr
v✝ : VLevel
a✝¹ : HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
ih1 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : OnCtx (A✝ :: Γ✝) (IsType env U) → HasType env U (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
body✝ : VExpr
v✝ : VLevel
a✝¹ : HasTypeU1 env U defEq Γ✝ A✝ (VExpr.sort u✝)
a✝ : HasTypeU1 env U defEq (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
ih1 : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ A✝ (VExpr.sort u✝)
ih2 : OnCtx (A✝ :: Γ✝) (IsType env U) → HasType env U (A✝ :: Γ✝) body✝ (VExpr.sort v✝)
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | let ⟨_, h⟩ := (ih hΓ).isType henv hΓ | case defeq
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝
a✝ : HasTypeU1 env U defEq Γ✝ e✝ A✝
ih : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ e✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ e✝ B✝ | case defeq
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝
a✝ : HasTypeU1 env U defEq Γ✝ e✝ A✝
ih : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ e✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
w✝ : VLevel
h : HasType env U Γ✝ A✝ (VExpr.sort w✝)
⊢ HasType env U Γ✝ e✝ B✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝
a✝ : HasTypeU1 env U defEq Γ✝ e✝ A✝
ih : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ e✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
⊢ HasType env U Γ✝ e✝ B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/StratifiedUntyped.lean | Lean4Lean.VEnv.HasTypeU1.induction | [102, 1] | [112, 34] | exact (IH h h1).defeq (ih hΓ) | case defeq
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝
a✝ : HasTypeU1 env U defEq Γ✝ e✝ A✝
ih : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ e✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
w✝ : VLevel
h : HasType env U Γ✝ A✝ (VExpr.sort w✝)
⊢ HasType env U Γ✝ e✝ B✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
Γ : List VExpr
U : Nat
henv : Ordered env
defEq : List VExpr → VExpr → VExpr → Prop
IH : ∀ {Γ : List VExpr} {e1 e2 A : VExpr}, HasType env U Γ e1 A → defEq Γ e1 e2 → IsDefEq env U Γ e1 e2 A
e A : VExpr
Γ✝ : List VExpr
A✝ B✝ e✝ : VExpr
h1 : defEq Γ✝ A✝ B✝
a✝ : HasTypeU1 env U defEq Γ✝ e✝ A✝
ih : OnCtx Γ✝ (IsType env U) → HasType env U Γ✝ e✝ A✝
hΓ : OnCtx Γ✝ (IsType env U)
w✝ : VLevel
h : HasType env U Γ✝ A✝ (VExpr.sort w✝)
⊢ HasType env U Γ✝ e✝ B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact .empty | case empty
ds : List VDecl
env : VEnv
⊢ Ordered VEnv.empty | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
ds : List VDecl
env : VEnv
⊢ Ordered VEnv.empty
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact .const ih (by rintro _ ⟨⟩) h | case decl.block
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
n✝ : Name
h : addConst env✝ n✝ none = some env'✝
⊢ Ordered env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.block
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
n✝ : Name
h : addConst env✝ n✝ none = some env'✝
⊢ Ordered env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | rintro _ ⟨⟩ | ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
n✝ : Name
h : addConst env✝ n✝ none = some env'✝
⊢ ∀ (ci : VConstant), none = some ci → VConstant.WF env✝ ci | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
n✝ : Name
h : addConst env✝ n✝ none = some env'✝
⊢ ∀ (ci : VConstant), none = some ci → VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact .const ih (by rintro _ ⟨⟩; exact h1) h2 | case decl.axiom
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ Ordered env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.axiom
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ Ordered env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | rintro _ ⟨⟩ | ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ ∀ (ci : VConstant), some ci✝.toVConstant = some ci → VConstant.WF env✝ ci | case refl
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ VConstant.WF env✝ ci✝.toVConstant | Please generate a tactic in lean4 to solve the state.
STATE:
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ ∀ (ci : VConstant), some ci✝.toVConstant = some ci → VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact h1 | case refl
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ VConstant.WF env✝ ci✝.toVConstant | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VConstVal
h1 : VConstant.WF env✝ ci✝.toVConstant
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ VConstant.WF env✝ ci✝.toVConstant
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | refine .defeq (.const ih (by rintro _ ⟨⟩; exact h1.isType ih ⟨⟩) h2) ⟨?_, ?_⟩ | case decl.def
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ Ordered (addDefEq env (VDefVal.toDefEq ci)) | case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env (VDefVal.toDefEq ci).uvars [] (VDefVal.toDefEq ci).lhs (VDefVal.toDefEq ci).type
case decl.def.refine_2
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env (VDefVal.toDefEq ci).uvars [] (VDefVal.toDefEq ci).rhs (VDefVal.toDefEq ci).type | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.def
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ Ordered (addDefEq env (VDefVal.toDefEq ci))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | rintro _ ⟨⟩ | ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ ∀ (ci_1 : VConstant), some ci.toVConstant = some ci_1 → VConstant.WF env✝ ci_1 | case refl
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ VConstant.WF env✝ ci.toVConstant | Please generate a tactic in lean4 to solve the state.
STATE:
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ ∀ (ci_1 : VConstant), some ci.toVConstant = some ci_1 → VConstant.WF env✝ ci_1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact h1.isType ih ⟨⟩ | case refl
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ VConstant.WF env✝ ci.toVConstant | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ VConstant.WF env✝ ci.toVConstant
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | simp [VDefVal.toDefEq] | case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env (VDefVal.toDefEq ci).uvars [] (VDefVal.toDefEq ci).lhs (VDefVal.toDefEq ci).type | case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env ci.uvars [] (VExpr.const ci.name (List.map VLevel.param (List.range ci.uvars))) ci.type | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env (VDefVal.toDefEq ci).uvars [] (VDefVal.toDefEq ci).lhs (VDefVal.toDefEq ci).type
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | rw [← (h1.levelWF ⟨⟩).2.2.instL_id] | case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env ci.uvars [] (VExpr.const ci.name (List.map VLevel.param (List.range ci.uvars))) ci.type | case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env ci.uvars [] (VExpr.const ci.name (List.map VLevel.param (List.range ci.uvars)))
(VExpr.instL (List.map VLevel.param (List.range ci.uvars)) ci.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env ci.uvars [] (VExpr.const ci.name (List.map VLevel.param (List.range ci.uvars))) ci.type
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact .const (addConst_self h2) VLevel.id_WF (by simp) | case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env ci.uvars [] (VExpr.const ci.name (List.map VLevel.param (List.range ci.uvars)))
(VExpr.instL (List.map VLevel.param (List.range ci.uvars)) ci.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.def.refine_1
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env ci.uvars [] (VExpr.const ci.name (List.map VLevel.param (List.range ci.uvars)))
(VExpr.instL (List.map VLevel.param (List.range ci.uvars)) ci.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | simp | ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ List.length (List.map VLevel.param (List.range ci.uvars)) = ci.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ List.length (List.map VLevel.param (List.range ci.uvars)) = ci.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact h1.mono (addConst_le h2) | case decl.def.refine_2
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env (VDefVal.toDefEq ci).uvars [] (VDefVal.toDefEq ci).rhs (VDefVal.toDefEq ci).type | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.def.refine_2
ds : List VDecl
env✝¹ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
env : VEnv
ci : VDefVal
h1 : VDefVal.WF env✝ ci
h2 : addConst env✝ ci.name (some ci.toVConstant) = some env
⊢ HasType env (VDefVal.toDefEq ci).uvars [] (VDefVal.toDefEq ci).rhs (VDefVal.toDefEq ci).type
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact .const ih (by rintro _ ⟨⟩; exact h1.isType ih ⟨⟩) h2 | case decl.opaque
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ Ordered env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.opaque
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ Ordered env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | rintro _ ⟨⟩ | ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ ∀ (ci : VConstant), some ci✝.toVConstant = some ci → VConstant.WF env✝ ci | case refl
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ VConstant.WF env✝ ci✝.toVConstant | Please generate a tactic in lean4 to solve the state.
STATE:
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ ∀ (ci : VConstant), some ci✝.toVConstant = some ci → VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact h1.isType ih ⟨⟩ | case refl
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ VConstant.WF env✝ ci✝.toVConstant | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
ci✝ : VDefVal
h1 : VDefVal.WF env✝ ci✝
h2 : addConst env✝ ci✝.name (some ci✝.toVConstant) = some env'✝
⊢ VConstant.WF env✝ ci✝.toVConstant
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact ih | case decl.example
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
ci✝ : VDefVal
a✝¹ : WF ds✝ env'✝
ih : Ordered env'✝
a✝ : VDefVal.WF env'✝ ci✝
⊢ Ordered env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.example
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
ci✝ : VDefVal
a✝¹ : WF ds✝ env'✝
ih : Ordered env'✝
a✝ : VDefVal.WF env'✝ ci✝
⊢ Ordered env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact addQuot_WF ih h1 h2 | case decl.quot
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
h1 : QuotReady env✝
h2 : addQuot env✝ = some env'✝
⊢ Ordered env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.quot
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
h1 : QuotReady env✝
h2 : addQuot env✝ = some env'✝
⊢ Ordered env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/EnvLemmas.lean | Lean4Lean.VEnv.WF.ordered | [8, 1] | [24, 50] | exact addInduct_WF ih h1 h2 | case decl.induct
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
decl✝ : VInductDecl
h1 : VInductDecl.WF env✝ decl✝
h2 : addInduct env✝ decl✝ = some env'✝
⊢ Ordered env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case decl.induct
ds : List VDecl
env env'✝ : VEnv
ds✝ : List VDecl
env✝ : VEnv
a✝ : WF ds✝ env✝
ih : Ordered env✝
decl✝ : VInductDecl
h1 : VInductDecl.WF env✝ decl✝
h2 : addInduct env✝ decl✝ = some env'✝
⊢ Ordered env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.succ_congr | [56, 1] | [57, 34] | simpa [equiv_def, eval] using h | a b : VLevel
h : a ≈ b
⊢ succ a ≈ succ b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : VLevel
h : a ≈ b
⊢ succ a ≈ succ b
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_inst | [67, 1] | [69, 50] | induction l <;> simp [inst, *, List.getD_eq_get?] | ls ls' : List VLevel
l : VLevel
⊢ inst ls' (inst ls l) = inst (List.map (inst ls') ls) l | case param
ls ls' : List VLevel
a✝ : Nat
⊢ inst ls' (Option.getD (List.get? ls a✝) zero) = Option.getD (Option.map (inst ls') (List.get? ls a✝)) zero | Please generate a tactic in lean4 to solve the state.
STATE:
ls ls' : List VLevel
l : VLevel
⊢ inst ls' (inst ls l) = inst (List.map (inst ls') ls) l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_inst | [67, 1] | [69, 50] | case param n => cases ls.get? n <;> simp [inst] | ls ls' : List VLevel
n : Nat
⊢ inst ls' (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (inst ls') (List.get? ls n)) zero | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ls ls' : List VLevel
n : Nat
⊢ inst ls' (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (inst ls') (List.get? ls n)) zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_inst | [67, 1] | [69, 50] | cases ls.get? n <;> simp [inst] | ls ls' : List VLevel
n : Nat
⊢ inst ls' (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (inst ls') (List.get? ls n)) zero | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ls ls' : List VLevel
n : Nat
⊢ inst ls' (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (inst ls') (List.get? ls n)) zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_id | [71, 1] | [72, 74] | induction l <;> simp_all [inst, WF, List.getD_eq_get?, List.get?_range] | u : Nat
l : VLevel
h : WF u l
⊢ inst (List.map param (List.range u)) l = l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
u : Nat
l : VLevel
h : WF u l
⊢ inst (List.map param (List.range u)) l = l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.eval_inst | [74, 1] | [76, 50] | induction l <;> simp [eval, inst, *, List.getD_eq_get?] | ls : List VLevel
ns : List Nat
l : VLevel
⊢ eval ns (inst ls l) = eval (List.map (eval ns) ls) l | case param
ls : List VLevel
ns : List Nat
a✝ : Nat
⊢ eval ns (Option.getD (List.get? ls a✝) zero) = Option.getD (Option.map (eval ns) (List.get? ls a✝)) 0 | Please generate a tactic in lean4 to solve the state.
STATE:
ls : List VLevel
ns : List Nat
l : VLevel
⊢ eval ns (inst ls l) = eval (List.map (eval ns) ls) l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.eval_inst | [74, 1] | [76, 50] | case param n => cases ls.get? n <;> simp [eval] | ls : List VLevel
ns : List Nat
n : Nat
⊢ eval ns (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (eval ns) (List.get? ls n)) 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ls : List VLevel
ns : List Nat
n : Nat
⊢ eval ns (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (eval ns) (List.get? ls n)) 0
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.eval_inst | [74, 1] | [76, 50] | cases ls.get? n <;> simp [eval] | ls : List VLevel
ns : List Nat
n : Nat
⊢ eval ns (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (eval ns) (List.get? ls n)) 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ls : List VLevel
ns : List Nat
n : Nat
⊢ eval ns (Option.getD (List.get? ls n) zero) = Option.getD (Option.map (eval ns) (List.get? ls n)) 0
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | induction l with
| zero => trivial
| succ _ ih => exact ih
| max _ _ ih1 ih2 | imax _ _ ih1 ih2 => exact ⟨ih1, ih2⟩
| param i =>
simp [VLevel.inst, List.getD_eq_get?]
cases e : ls.get? i with
| none => trivial
| some => exact H _ (List.get?_mem e) | ls : List VLevel
n : Nat
l : VLevel
H : ∀ (l : VLevel), l ∈ ls → WF n l
⊢ WF n (VLevel.inst ls l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ls : List VLevel
n : Nat
l : VLevel
H : ∀ (l : VLevel), l ∈ ls → WF n l
⊢ WF n (VLevel.inst ls l)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | trivial | case zero
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
⊢ WF n (VLevel.inst ls zero) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
⊢ WF n (VLevel.inst ls zero)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | exact ih | case succ
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
a✝ : VLevel
ih : WF n (VLevel.inst ls a✝)
⊢ WF n (VLevel.inst ls (succ a✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
a✝ : VLevel
ih : WF n (VLevel.inst ls a✝)
⊢ WF n (VLevel.inst ls (succ a✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | exact ⟨ih1, ih2⟩ | case imax
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
a✝¹ a✝ : VLevel
ih1 : WF n (VLevel.inst ls a✝¹)
ih2 : WF n (VLevel.inst ls a✝)
⊢ WF n (VLevel.inst ls (imax a✝¹ a✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case imax
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
a✝¹ a✝ : VLevel
ih1 : WF n (VLevel.inst ls a✝¹)
ih2 : WF n (VLevel.inst ls a✝)
⊢ WF n (VLevel.inst ls (imax a✝¹ a✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | simp [VLevel.inst, List.getD_eq_get?] | case param
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
⊢ WF n (VLevel.inst ls (param i)) | case param
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
⊢ WF n (Option.getD (List.get? ls i) zero) | Please generate a tactic in lean4 to solve the state.
STATE:
case param
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
⊢ WF n (VLevel.inst ls (param i))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | cases e : ls.get? i with
| none => trivial
| some => exact H _ (List.get?_mem e) | case param
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
⊢ WF n (Option.getD (List.get? ls i) zero) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case param
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
⊢ WF n (Option.getD (List.get? ls i) zero)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | trivial | case param.none
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
e : List.get? ls i = none
⊢ WF n (Option.getD none zero) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case param.none
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
e : List.get? ls i = none
⊢ WF n (Option.getD none zero)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.inst | [78, 1] | [87, 42] | exact H _ (List.get?_mem e) | case param.some
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
val✝ : VLevel
e : List.get? ls i = some val✝
⊢ WF n (Option.getD (some val✝) zero) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case param.some
ls : List VLevel
n : Nat
H : ∀ (l : VLevel), l ∈ ls → WF n l
i : Nat
val✝ : VLevel
e : List.get? ls i = some val✝
⊢ WF n (Option.getD (some val✝) zero)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.id_WF | [89, 1] | [89, 71] | simp [WF] | u : Nat
⊢ ∀ (l : VLevel), l ∈ List.map param (List.range u) → WF u l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
u : Nat
⊢ ∀ (l : VLevel), l ∈ List.map param (List.range u) → WF u l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_congr | [91, 1] | [97, 40] | simp [equiv_def, eval_inst, ← equiv_def.1 h1] | l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
⊢ inst ls l ≈ inst ls' l' | l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
⊢ ∀ (ls_1 : List Nat), eval (List.map (eval ls_1) ls) l = eval (List.map (eval ls_1) ls') l | Please generate a tactic in lean4 to solve the state.
STATE:
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
⊢ inst ls l ≈ inst ls' l'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_congr | [91, 1] | [97, 40] | intro ns | l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
⊢ ∀ (ls_1 : List Nat), eval (List.map (eval ls_1) ls) l = eval (List.map (eval ls_1) ls') l | l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
ns : List Nat
⊢ eval (List.map (eval ns) ls) l = eval (List.map (eval ns) ls') l | Please generate a tactic in lean4 to solve the state.
STATE:
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
⊢ ∀ (ls_1 : List Nat), eval (List.map (eval ls_1) ls) l = eval (List.map (eval ls_1) ls') l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_congr | [91, 1] | [97, 40] | congr 1 | l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
ns : List Nat
⊢ eval (List.map (eval ns) ls) l = eval (List.map (eval ns) ls') l | case e_ls
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
ns : List Nat
⊢ List.map (eval ns) ls = List.map (eval ns) ls' | Please generate a tactic in lean4 to solve the state.
STATE:
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
ns : List Nat
⊢ eval (List.map (eval ns) ls) l = eval (List.map (eval ns) ls') l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_congr | [91, 1] | [97, 40] | induction h2 with
| nil => rfl
| cons h2 => simp [*, equiv_def.1 h2] | case e_ls
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
ns : List Nat
⊢ List.map (eval ns) ls = List.map (eval ns) ls' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_ls
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
h2 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls ls'
ns : List Nat
⊢ List.map (eval ns) ls = List.map (eval ns) ls'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_congr | [91, 1] | [97, 40] | rfl | case e_ls.nil
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
ns : List Nat
⊢ List.map (eval ns) [] = List.map (eval ns) [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_ls.nil
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
ns : List Nat
⊢ List.map (eval ns) [] = List.map (eval ns) []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.inst_congr | [91, 1] | [97, 40] | simp [*, equiv_def.1 h2] | case e_ls.cons
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
ns : List Nat
a✝¹ b✝ : VLevel
l₁✝ l₂✝ : List VLevel
h2 : a✝¹ ≈ b✝
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) l₁✝ l₂✝
a_ih✝ : List.map (eval ns) l₁✝ = List.map (eval ns) l₂✝
⊢ List.map (eval ns) (a✝¹ :: l₁✝) = List.map (eval ns) (b✝ :: l₂✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_ls.cons
l' : VLevel
ls ls' : List VLevel
l : VLevel
h1 : l ≈ l'
ns : List Nat
a✝¹ b✝ : VLevel
l₁✝ l₂✝ : List VLevel
h2 : a✝¹ ≈ b✝
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) l₁✝ l₂✝
a_ih✝ : List.map (eval ns) l₁✝ = List.map (eval ns) l₂✝
⊢ List.map (eval ns) (a✝¹ :: l₁✝) = List.map (eval ns) (b✝ :: l₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | induction l generalizing l' with simp [ofLevel, bind, Option.bind_eq_some] at h
| zero => cases h; trivial
| succ _ ih => obtain ⟨l', h, ⟨⟩⟩ := h; exact @ih l' h
| max _ _ ih1 ih2 | imax _ _ ih1 ih2 => obtain ⟨_, h1, _, h2, ⟨⟩⟩ := h; exact ⟨ih1 h1, ih2 h2⟩
| param n => exact h.2 ▸ h.1 | ls : List Name
l : Lean.Level
l' : VLevel
h : ofLevel ls l = some l'
⊢ WF (List.length ls) l' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ls : List Name
l : Lean.Level
l' : VLevel
h : ofLevel ls l = some l'
⊢ WF (List.length ls) l'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | cases h | case zero
ls : List Name
l' : VLevel
h : zero = l'
⊢ WF (List.length ls) l' | case zero.refl
ls : List Name
⊢ WF (List.length ls) zero | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
ls : List Name
l' : VLevel
h : zero = l'
⊢ WF (List.length ls) l'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | trivial | case zero.refl
ls : List Name
⊢ WF (List.length ls) zero | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.refl
ls : List Name
⊢ WF (List.length ls) zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | obtain ⟨l', h, ⟨⟩⟩ := h | case succ
ls : List Name
a✝ : Lean.Level
ih : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ∃ a, ofLevel ls a✝ = some a ∧ succ a = l'
⊢ WF (List.length ls) l' | case succ.intro.intro.refl
ls : List Name
a✝ : Lean.Level
ih : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ofLevel ls a✝ = some l'
⊢ WF (List.length ls) (succ l') | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
ls : List Name
a✝ : Lean.Level
ih : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ∃ a, ofLevel ls a✝ = some a ∧ succ a = l'
⊢ WF (List.length ls) l'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | exact @ih l' h | case succ.intro.intro.refl
ls : List Name
a✝ : Lean.Level
ih : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ofLevel ls a✝ = some l'
⊢ WF (List.length ls) (succ l') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.refl
ls : List Name
a✝ : Lean.Level
ih : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ofLevel ls a✝ = some l'
⊢ WF (List.length ls) (succ l')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | obtain ⟨_, h1, _, h2, ⟨⟩⟩ := h | case imax
ls : List Name
a✝¹ a✝ : Lean.Level
ih1 : ∀ {l' : VLevel}, ofLevel ls a✝¹ = some l' → WF (List.length ls) l'
ih2 : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ∃ a, ofLevel ls a✝¹ = some a ∧ ∃ a_1, ofLevel ls a✝ = some a_1 ∧ imax a a_1 = l'
⊢ WF (List.length ls) l' | case imax.intro.intro.intro.intro.refl
ls : List Name
a✝¹ a✝ : Lean.Level
ih1 : ∀ {l' : VLevel}, ofLevel ls a✝¹ = some l' → WF (List.length ls) l'
ih2 : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
w✝¹ : VLevel
h1 : ofLevel ls a✝¹ = some w✝¹
w✝ : VLevel
h2 : ofLevel ls a✝ = some w✝
⊢ WF (List.length ls) (imax w✝¹ w✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case imax
ls : List Name
a✝¹ a✝ : Lean.Level
ih1 : ∀ {l' : VLevel}, ofLevel ls a✝¹ = some l' → WF (List.length ls) l'
ih2 : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
l' : VLevel
h : ∃ a, ofLevel ls a✝¹ = some a ∧ ∃ a_1, ofLevel ls a✝ = some a_1 ∧ imax a a_1 = l'
⊢ WF (List.length ls) l'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | exact ⟨ih1 h1, ih2 h2⟩ | case imax.intro.intro.intro.intro.refl
ls : List Name
a✝¹ a✝ : Lean.Level
ih1 : ∀ {l' : VLevel}, ofLevel ls a✝¹ = some l' → WF (List.length ls) l'
ih2 : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
w✝¹ : VLevel
h1 : ofLevel ls a✝¹ = some w✝¹
w✝ : VLevel
h2 : ofLevel ls a✝ = some w✝
⊢ WF (List.length ls) (imax w✝¹ w✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case imax.intro.intro.intro.intro.refl
ls : List Name
a✝¹ a✝ : Lean.Level
ih1 : ∀ {l' : VLevel}, ofLevel ls a✝¹ = some l' → WF (List.length ls) l'
ih2 : ∀ {l' : VLevel}, ofLevel ls a✝ = some l' → WF (List.length ls) l'
w✝¹ : VLevel
h1 : ofLevel ls a✝¹ = some w✝¹
w✝ : VLevel
h2 : ofLevel ls a✝ = some w✝
⊢ WF (List.length ls) (imax w✝¹ w✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/VLevel.lean | Lean4Lean.VLevel.WF.of_ofLevel | [113, 1] | [118, 31] | exact h.2 ▸ h.1 | case param
ls : List Name
n : Name
l' : VLevel
h : List.indexOf n ls < List.length ls ∧ param (List.indexOf n ls) = l'
⊢ WF (List.length ls) l' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case param
ls : List Name
n : Name
l' : VLevel
h : List.indexOf n ls < List.length ls ∧ param (List.indexOf n ls) = l'
⊢ WF (List.length ls) l'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | induction H with
| empty => exact ⟨_, .empty⟩
| block _ h _ ih =>
have ⟨_, H⟩ := ih
exact ⟨_, H.decl <| .block h⟩
| «axiom» _ h1 h2 _ ih =>
have ⟨_, H⟩ := ih
exact ⟨_, H.decl <| .axiom (ci := ⟨_, _⟩) h1 h2⟩
| defn h1 h2 h3 _ ih =>
have ⟨_, H⟩ := ih
have := h1.1.2; dsimp [ConstantInfo.name, ConstantInfo.toConstantVal] at this
exact ⟨_, H.decl <| .def h2 (this ▸ h3)⟩
| «opaque» h1 h2 h3 _ ih =>
have ⟨_, H⟩ := ih
have := h1.1.2; dsimp [ConstantInfo.name, ConstantInfo.toConstantVal] at this
exact ⟨_, H.decl <| .opaque h2 (this ▸ h3)⟩
| quot h1 h2 _ _ ih =>
have ⟨_, H⟩ := ih
exact ⟨_, H.decl <| .quot h1 h2⟩
| induct h1 h2 _ _ ih =>
have ⟨_, H⟩ := ih
exact ⟨_, H.decl <| .induct h1 h2⟩ | C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
H : TrEnv' C Q env venv
⊢ ∃ ds, VEnv.WF ds venv | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
H : TrEnv' C Q env venv
⊢ ∃ ds, VEnv.WF ds venv
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, .empty⟩ | case empty
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
⊢ ∃ ds, VEnv.WF ds VEnv.empty | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
⊢ ∃ ds, VEnv.WF ds VEnv.empty
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have ⟨_, H⟩ := ih | case block
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
ci✝ : ConstantInfo
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
a✝¹ : ¬isAsSafeAs C ci✝ = true
h : VEnv.addConst env✝ (ConstantInfo.name ci✝) none = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | case block
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
ci✝ : ConstantInfo
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
a✝¹ : ¬isAsSafeAs C ci✝ = true
h : VEnv.addConst env✝ (ConstantInfo.name ci✝) none = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case block
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
ci✝ : ConstantInfo
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
a✝¹ : ¬isAsSafeAs C ci✝ = true
h : VEnv.addConst env✝ (ConstantInfo.name ci✝) none = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, H.decl <| .block h⟩ | case block
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
ci✝ : ConstantInfo
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
a✝¹ : ¬isAsSafeAs C ci✝ = true
h : VEnv.addConst env✝ (ConstantInfo.name ci✝) none = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case block
C : DefinitionSafety
Q : ConstMap
env : Bool
venv : VEnv
ci✝ : ConstantInfo
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
a✝¹ : ¬isAsSafeAs C ci✝ = true
h : VEnv.addConst env✝ (ConstantInfo.name ci✝) none = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have ⟨_, H⟩ := ih | case axiom
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : AxiomVal
ci'✝ : VConstant
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
a✝¹ : TrConstant C env✝ (ConstantInfo.axiomInfo ci✝) ci'✝
h1 : VConstant.WF env✝ ci'✝
h2 : VEnv.addConst env✝ ci✝.name (some ci'✝) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | case axiom
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : AxiomVal
ci'✝ : VConstant
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
a✝¹ : TrConstant C env✝ (ConstantInfo.axiomInfo ci✝) ci'✝
h1 : VConstant.WF env✝ ci'✝
h2 : VEnv.addConst env✝ ci✝.name (some ci'✝) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case axiom
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : AxiomVal
ci'✝ : VConstant
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
a✝¹ : TrConstant C env✝ (ConstantInfo.axiomInfo ci✝) ci'✝
h1 : VConstant.WF env✝ ci'✝
h2 : VEnv.addConst env✝ ci✝.name (some ci'✝) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, H.decl <| .axiom (ci := ⟨_, _⟩) h1 h2⟩ | case axiom
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : AxiomVal
ci'✝ : VConstant
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
a✝¹ : TrConstant C env✝ (ConstantInfo.axiomInfo ci✝) ci'✝
h1 : VConstant.WF env✝ ci'✝
h2 : VEnv.addConst env✝ ci✝.name (some ci'✝) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case axiom
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : AxiomVal
ci'✝ : VConstant
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
a✝¹ : TrConstant C env✝ (ConstantInfo.axiomInfo ci✝) ci'✝
h1 : VConstant.WF env✝ ci'✝
h2 : VEnv.addConst env✝ ci✝.name (some ci'✝) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have ⟨_, H⟩ := ih | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have := h1.1.2 | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ConstantInfo.name (ConstantInfo.defnInfo ci✝) = ci'✝.name
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | dsimp [ConstantInfo.name, ConstantInfo.toConstantVal] at this | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ConstantInfo.name (ConstantInfo.defnInfo ci✝) = ci'✝.name
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ci✝.name = ci'✝.name
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ConstantInfo.name (ConstantInfo.defnInfo ci✝) = ci'✝.name
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, H.decl <| .def h2 (this ▸ h3)⟩ | case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ci✝.name = ci'✝.name
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defn
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : DefinitionVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.defnInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ci✝.name = ci'✝.name
⊢ ∃ ds, VEnv.WF ds (VEnv.addDefEq env'✝ (VDefVal.toDefEq ci'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have ⟨_, H⟩ := ih | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have := h1.1.2 | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ConstantInfo.name (ConstantInfo.opaqueInfo ci✝) = ci'✝.name
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | dsimp [ConstantInfo.name, ConstantInfo.toConstantVal] at this | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ConstantInfo.name (ConstantInfo.opaqueInfo ci✝) = ci'✝.name
⊢ ∃ ds, VEnv.WF ds env'✝ | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ci✝.name = ci'✝.name
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ConstantInfo.name (ConstantInfo.opaqueInfo ci✝) = ci'✝.name
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, H.decl <| .opaque h2 (this ▸ h3)⟩ | case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ci✝.name = ci'✝.name
⊢ ∃ ds, VEnv.WF ds env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case opaque
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env✝ : VEnv
ci✝ : OpaqueVal
env'✝ : VEnv
C✝ : ConstMap
Q✝ : Bool
ci'✝ : VDefVal
h1 : TrDefVal C env✝ (ConstantInfo.opaqueInfo ci✝) ci'✝
h2 : VDefVal.WF env✝ ci'✝
h3 : VEnv.addConst env✝ ci✝.name (some ci'✝.toVConstant) = some env'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
this : ci✝.name = ci'✝.name
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have ⟨_, H⟩ := ih | case quot
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ env✝ : VEnv
C✝ C'✝ : ConstMap
h1 : VEnv.QuotReady env✝
h2 : VEnv.addQuot env✝ = some env'✝
a✝¹ : AddQuot env✝ C✝ C'✝
a✝ : TrEnv' C C✝ false env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | case quot
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ env✝ : VEnv
C✝ C'✝ : ConstMap
h1 : VEnv.QuotReady env✝
h2 : VEnv.addQuot env✝ = some env'✝
a✝¹ : AddQuot env✝ C✝ C'✝
a✝ : TrEnv' C C✝ false env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case quot
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ env✝ : VEnv
C✝ C'✝ : ConstMap
h1 : VEnv.QuotReady env✝
h2 : VEnv.addQuot env✝ = some env'✝
a✝¹ : AddQuot env✝ C✝ C'✝
a✝ : TrEnv' C C✝ false env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, H.decl <| .quot h1 h2⟩ | case quot
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ env✝ : VEnv
C✝ C'✝ : ConstMap
h1 : VEnv.QuotReady env✝
h2 : VEnv.addQuot env✝ = some env'✝
a✝¹ : AddQuot env✝ C✝ C'✝
a✝ : TrEnv' C C✝ false env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case quot
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ env✝ : VEnv
C✝ C'✝ : ConstMap
h1 : VEnv.QuotReady env✝
h2 : VEnv.addQuot env✝ = some env'✝
a✝¹ : AddQuot env✝ C✝ C'✝
a✝ : TrEnv' C C✝ false env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | have ⟨_, H⟩ := ih | case induct
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ : VEnv
C✝ : ConstMap
decl✝ : VInductDecl
C'✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
h1 : VInductDecl.WF env✝ decl✝
h2 : VEnv.addInduct env✝ decl✝ = some env'✝
a✝¹ : AddInduct C✝ decl✝ C'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | case induct
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ : VEnv
C✝ : ConstMap
decl✝ : VInductDecl
C'✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
h1 : VInductDecl.WF env✝ decl✝
h2 : VEnv.addInduct env✝ decl✝ = some env'✝
a✝¹ : AddInduct C✝ decl✝ C'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case induct
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ : VEnv
C✝ : ConstMap
decl✝ : VInductDecl
C'✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
h1 : VInductDecl.WF env✝ decl✝
h2 : VEnv.addInduct env✝ decl✝ = some env'✝
a✝¹ : AddInduct C✝ decl✝ C'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Environment.lean | Lean4Lean.TrEnv'.WF | [83, 1] | [105, 39] | exact ⟨_, H.decl <| .induct h1 h2⟩ | case induct
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ : VEnv
C✝ : ConstMap
decl✝ : VInductDecl
C'✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
h1 : VInductDecl.WF env✝ decl✝
h2 : VEnv.addInduct env✝ decl✝ = some env'✝
a✝¹ : AddInduct C✝ decl✝ C'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case induct
C : DefinitionSafety
Q : ConstMap
env : Bool
venv env'✝ : VEnv
C✝ : ConstMap
decl✝ : VInductDecl
C'✝ : ConstMap
Q✝ : Bool
env✝ : VEnv
h1 : VInductDecl.WF env✝ decl✝
h2 : VEnv.addInduct env✝ decl✝ = some env'✝
a✝¹ : AddInduct C✝ decl✝ C'✝
a✝ : TrEnv' C C✝ Q✝ env✝
ih : ∃ ds, VEnv.WF ds env✝
w✝ : List VDecl
H : VEnv.WF w✝ env✝
⊢ ∃ ds, VEnv.WF ds env'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.InScope.natLitToConstructor | [41, 1] | [42, 29] | cases n <;> simp [InScope] | P : FVarId → Prop
n k : Nat
⊢ InScope P (Expr.natLitToConstructor n) k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
P : FVarId → Prop
n k : Nat
⊢ InScope P (Expr.natLitToConstructor n) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.InScope.strLitToConstructor | [44, 1] | [45, 74] | simp [InScope, String.foldr_eq] | P : FVarId → Prop
s : String
k : Nat
⊢ InScope P (Expr.strLitToConstructor s) k | P : FVarId → Prop
s : String
k : Nat
⊢ InScope P
(List.foldr
(fun c e =>
Expr.app
(Expr.app (Expr.app (Expr.const `List.cons [Level.zero]) (Expr.const `Char []))
(Expr.app (Expr.const `Char.ofNat []) (Expr.lit (Literal.natVal (Char.toNat c)))))
e)
(Expr.app (Expr.const `List.nil [Level.zero]) (Expr.const `Char [])) s.data)
k | Please generate a tactic in lean4 to solve the state.
STATE:
P : FVarId → Prop
s : String
k : Nat
⊢ InScope P (Expr.strLitToConstructor s) k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.InScope.strLitToConstructor | [44, 1] | [45, 74] | induction s.data <;> simp [*, InScope] | P : FVarId → Prop
s : String
k : Nat
⊢ InScope P
(List.foldr
(fun c e =>
Expr.app
(Expr.app (Expr.app (Expr.const `List.cons [Level.zero]) (Expr.const `Char []))
(Expr.app (Expr.const `Char.ofNat []) (Expr.lit (Literal.natVal (Char.toNat c)))))
e)
(Expr.app (Expr.const `List.nil [Level.zero]) (Expr.const `Char [])) s.data)
k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
P : FVarId → Prop
s : String
k : Nat
⊢ InScope P
(List.foldr
(fun c e =>
Expr.app
(Expr.app (Expr.app (Expr.const `List.cons [Level.zero]) (Expr.const `Char []))
(Expr.app (Expr.const `Char.ofNat []) (Expr.lit (Literal.natVal (Char.toNat c)))))
e)
(Expr.app (Expr.const `List.nil [Level.zero]) (Expr.const `Char [])) s.data)
k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.InScope.fvars_cons | [51, 1] | [53, 52] | cases ofv <;> simp [h] | Δ : VLCtx
e : Expr
k : Nat
ofv : Option FVarId
d : VLocalDecl
a : FVarId
h : a ∈ VLCtx.fvars Δ
⊢ a ∈ VLCtx.fvars ((ofv, d) :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ : VLCtx
e : Expr
k : Nat
ofv : Option FVarId
d : VLocalDecl
a : FVarId
h : a ∈ VLCtx.fvars Δ
⊢ a ∈ VLCtx.fvars ((ofv, d) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | let (ofv, d') :: Δ := Δ | env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ : VLCtx
hΔ : WF env U Δ
H : find? Δ v = some (e, A)
⊢ HasType env U (toCtx Δ) e A | env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
H : find? ((ofv, d') :: Δ) v = some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ : VLCtx
hΔ : WF env U Δ
H : find? Δ v = some (e, A)
⊢ HasType env U (toCtx Δ) e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | unfold VLCtx.find? at H | env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
H : find? ((ofv, d') :: Δ) v = some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
H :
(match next ofv v with
| none => some (VLocalDecl.value d', VLocalDecl.type d')
| some v => do
let __discr ← find? Δ v
match __discr with
| (e, A) => some (VExpr.liftN (VLocalDecl.depth d') e, VExpr.liftN (VLocalDecl.depth d') A)) =
some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
H : find? ((ofv, d') :: Δ) v = some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | split at H | env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
H :
(match next ofv v with
| none => some (VLocalDecl.value d', VLocalDecl.type d')
| some v => do
let __discr ← find? Δ v
match __discr with
| (e, A) => some (VExpr.liftN (VLocalDecl.depth d') e, VExpr.liftN (VLocalDecl.depth d') A)) =
some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | case h_1
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv v = none
H : some (VLocalDecl.value d', VLocalDecl.type d') = some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A
case h_2
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
H :
(do
let __discr ← find? Δ v✝
match __discr with
| (e, A) => some (VExpr.liftN (VLocalDecl.depth d') e, VExpr.liftN (VLocalDecl.depth d') A)) =
some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
H :
(match next ofv v with
| none => some (VLocalDecl.value d', VLocalDecl.type d')
| some v => do
let __discr ← find? Δ v
match __discr with
| (e, A) => some (VExpr.liftN (VLocalDecl.depth d') e, VExpr.liftN (VLocalDecl.depth d') A)) =
some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | cases H | case h_1
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv v = none
H : some (VLocalDecl.value d', VLocalDecl.type d') = some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | case h_1.refl
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv v = none
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) (VLocalDecl.value d') (VLocalDecl.type d') | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv v = none
H : some (VLocalDecl.value d', VLocalDecl.type d') = some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | exact hΔ.2.2.hasType | case h_1.refl
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv v = none
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) (VLocalDecl.value d') (VLocalDecl.type d') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1.refl
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv v = none
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) (VLocalDecl.value d') (VLocalDecl.type d')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | simp [bind, Option.bind_eq_some] at H | case h_2
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
H :
(do
let __discr ← find? Δ v✝
match __discr with
| (e, A) => some (VExpr.liftN (VLocalDecl.depth d') e, VExpr.liftN (VLocalDecl.depth d') A)) =
some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | case h_2
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
H : ∃ a, find? Δ v✝ = some a ∧ VExpr.liftN (VLocalDecl.depth d') a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d') a.snd = A
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
H :
(do
let __discr ← find? Δ v✝
match __discr with
| (e, A) => some (VExpr.liftN (VLocalDecl.depth d') e, VExpr.liftN (VLocalDecl.depth d') A)) =
some (e, A)
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | obtain ⟨⟨d'', n'⟩, H, rfl, rfl⟩ := H | case h_2
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
H : ∃ a, find? Δ v✝ = some a ∧ VExpr.liftN (VLocalDecl.depth d') a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d') a.snd = A
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A | case h_2.intro.mk.intro.intro
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
d'' n' : VExpr
H : find? Δ v✝ = some (d'', n')
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) (VExpr.liftN (VLocalDecl.depth d') (d'', n').fst)
(VExpr.liftN (VLocalDecl.depth d') (d'', n').snd) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
env : VEnv
henv : Ordered env
U : Nat
v : Nat ⊕ FVarId
e A : VExpr
Δ✝ : VLCtx
ofv : Option FVarId
d' : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U ((ofv, d') :: Δ)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv v = some v✝
H : ∃ a, find? Δ v✝ = some a ∧ VExpr.liftN (VLocalDecl.depth d') a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d') a.snd = A
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) e A
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.