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/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | obtain h3 := hΔ.1.find?_wf H | 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) | 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')
h3 : HasType env U (toCtx Δ) 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.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)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.find?_wf | [79, 1] | [87, 44] | exact h3.weakN henv VLocalDecl.is_liftN | 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')
h3 : HasType env U (toCtx Δ) d'' n'
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) (VExpr.liftN (VLocalDecl.depth d') (d'', n').fst)
(VExpr.liftN (VLocalDecl.depth d') (d'', n').snd) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
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')
h3 : HasType env U (toCtx Δ) d'' n'
⊢ HasType env U (toCtx ((ofv, d') :: Δ)) (VExpr.liftN (VLocalDecl.depth d') (d'', n').fst)
(VExpr.liftN (VLocalDecl.depth d') (d'', n').snd)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.fvars_nodup | [94, 1] | [99, 18] | suffices fv ∉ fvars Δ from (fvars_nodup hΔ).cons (fun _ h e => this (e ▸ h)) | env : VEnv
U : Nat
fv : FVarId
snd✝ : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U Δ
h : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ fvars Δ
right✝ : VLocalDecl.WF env U (VLCtx.toCtx Δ) snd✝
⊢ List.Nodup (fvars ((some fv, snd✝) :: Δ)) | env : VEnv
U : Nat
fv : FVarId
snd✝ : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U Δ
h : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ fvars Δ
right✝ : VLocalDecl.WF env U (VLCtx.toCtx Δ) snd✝
⊢ ¬fv ∈ fvars Δ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
fv : FVarId
snd✝ : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U Δ
h : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ fvars Δ
right✝ : VLocalDecl.WF env U (VLCtx.toCtx Δ) snd✝
⊢ List.Nodup (fvars ((some fv, snd✝) :: Δ))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.WF.fvars_nodup | [94, 1] | [99, 18] | simpa using h | env : VEnv
U : Nat
fv : FVarId
snd✝ : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U Δ
h : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ fvars Δ
right✝ : VLocalDecl.WF env U (VLCtx.toCtx Δ) snd✝
⊢ ¬fv ∈ fvars Δ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
fv : FVarId
snd✝ : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
hΔ : WF env U Δ
h : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ fvars Δ
right✝ : VLocalDecl.WF env U (VLCtx.toCtx Δ) snd✝
⊢ ¬fv ∈ fvars Δ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | induction W with
| refl => exact .zero []
| @skip_fvar _ Δ' _ _ d _ ih =>
match d with
| .vlet .. => exact ih
| .vlam A =>
generalize hΓ' : VLCtx.toCtx Δ' = Γ' at ih
let .zero As eq := ih
simp [VLCtx.toCtx, hΓ']
exact .zero (A :: As) (eq ▸ rfl)
| cons_bvar d _ ih =>
match d with
| .vlet .. => exact ih
| .vlam A => exact .succ ih | Δ Δ' : VLCtx
dk n k : Nat
W : LiftN Δ Δ' dk n k
⊢ Ctx.LiftN n k (VLCtx.toCtx Δ) (VLCtx.toCtx Δ') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ' : VLCtx
dk n k : Nat
W : LiftN Δ Δ' dk n k
⊢ Ctx.LiftN n k (VLCtx.toCtx Δ) (VLCtx.toCtx Δ')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | exact .zero [] | case refl
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ : VLCtx
⊢ Ctx.LiftN 0 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ : VLCtx
⊢ Ctx.LiftN 0 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | match d with
| .vlet .. => exact ih
| .vlam A =>
generalize hΓ' : VLCtx.toCtx Δ' = Γ' at ih
let .zero As eq := ih
simp [VLCtx.toCtx, hΓ']
exact .zero (A :: As) (eq ▸ rfl) | case skip_fvar
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ')
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth d) 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx ((some fv✝, d) :: Δ')) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ')
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth d) 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx ((some fv✝, d) :: Δ'))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | exact ih | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ')
type✝ value✝ : VExpr
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlet type✝ value✝)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlet type✝ value✝) :: Δ')) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ')
type✝ value✝ : VExpr
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlet type✝ value✝)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlet type✝ value✝) :: Δ'))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | generalize hΓ' : VLCtx.toCtx Δ' = Γ' at ih | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ')
A : VExpr
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ')) | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
hΓ' : VLCtx.toCtx Δ' = Γ'
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ')) | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ')
A : VExpr
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ'))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | let .zero As eq := ih | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
hΓ' : VLCtx.toCtx Δ' = Γ'
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ')) | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
As : List VExpr
eq : List.length As = n✝
hΓ' : VLCtx.toCtx Δ' = As ++ VLCtx.toCtx Δ✝
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ')) | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
hΓ' : VLCtx.toCtx Δ' = Γ'
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ'))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | simp [VLCtx.toCtx, hΓ'] | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
As : List VExpr
eq : List.length As = n✝
hΓ' : VLCtx.toCtx Δ' = As ++ VLCtx.toCtx Δ✝
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ')) | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
As : List VExpr
eq : List.length As = n✝
hΓ' : VLCtx.toCtx Δ' = As ++ VLCtx.toCtx Δ✝
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝) (A :: (As ++ VLCtx.toCtx Δ✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
As : List VExpr
eq : List.length As = n✝
hΓ' : VLCtx.toCtx Δ' = As ++ VLCtx.toCtx Δ✝
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝)
(VLCtx.toCtx ((some fv✝, VLocalDecl.vlam A) :: Δ'))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | exact .zero (A :: As) (eq ▸ rfl) | Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
As : List VExpr
eq : List.length As = n✝
hΓ' : VLCtx.toCtx Δ' = As ++ VLCtx.toCtx Δ✝
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝) (A :: (As ++ VLCtx.toCtx Δ✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv✝ : FVarId
d : VLocalDecl
a✝ : LiftN Δ✝ Δ' 0 n✝ 0
A : VExpr
Γ' : List VExpr
ih : Ctx.LiftN n✝ 0 (VLCtx.toCtx Δ✝) Γ'
As : List VExpr
eq : List.length As = n✝
hΓ' : VLCtx.toCtx Δ' = As ++ VLCtx.toCtx Δ✝
⊢ Ctx.LiftN (n✝ + VLocalDecl.depth (VLocalDecl.vlam A)) 0 (VLCtx.toCtx Δ✝) (A :: (As ++ VLCtx.toCtx Δ✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | match d with
| .vlet .. => exact ih
| .vlam A => exact .succ ih | case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : Ctx.LiftN n✝ k✝ (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ'✝)
⊢ Ctx.LiftN n✝ (k✝ + VLocalDecl.depth d) (VLCtx.toCtx ((none, d) :: Δ✝))
(VLCtx.toCtx ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : Ctx.LiftN n✝ k✝ (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ'✝)
⊢ Ctx.LiftN n✝ (k✝ + VLocalDecl.depth d) (VLCtx.toCtx ((none, d) :: Δ✝))
(VLCtx.toCtx ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | exact ih | Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : Ctx.LiftN n✝ k✝ (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ'✝)
type✝ value✝ : VExpr
⊢ Ctx.LiftN n✝ (k✝ + VLocalDecl.depth (VLocalDecl.vlet type✝ value✝))
(VLCtx.toCtx ((none, VLocalDecl.vlet type✝ value✝) :: Δ✝))
(VLCtx.toCtx ((none, VLocalDecl.liftN (VLocalDecl.vlet type✝ value✝) n✝ k✝) :: Δ'✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : Ctx.LiftN n✝ k✝ (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ'✝)
type✝ value✝ : VExpr
⊢ Ctx.LiftN n✝ (k✝ + VLocalDecl.depth (VLocalDecl.vlet type✝ value✝))
(VLCtx.toCtx ((none, VLocalDecl.vlet type✝ value✝) :: Δ✝))
(VLCtx.toCtx ((none, VLocalDecl.liftN (VLocalDecl.vlet type✝ value✝) n✝ k✝) :: Δ'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.toCtx | [109, 1] | [123, 32] | exact .succ ih | Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : Ctx.LiftN n✝ k✝ (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ'✝)
A : VExpr
⊢ Ctx.LiftN n✝ (k✝ + VLocalDecl.depth (VLocalDecl.vlam A)) (VLCtx.toCtx ((none, VLocalDecl.vlam A) :: Δ✝))
(VLCtx.toCtx ((none, VLocalDecl.liftN (VLocalDecl.vlam A) n✝ k✝) :: Δ'✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : Ctx.LiftN n✝ k✝ (VLCtx.toCtx Δ✝) (VLCtx.toCtx Δ'✝)
A : VExpr
⊢ Ctx.LiftN n✝ (k✝ + VLocalDecl.depth (VLocalDecl.vlam A)) (VLCtx.toCtx ((none, VLocalDecl.vlam A) :: Δ✝))
(VLCtx.toCtx ((none, VLocalDecl.liftN (VLocalDecl.vlam A) n✝ k✝) :: Δ'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.wf | [126, 1] | [132, 78] | induction W with
| refl => exact hΔ'
| skip_fvar _ _ _ ih => exact ih hΔ'.1
| cons_bvar _ W ih =>
let ⟨hΔ', _, h2⟩ := hΔ'
exact ⟨ih hΔ', nofun, (VLocalDecl.weakN_iff henv hΔ'.toCtx W.toCtx).1 h2⟩ | env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
W : LiftN Δ Δ' dk n k
hΔ' : WF env U Δ'
⊢ WF env U Δ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
W : LiftN Δ Δ' dk n k
hΔ' : WF env U Δ'
⊢ WF env U Δ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.wf | [126, 1] | [132, 78] | exact hΔ' | case refl
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ : VLCtx
hΔ' : WF env U Δ✝
⊢ WF env U Δ✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ : VLCtx
hΔ' : WF env U Δ✝
⊢ WF env U Δ✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.wf | [126, 1] | [132, 78] | exact ih hΔ'.1 | case skip_fvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
n✝ : Nat
fv✝ : FVarId
d✝ : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ 0 n✝ 0
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ' : WF env U ((some fv✝, d✝) :: Δ'✝)
⊢ WF env U Δ✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
n✝ : Nat
fv✝ : FVarId
d✝ : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ 0 n✝ 0
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ' : WF env U ((some fv✝, d✝) :: Δ'✝)
⊢ WF env U Δ✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.wf | [126, 1] | [132, 78] | let ⟨hΔ', _, h2⟩ := hΔ' | case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
W : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ' : WF env U ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝)
⊢ WF env U ((none, d✝) :: Δ✝) | case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
W : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ'✝ : WF env U ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝)
hΔ' : WF env U Δ'✝
left✝ : ∀ (fv : FVarId), none = some fv → ¬fv ∈ fvars Δ'✝
h2 : VLocalDecl.WF env U (VLCtx.toCtx Δ'✝) (VLocalDecl.liftN d✝ n✝ k✝)
⊢ WF env U ((none, d✝) :: Δ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
W : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ' : WF env U ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝)
⊢ WF env U ((none, d✝) :: Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.wf | [126, 1] | [132, 78] | exact ⟨ih hΔ', nofun, (VLocalDecl.weakN_iff henv hΔ'.toCtx W.toCtx).1 h2⟩ | case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
W : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ'✝ : WF env U ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝)
hΔ' : WF env U Δ'✝
left✝ : ∀ (fv : FVarId), none = some fv → ¬fv ∈ fvars Δ'✝
h2 : VLocalDecl.WF env U (VLCtx.toCtx Δ'✝) (VLocalDecl.liftN d✝ n✝ k✝)
⊢ WF env U ((none, d✝) :: Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
W : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : WF env U Δ'✝ → WF env U Δ✝
hΔ'✝ : WF env U ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝)
hΔ' : WF env U Δ'✝
left✝ : ∀ (fv : FVarId), none = some fv → ¬fv ∈ fvars Δ'✝
h2 : VLocalDecl.WF env U (VLCtx.toCtx Δ'✝) (VLocalDecl.liftN d✝ n✝ k✝)
⊢ WF env U ((none, d✝) :: Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.fvars_suffix | [135, 1] | [139, 33] | induction W with
| refl => exact List.suffix_refl _
| skip_fvar _ _ _ ih => exact ih.trans (List.suffix_cons ..)
| cons_bvar _ _ ih => exact ih | env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
W : LiftN Δ Δ' dk n k
⊢ fvars Δ <:+ fvars Δ' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
W : LiftN Δ Δ' dk n k
⊢ fvars Δ <:+ fvars Δ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.fvars_suffix | [135, 1] | [139, 33] | exact List.suffix_refl _ | case refl
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ : VLCtx
⊢ fvars Δ✝ <:+ fvars Δ✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ : VLCtx
⊢ fvars Δ✝ <:+ fvars Δ✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.fvars_suffix | [135, 1] | [139, 33] | exact ih.trans (List.suffix_cons ..) | case skip_fvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
n✝ : Nat
fv✝ : FVarId
d✝ : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ 0 n✝ 0
ih : fvars Δ✝ <:+ fvars Δ'✝
⊢ fvars Δ✝ <:+ fvars ((some fv✝, d✝) :: Δ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
n✝ : Nat
fv✝ : FVarId
d✝ : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ 0 n✝ 0
ih : fvars Δ✝ <:+ fvars Δ'✝
⊢ fvars Δ✝ <:+ fvars ((some fv✝, d✝) :: Δ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.fvars_suffix | [135, 1] | [139, 33] | exact ih | case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : fvars Δ✝ <:+ fvars Δ'✝
⊢ fvars ((none, d✝) :: Δ✝) <:+ fvars ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d✝ : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih : fvars Δ✝ <:+ fvars Δ'✝
⊢ fvars ((none, d✝) :: Δ✝) <:+ fvars ((none, VLocalDecl.liftN d✝ n✝ k✝) :: Δ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | simp [H] | case refl
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ : VLCtx
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U Δ✝
H : VLCtx.find? Δ✝ v = some (e, A)
⊢ VLCtx.find? Δ✝ v = some (VExpr.liftN 0 e, VExpr.liftN 0 A) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ : VLCtx
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U Δ✝
H : VLCtx.find? Δ✝ v = some (e, A)
⊢ VLCtx.find? Δ✝ v = some (VExpr.liftN 0 e, VExpr.liftN 0 A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | simp [VLCtx.find?] | case skip_fvar
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
H : VLCtx.find? Δ✝ v = some (e, A)
⊢ VLCtx.find? ((some fv', d✝) :: Δ') v =
some (VExpr.liftN (n✝ + VLocalDecl.depth d✝) e, VExpr.liftN (n✝ + VLocalDecl.depth d✝) A) | case skip_fvar
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
H : VLCtx.find? Δ✝ v = some (e, A)
⊢ (match next (some fv') v with
| none => some (VLocalDecl.value d✝, VLocalDecl.type d✝)
| some v =>
Option.bind (VLCtx.find? Δ' v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d✝) __discr.fst, VExpr.liftN (VLocalDecl.depth d✝) __discr.snd)) =
some (VExpr.liftN (n✝ + VLocalDecl.depth d✝) e, VExpr.liftN (n✝ + VLocalDecl.depth d✝) A) | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
H : VLCtx.find? Δ✝ v = some (e, A)
⊢ VLCtx.find? ((some fv', d✝) :: Δ') v =
some (VExpr.liftN (n✝ + VLocalDecl.depth d✝) e, VExpr.liftN (n✝ + VLocalDecl.depth d✝) A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | exact ⟨_, ih hΔ'.1 H, by simp [VExpr.liftN_liftN]⟩ | case skip_fvar.inl
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
val✝ : Nat
H : VLCtx.find? Δ✝ (Sum.inl val✝) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ' (Sum.inl val✝) = some a ∧
VExpr.liftN (VLocalDecl.depth d✝) a.fst = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) a.snd = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar.inl
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
val✝ : Nat
H : VLCtx.find? Δ✝ (Sum.inl val✝) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ' (Sum.inl val✝) = some a ∧
VExpr.liftN (VLocalDecl.depth d✝) a.fst = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) a.snd = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | simp [VExpr.liftN_liftN] | Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
val✝ : Nat
H : VLCtx.find? Δ✝ (Sum.inl val✝) = some (e, A)
⊢ VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).fst =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).snd =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
val✝ : Nat
H : VLCtx.find? Δ✝ (Sum.inl val✝) = some (e, A)
⊢ VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).fst =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).snd =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | cases eq : fv' == fv <;> simp | case skip_fvar.inr
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ (match if (fv' == fv) = true then none else some (Sum.inr fv) with
| none => some (VLocalDecl.value d✝, VLocalDecl.type d✝)
| some v =>
Option.bind (VLCtx.find? Δ' v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d✝) __discr.fst, VExpr.liftN (VLocalDecl.depth d✝) __discr.snd)) =
some (VExpr.liftN (n✝ + VLocalDecl.depth d✝) e, VExpr.liftN (n✝ + VLocalDecl.depth d✝) A) | case skip_fvar.inr.false
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = false
⊢ ∃ a,
VLCtx.find? Δ' (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth d✝) a.fst = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) a.snd = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A
case skip_fvar.inr.true
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = true
⊢ VLocalDecl.value d✝ = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VLocalDecl.type d✝ = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar.inr
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ (match if (fv' == fv) = true then none else some (Sum.inr fv) with
| none => some (VLocalDecl.value d✝, VLocalDecl.type d✝)
| some v =>
Option.bind (VLCtx.find? Δ' v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d✝) __discr.fst, VExpr.liftN (VLocalDecl.depth d✝) __discr.snd)) =
some (VExpr.liftN (n✝ + VLocalDecl.depth d✝) e, VExpr.liftN (n✝ + VLocalDecl.depth d✝) A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | exact ⟨_, ih hΔ'.1 H, by simp [VExpr.liftN_liftN]⟩ | case skip_fvar.inr.false
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = false
⊢ ∃ a,
VLCtx.find? Δ' (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth d✝) a.fst = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) a.snd = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar.inr.false
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = false
⊢ ∃ a,
VLCtx.find? Δ' (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth d✝) a.fst = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) a.snd = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | simp [VExpr.liftN_liftN] | Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = false
⊢ VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).fst =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).snd =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = false
⊢ VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).fst =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VExpr.liftN (VLocalDecl.depth d✝) (VExpr.liftN n✝ e, VExpr.liftN n✝ A).snd =
VExpr.liftN (n✝ + VLocalDecl.depth d✝) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | refine ((List.pairwise_cons.1 hΔ'.fvars_nodup).1 fv' ?_ rfl).elim | case skip_fvar.inr.true
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = true
⊢ VLocalDecl.value d✝ = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VLocalDecl.type d✝ = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A | case skip_fvar.inr.true
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = true
⊢ fv' ∈ List.filterMap (fun x => x.fst) Δ' | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar.inr.true
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = true
⊢ VLocalDecl.value d✝ = VExpr.liftN (n✝ + VLocalDecl.depth d✝) e ∧
VLocalDecl.type d✝ = VExpr.liftN (n✝ + VLocalDecl.depth d✝) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | exact W.fvars_suffix.subset ((beq_iff_eq ..).1 eq ▸ find?_eq_some.1 ⟨_, H⟩) | case skip_fvar.inr.true
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = true
⊢ fv' ∈ List.filterMap (fun x => x.fst) Δ' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip_fvar.inr.true
Δ Δ'✝ : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ' : VLCtx
n✝ : Nat
fv' : FVarId
d✝ : VLocalDecl
W : LiftN Δ✝ Δ' 0 n✝ 0
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ' → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ' v = some (VExpr.liftN n✝ e, VExpr.liftN n✝ A)
e A : VExpr
hΔ' : WF env U ((some fv', d✝) :: Δ')
fv : FVarId
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
eq : (fv' == fv) = true
⊢ fv' ∈ List.filterMap (fun x => x.fst) Δ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | simp [VLCtx.find?] at H ⊢ | case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H : VLCtx.find? ((none, d) :: Δ✝) v = some (e, A)
⊢ VLCtx.find? ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝) v =
some (VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d), VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d)) | case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H :
(match next none v with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (VLCtx.find? Δ✝ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) =
some (e, A)
⊢ (match next none v with
| none => some (VLocalDecl.value (VLocalDecl.liftN d n✝ k✝), VLocalDecl.type (VLocalDecl.liftN d n✝ k✝))
| some v =>
Option.bind (VLCtx.find? Δ'✝ v) fun __discr =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) __discr.fst,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) __discr.snd)) =
some (VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d), VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d)) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H : VLCtx.find? ((none, d) :: Δ✝) v = some (e, A)
⊢ VLCtx.find? ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝) v =
some (VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d), VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | obtain ⟨_|i⟩ | fv := v <;> simp [VLCtx.next, bind] at H ⊢ <;>
[(obtain ⟨rfl, rfl⟩ := H);
(obtain ⟨⟨e, A⟩, H, rfl, rfl⟩ := H
refine ⟨_, ih (v := .inl i) hΔ'.1 H, ?_⟩);
(obtain ⟨⟨e, A⟩, H, rfl, rfl⟩ := H
refine ⟨_, ih (v := .inr fv) hΔ'.1 H, ?_⟩)] <;>
open VLocalDecl in
cases d <;> simp [VExpr.lift_liftN', liftN, value, type, depth, VExpr.liftN] | case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H :
(match next none v with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (VLCtx.find? Δ✝ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) =
some (e, A)
⊢ (match next none v with
| none => some (VLocalDecl.value (VLocalDecl.liftN d n✝ k✝), VLocalDecl.type (VLocalDecl.liftN d n✝ k✝))
| some v =>
Option.bind (VLCtx.find? Δ'✝ v) fun __discr =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) __discr.fst,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) __discr.snd)) =
some (VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d), VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
v : Nat ⊕ FVarId
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H :
(match next none v with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (VLCtx.find? Δ✝ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) =
some (e, A)
⊢ (match next none v with
| none => some (VLocalDecl.value (VLocalDecl.liftN d n✝ k✝), VLocalDecl.type (VLocalDecl.liftN d n✝ k✝))
| some v =>
Option.bind (VLCtx.find? Δ'✝ v) fun __discr =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) __discr.fst,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) __discr.snd)) =
some (VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d), VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | obtain ⟨rfl, rfl⟩ := H | case cons_bvar.inl.zero
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H : VLocalDecl.value d = e ∧ VLocalDecl.type d = A
⊢ VLocalDecl.value (VLocalDecl.liftN d n✝ k✝) = VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d) ∧
VLocalDecl.type (VLocalDecl.liftN d n✝ k✝) = VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d) | case cons_bvar.inl.zero.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
⊢ VLocalDecl.value (VLocalDecl.liftN d n✝ k✝) = VExpr.liftN n✝ (VLocalDecl.value d) (k✝ + VLocalDecl.depth d) ∧
VLocalDecl.type (VLocalDecl.liftN d n✝ k✝) = VExpr.liftN n✝ (VLocalDecl.type d) (k✝ + VLocalDecl.depth d) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar.inl.zero
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
H : VLocalDecl.value d = e ∧ VLocalDecl.type d = A
⊢ VLocalDecl.value (VLocalDecl.liftN d n✝ k✝) = VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d) ∧
VLocalDecl.type (VLocalDecl.liftN d n✝ k✝) = VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | obtain ⟨⟨e, A⟩, H, rfl, rfl⟩ := H | case cons_bvar.inl.succ
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
i : Nat
H :
∃ a,
VLCtx.find? Δ✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth d) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d) a.snd = A
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst = VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd = VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d) | case cons_bvar.inl.succ.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
i : Nat
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inl i) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar.inl.succ
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
i : Nat
H :
∃ a,
VLCtx.find? Δ✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth d) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d) a.snd = A
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst = VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd = VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | refine ⟨_, ih (v := .inl i) hΔ'.1 H, ?_⟩ | case cons_bvar.inl.succ.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
i : Nat
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inl i) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | case cons_bvar.inl.succ.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
i : Nat
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inl i) = some (e, A)
⊢ VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar.inl.succ.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
i : Nat
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inl i) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inl i) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | obtain ⟨⟨e, A⟩, H, rfl, rfl⟩ := H | case cons_bvar.inr
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
H :
∃ a,
VLCtx.find? Δ✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth d) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d) a.snd = A
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst = VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd = VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d) | case cons_bvar.inr.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar.inr
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
e A : VExpr
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
H :
∃ a,
VLCtx.find? Δ✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth d) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth d) a.snd = A
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst = VExpr.liftN n✝ e (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd = VExpr.liftN n✝ A (k✝ + VLocalDecl.depth d)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | refine ⟨_, ih (v := .inr fv) hΔ'.1 H, ?_⟩ | case cons_bvar.inr.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | case cons_bvar.inr.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar.inr.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ ∃ a,
VLCtx.find? Δ'✝ (Sum.inr fv) = some a ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) a.snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.LiftN.find? | [141, 1] | [163, 83] | cases d <;> simp [VExpr.lift_liftN', liftN, value, type, depth, VExpr.liftN] | case cons_bvar.inr.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons_bvar.inr.intro.mk.intro.intro
Δ Δ' : VLCtx
dk n k : Nat
env : VEnv
U : Nat
Δ✝ Δ'✝ : VLCtx
dk✝ n✝ k✝ : Nat
d : VLocalDecl
a✝ : LiftN Δ✝ Δ'✝ dk✝ n✝ k✝
ih :
∀ {v : Nat ⊕ FVarId} {e A : VExpr},
WF env U Δ'✝ → VLCtx.find? Δ✝ v = some (e, A) → VLCtx.find? Δ'✝ v = some (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝)
hΔ' : WF env U ((none, VLocalDecl.liftN d n✝ k✝) :: Δ'✝)
fv : FVarId
e A : VExpr
H : VLCtx.find? Δ✝ (Sum.inr fv) = some (e, A)
⊢ VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).fst =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).fst) (k✝ + VLocalDecl.depth d) ∧
VExpr.liftN (VLocalDecl.depth (VLocalDecl.liftN d n✝ k✝)) (VExpr.liftN n✝ e k✝, VExpr.liftN n✝ A k✝).snd =
VExpr.liftN n✝ (VExpr.liftN (VLocalDecl.depth d) (e, A).snd) (k✝ + VLocalDecl.depth d)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | induction H generalizing Δ' dk k with
| bvar h1 => exact .bvar (W.find? hΔ' h1)
| fvar h1 => exact .fvar (W.find? hΔ' h1)
| sort h1 => exact .sort h1
| const h1 h2 h3 => exact .const h1 h2 h3
| app h1 h2 _ _ ih1 ih2 =>
exact .app (h1.weakN henv W.toCtx) (h2.weakN henv W.toCtx) (ih1 W hΔ') (ih2 W hΔ')
| lam h1 _ _ ih1 ih2 =>
have h1 := h1.weakN henv W.toCtx
exact .lam h1 (ih1 W hΔ') (ih2 (W.cons_bvar _) ⟨hΔ', nofun, h1⟩)
| forallE h1 h2 _ _ ih1 ih2 =>
have h1 := h1.weakN henv W.toCtx
have h2 := h2.weakN henv W.toCtx.succ
exact .forallE h1 h2 (ih1 W hΔ') (ih2 (W.cons_bvar _) ⟨hΔ', nofun, h1⟩)
| letE h1 _ _ _ ih1 ih2 ih3 =>
have h1 := h1.weakN henv W.toCtx
exact .letE h1 (ih1 W hΔ') (ih2 W hΔ') (ih3 (W.cons_bvar _) ⟨hΔ', nofun, h1⟩)
| lit _ ih => exact .lit (ih W hΔ')
| mdata _ ih => exact .mdata (ih W hΔ')
| proj _ h2 ih => exact .proj (ih W hΔ') (h2.weakN W.toCtx) | env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Us : List Name
e : Expr
e' : VExpr
W : VLCtx.LiftN Δ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
H : TrExpr env Us Δ e e'
⊢ TrExpr env Us Δ' e (VExpr.liftN n e' k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Δ Δ' : VLCtx
dk n k : Nat
Us : List Name
e : Expr
e' : VExpr
W : VLCtx.LiftN Δ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
H : TrExpr env Us Δ e e'
⊢ TrExpr env Us Δ' e (VExpr.liftN n e' k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .bvar (W.find? hΔ' h1) | case bvar
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
i✝ : Nat
h1 : VLCtx.find? Δ✝ (Sum.inl i✝) = some (e✝, A✝)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.bvar i✝) (VExpr.liftN n e✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
i✝ : Nat
h1 : VLCtx.find? Δ✝ (Sum.inl i✝) = some (e✝, A✝)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.bvar i✝) (VExpr.liftN n e✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .fvar (W.find? hΔ' h1) | case fvar
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
fv✝ : FVarId
h1 : VLCtx.find? Δ✝ (Sum.inr fv✝) = some (e✝, A✝)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.fvar fv✝) (VExpr.liftN n e✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case fvar
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
fv✝ : FVarId
h1 : VLCtx.find? Δ✝ (Sum.inr fv✝) = some (e✝, A✝)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.fvar fv✝) (VExpr.liftN n e✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .sort h1 | case sort
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
u✝ : Level
u'✝ : VLevel
Δ✝ : VLCtx
h1 : VLevel.ofLevel Us u✝ = some u'✝
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.sort u✝) (VExpr.liftN n (VExpr.sort u'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sort
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
u✝ : Level
u'✝ : VLevel
Δ✝ : VLCtx
h1 : VLevel.ofLevel Us u✝ = some u'✝
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.sort u✝) (VExpr.liftN n (VExpr.sort u'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .const h1 h2 h3 | case const
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h2 : List.mapM (VLevel.ofLevel Us) us✝ = some us'✝
h3 : List.length us✝ = ci✝.uvars
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.const c✝ us✝) (VExpr.liftN n (VExpr.const c✝ us'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h2 : List.mapM (VLevel.ofLevel Us) us✝ = some us'✝
h3 : List.length us✝ = ci✝.uvars
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.const c✝ us✝) (VExpr.liftN n (VExpr.const c✝ us'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .app (h1.weakN henv W.toCtx) (h2.weakN henv W.toCtx) (ih1 W hΔ') (ih2 W hΔ') | case app
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' f'✝ A✝ B✝ a'✝ : VExpr
Δ✝ : VLCtx
f✝ a✝² : Expr
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ✝) f'✝ (VExpr.forallE A✝ B✝)
h2 : HasType env (List.length Us) (VLCtx.toCtx Δ✝) a'✝ A✝
a✝¹ : TrExpr env Us Δ✝ f✝ f'✝
a✝ : TrExpr env Us Δ✝ a✝² a'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' f✝ (VExpr.liftN n f'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' a✝² (VExpr.liftN n a'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.app f✝ a✝²) (VExpr.liftN n (VExpr.app f'✝ a'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case app
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' f'✝ A✝ B✝ a'✝ : VExpr
Δ✝ : VLCtx
f✝ a✝² : Expr
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ✝) f'✝ (VExpr.forallE A✝ B✝)
h2 : HasType env (List.length Us) (VLCtx.toCtx Δ✝) a'✝ A✝
a✝¹ : TrExpr env Us Δ✝ f✝ f'✝
a✝ : TrExpr env Us Δ✝ a✝² a'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' f✝ (VExpr.liftN n f'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' a✝² (VExpr.liftN n a'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.app f✝ a✝²) (VExpr.liftN n (VExpr.app f'✝ a'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | have h1 := h1.weakN henv W.toCtx | case lam
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : BinderInfo
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.lam name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.lam ty'✝ body'✝) k) | case lam
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.lam name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.lam ty'✝ body'✝) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case lam
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : BinderInfo
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.lam name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.lam ty'✝ body'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .lam h1 (ih1 W hΔ') (ih2 (W.cons_bvar _) ⟨hΔ', nofun, h1⟩) | case lam
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.lam name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.lam ty'✝ body'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lam
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.lam name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.lam ty'✝ body'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | have h1 := h1.weakN henv W.toCtx | case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2 : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k) | case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2 : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2 : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | have h2 := h2.weakN henv W.toCtx.succ | case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2 : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k) | case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2✝ : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
h2 : IsType env (List.length Us) (VExpr.liftN n ty'✝ k :: VLCtx.toCtx Δ') (VExpr.liftN n body'✝ (k + 1))
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2 : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .forallE h1 h2 (ih1 W hΔ') (ih2 (W.cons_bvar _) ⟨hΔ', nofun, h1⟩) | case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2✝ : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
h2 : IsType env (List.length Us) (VExpr.liftN n ty'✝ k :: VLCtx.toCtx Δ') (VExpr.liftN n body'✝ (k + 1))
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
h1✝ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
h2✝ : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlam ty'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : IsType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n ty'✝ k)
h2 : IsType env (List.length Us) (VExpr.liftN n ty'✝ k :: VLCtx.toCtx Δ') (VExpr.liftN n body'✝ (k + 1))
⊢ TrExpr env Us Δ' (Expr.forallE name✝ ty✝ body✝ bi✝) (VExpr.liftN n (VExpr.forallE ty'✝ body'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | have h1 := h1.weakN henv W.toCtx | case letE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' val✝ (VExpr.liftN n val'✝ k)
ih3 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VExpr.liftN n body'✝ k) | case letE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
h1✝ : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' val✝ (VExpr.liftN n val'✝ k)
ih3 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n val'✝ k) (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VExpr.liftN n body'✝ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case letE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' val✝ (VExpr.liftN n val'✝ k)
ih3 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VExpr.liftN n body'✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .letE h1 (ih1 W hΔ') (ih2 W hΔ') (ih3 (W.cons_bvar _) ⟨hΔ', nofun, h1⟩) | case letE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
h1✝ : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' val✝ (VExpr.liftN n val'✝ k)
ih3 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n val'✝ k) (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VExpr.liftN n body'✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case letE
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
h1✝ : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' ty✝ (VExpr.liftN n ty'✝ k)
ih2 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' val✝ (VExpr.liftN n val'✝ k)
ih3 :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' body✝ (VExpr.liftN n body'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
h1 : HasType env (List.length Us) (VLCtx.toCtx Δ') (VExpr.liftN n val'✝ k) (VExpr.liftN n ty'✝ k)
⊢ TrExpr env Us Δ' (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VExpr.liftN n body'✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .lit (ih W hΔ') | case lit
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : VExpr
l✝ : Literal
a✝ : TrExpr env Us Δ✝ (Literal.toConstructor l✝) e✝
ih :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' (Literal.toConstructor l✝) (VExpr.liftN n e✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.lit l✝) (VExpr.liftN n e✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lit
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : VExpr
l✝ : Literal
a✝ : TrExpr env Us Δ✝ (Literal.toConstructor l✝) e✝
ih :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k →
VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' (Literal.toConstructor l✝) (VExpr.liftN n e✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.lit l✝) (VExpr.liftN n e✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .mdata (ih W hΔ') | case mdata
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
d✝ : MData
a✝ : TrExpr env Us Δ✝ e✝ e'✝
ih :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' e✝ (VExpr.liftN n e'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.mdata d✝ e✝) (VExpr.liftN n e'✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mdata
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
d✝ : MData
a✝ : TrExpr env Us Δ✝ e✝ e'✝
ih :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' e✝ (VExpr.liftN n e'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.mdata d✝ e✝) (VExpr.liftN n e'✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.weakN | [171, 1] | [192, 62] | exact .proj (ih W hΔ') (h2.weakN W.toCtx) | case proj
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
s✝ : Name
i✝ : Nat
e''✝ : VExpr
a✝ : TrExpr env Us Δ✝ e✝ e'✝
h2 : TrProj (VLCtx.toCtx Δ✝) s✝ i✝ e'✝ e''✝
ih :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' e✝ (VExpr.liftN n e'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.proj s✝ i✝ e✝) (VExpr.liftN n e''✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proj
env : VEnv
henv : Ordered env
Δ : VLCtx
n : Nat
Us : List Name
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
s✝ : Name
i✝ : Nat
e''✝ : VExpr
a✝ : TrExpr env Us Δ✝ e✝ e'✝
h2 : TrProj (VLCtx.toCtx Δ✝) s✝ i✝ e'✝ e''✝
ih :
∀ {Δ' : VLCtx} {dk k : Nat},
VLCtx.LiftN Δ✝ Δ' dk n k → VLCtx.WF env (List.length Us) Δ' → TrExpr env Us Δ' e✝ (VExpr.liftN n e'✝ k)
Δ' : VLCtx
dk k : Nat
W : VLCtx.LiftN Δ✝ Δ' dk n k
hΔ' : VLCtx.WF env (List.length Us) Δ'
⊢ TrExpr env Us Δ' (Expr.proj s✝ i✝ e✝) (VExpr.liftN n e''✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.fvars | [230, 1] | [233, 57] | simp | env : VEnv
U : Nat
Δ₁ Δ₂ : VLCtx
⊢ VLCtx.fvars [] = VLCtx.fvars [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Δ₁ Δ₂ : VLCtx
⊢ VLCtx.fvars [] = VLCtx.fvars []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.fvars | [230, 1] | [233, 57] | simp [h1.fvars] | env : VEnv
U : Nat
Δ₁ Δ₂ : VLCtx
fv : FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
h1 : IsDefEq env U Δ₁✝ Δ₂✝
h2 : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ VLCtx.fvars Δ₁✝
a✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
⊢ VLCtx.fvars ((some fv, d₁✝) :: Δ₁✝) = VLCtx.fvars ((some fv, d₂✝) :: Δ₂✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Δ₁ Δ₂ : VLCtx
fv : FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
h1 : IsDefEq env U Δ₁✝ Δ₂✝
h2 : ∀ (fv_1 : FVarId), some fv = some fv_1 → ¬fv_1 ∈ VLCtx.fvars Δ₁✝
a✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
⊢ VLCtx.fvars ((some fv, d₁✝) :: Δ₁✝) = VLCtx.fvars ((some fv, d₂✝) :: Δ₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.symm | [254, 1] | [257, 85] | simpa [h1.fvars] using h2 | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
h1 : IsDefEq env U Δ₁✝ Δ₂✝
h2 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h3 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
⊢ ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₂✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
h1 : IsDefEq env U Δ₁✝ Δ₂✝
h2 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h3 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
⊢ ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₂✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | let .cons hΔ h1 h2 := hΔ | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ : IsDefEq env U Δ₁ Δ₂
H1 : find? Δ₁ v = some (e₁, A₁)
H2 : find? Δ₂ v = some (e₂, A₂)
⊢ IsDefEqU env U (toCtx Δ₁) A₁ A₂ ∧ VEnv.IsDefEq env U (toCtx Δ₁) e₁ e₂ A₁ | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
H1 : find? ((ofv✝, d₁✝) :: Δ₁✝) v = some (e₁, A₁)
H2 : find? ((ofv✝, d₂✝) :: Δ₂✝) v = some (e₂, A₂)
⊢ IsDefEqU env U (toCtx ((ofv✝, d₁✝) :: Δ₁✝)) A₁ A₂ ∧ VEnv.IsDefEq env U (toCtx ((ofv✝, d₁✝) :: Δ₁✝)) e₁ e₂ A₁ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ : IsDefEq env U Δ₁ Δ₂
H1 : find? Δ₁ v = some (e₁, A₁)
H2 : find? Δ₂ v = some (e₂, A₂)
⊢ IsDefEqU env U (toCtx Δ₁) A₁ A₂ ∧ VEnv.IsDefEq env U (toCtx Δ₁) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | revert H1 H2 | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
H1 : find? ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝) v = some (e₁, A₁✝)
H2 : find? ((ofv✝, VLocalDecl.vlam A₂) :: Δ₂✝) v = some (e₂, A₂✝)
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
⊢ find? ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝) v = some (e₁, A₁✝) →
find? ((ofv✝, VLocalDecl.vlam A₂) :: Δ₂✝) v = some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
H1 : find? ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝) v = some (e₁, A₁✝)
H2 : find? ((ofv✝, VLocalDecl.vlam A₂) :: Δ₂✝) v = some (e₂, A₂✝)
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | unfold VLCtx.find? | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
⊢ find? ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝) v = some (e₁, A₁✝) →
find? ((ofv✝, VLocalDecl.vlam A₂) :: Δ₂✝) v = some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
⊢ (match next ofv✝ v with
| none => some (VLocalDecl.value (VLocalDecl.vlam A₁), VLocalDecl.type (VLocalDecl.vlam A₁))
| some v => do
let __discr ← find? Δ₁✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) A)) =
some (e₁, A₁✝) →
(match next ofv✝ v with
| none => some (VLocalDecl.value (VLocalDecl.vlam A₂), VLocalDecl.type (VLocalDecl.vlam A₂))
| some v => do
let __discr ← find? Δ₂✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) A)) =
some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
⊢ find? ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝) v = some (e₁, A₁✝) →
find? ((ofv✝, VLocalDecl.vlam A₂) :: Δ₂✝) v = some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | split | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
⊢ (match next ofv✝ v with
| none => some (VLocalDecl.value (VLocalDecl.vlam A₁), VLocalDecl.type (VLocalDecl.vlam A₁))
| some v => do
let __discr ← find? Δ₁✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) A)) =
some (e₁, A₁✝) →
(match next ofv✝ v with
| none => some (VLocalDecl.value (VLocalDecl.vlam A₂), VLocalDecl.type (VLocalDecl.vlam A₂))
| some v => do
let __discr ← find? Δ₂✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) A)) =
some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | case h_1
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ some (VLocalDecl.value (VLocalDecl.vlam A₁), VLocalDecl.type (VLocalDecl.vlam A₁)) = some (e₁, A₁✝) →
some (VLocalDecl.value (VLocalDecl.vlam A₂), VLocalDecl.type (VLocalDecl.vlam A₂)) = some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ (do
let __discr ← find? Δ₁✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) A)) =
some (e₁, A₁✝) →
(do
let __discr ← find? Δ₂✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) A)) =
some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
⊢ (match next ofv✝ v with
| none => some (VLocalDecl.value (VLocalDecl.vlam A₁), VLocalDecl.type (VLocalDecl.vlam A₁))
| some v => do
let __discr ← find? Δ₁✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) A)) =
some (e₁, A₁✝) →
(match next ofv✝ v with
| none => some (VLocalDecl.value (VLocalDecl.vlam A₂), VLocalDecl.type (VLocalDecl.vlam A₂))
| some v => do
let __discr ← find? Δ₂✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) A)) =
some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | rintro ⟨⟩ ⟨⟩ | case h_1
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ some (VLocalDecl.value (VLocalDecl.vlam A₁), VLocalDecl.type (VLocalDecl.vlam A₁)) = some (e₁, A₁✝) →
some (VLocalDecl.value (VLocalDecl.vlam A₂), VLocalDecl.type (VLocalDecl.vlam A₂)) = some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | case h_1.refl.refl
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) (VLocalDecl.type (VLocalDecl.vlam A₁))
(VLocalDecl.type (VLocalDecl.vlam A₂)) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) (VLocalDecl.value (VLocalDecl.vlam A₁))
(VLocalDecl.value (VLocalDecl.vlam A₂)) (VLocalDecl.type (VLocalDecl.vlam A₁)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ some (VLocalDecl.value (VLocalDecl.vlam A₁), VLocalDecl.type (VLocalDecl.vlam A₁)) = some (e₁, A₁✝) →
some (VLocalDecl.value (VLocalDecl.vlam A₂), VLocalDecl.type (VLocalDecl.vlam A₂)) = some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | exact ⟨⟨_, h2.weak henv⟩, .bvar .zero⟩ | case h_1.refl.refl
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) (VLocalDecl.type (VLocalDecl.vlam A₁))
(VLocalDecl.type (VLocalDecl.vlam A₂)) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) (VLocalDecl.value (VLocalDecl.vlam A₁))
(VLocalDecl.value (VLocalDecl.vlam A₂)) (VLocalDecl.type (VLocalDecl.vlam A₁)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1.refl.refl
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) (VLocalDecl.type (VLocalDecl.vlam A₁))
(VLocalDecl.type (VLocalDecl.vlam A₂)) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) (VLocalDecl.value (VLocalDecl.vlam A₁))
(VLocalDecl.value (VLocalDecl.vlam A₂)) (VLocalDecl.type (VLocalDecl.vlam A₁))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | simp [bind, Option.bind_eq_some] | case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ (do
let __discr ← find? Δ₁✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) A)) =
some (e₁, A₁✝) →
(do
let __discr ← find? Δ₂✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) A)) =
some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ ∀ (x : VExpr × VExpr),
find? Δ₁✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) x.fst = e₁ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) x.snd = A₁✝ →
∀ (x : VExpr × VExpr),
find? Δ₂✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) x.fst = e₂ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) x.snd = A₂✝ →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ (do
let __discr ← find? Δ₁✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) A)) =
some (e₁, A₁✝) →
(do
let __discr ← find? Δ₂✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) A)) =
some (e₂, A₂✝) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | rintro ⟨d₁', n₁'⟩ H1' rfl rfl ⟨d₂', n₂'⟩ H2' rfl rfl | case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ ∀ (x : VExpr × VExpr),
find? Δ₁✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) x.fst = e₁ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) x.snd = A₁✝ →
∀ (x : VExpr × VExpr),
find? Δ₂✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) x.fst = e₂ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) x.snd = A₂✝ →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝ | case h_2.mk.mk
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁✝ e₂ A₂✝ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ ∀ (x : VExpr × VExpr),
find? Δ₁✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) x.fst = e₁ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) x.snd = A₁✝ →
∀ (x : VExpr × VExpr),
find? Δ₂✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) x.fst = e₂ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) x.snd = A₂✝ →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) A₁✝ A₂✝ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝)) e₁ e₂ A₁✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | obtain ⟨h2, h3⟩ := find?_uniq hΔ H1' H2' | case h_2.mk.mk
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd) | case h_2.mk.mk.intro
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝¹ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2✝ : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
h2 : IsDefEqU env U (toCtx Δ₁✝) n₁' n₂'
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) d₁' d₂' n₁'
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.mk.mk
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2 : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | exact ⟨h2.weakN henv .one, h3.weak henv⟩ | case h_2.mk.mk.intro
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝¹ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2✝ : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
h2 : IsDefEqU env U (toCtx Δ₁✝) n₁' n₂'
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) d₁' d₂' n₁'
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.mk.mk.intro
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2✝¹ : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
A₁ A₂ : VExpr
u✝ : VLevel
h2✝ : VEnv.IsDefEq env U (toCtx Δ₁✝) A₁ A₂ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
h2 : IsDefEqU env U (toCtx Δ₁✝) n₁' n₂'
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) d₁' d₂' n₁'
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlam A₁) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₂)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlam A₁)) (d₁', n₁').snd)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | revert H1 H2 | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
H1 : find? ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝) v = some (e₁, A₁)
H2 : find? ((ofv✝, VLocalDecl.vlet type₂✝ value₂✝) :: Δ₂✝) v = some (e₂, A₂)
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
⊢ find? ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝) v = some (e₁, A₁) →
find? ((ofv✝, VLocalDecl.vlet type₂✝ value₂✝) :: Δ₂✝) v = some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
H1 : find? ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝) v = some (e₁, A₁)
H2 : find? ((ofv✝, VLocalDecl.vlet type₂✝ value₂✝) :: Δ₂✝) v = some (e₂, A₂)
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | unfold VLCtx.find? | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
⊢ find? ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝) v = some (e₁, A₁) →
find? ((ofv✝, VLocalDecl.vlet type₂✝ value₂✝) :: Δ₂✝) v = some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
⊢ (match next ofv✝ v with
| none =>
some (VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝), VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝))
| some v => do
let __discr ← find? Δ₁✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) A)) =
some (e₁, A₁) →
(match next ofv✝ v with
| none =>
some (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝), VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝))
| some v => do
let __discr ← find? Δ₂✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) A)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
⊢ find? ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝) v = some (e₁, A₁) →
find? ((ofv✝, VLocalDecl.vlet type₂✝ value₂✝) :: Δ₂✝) v = some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | split | env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
⊢ (match next ofv✝ v with
| none =>
some (VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝), VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝))
| some v => do
let __discr ← find? Δ₁✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) A)) =
some (e₁, A₁) →
(match next ofv✝ v with
| none =>
some (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝), VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝))
| some v => do
let __discr ← find? Δ₂✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) A)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | case h_1
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ some (VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝), VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) =
some (e₁, A₁) →
some (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝), VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ (do
let __discr ← find? Δ₁✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) A)) =
some (e₁, A₁) →
(do
let __discr ← find? Δ₂✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) A)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
⊢ (match next ofv✝ v with
| none =>
some (VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝), VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝))
| some v => do
let __discr ← find? Δ₁✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) A)) =
some (e₁, A₁) →
(match next ofv✝ v with
| none =>
some (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝), VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝))
| some v => do
let __discr ← find? Δ₂✝ v
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) A)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | rintro ⟨⟩ ⟨⟩ | case h_1
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ some (VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝), VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) =
some (e₁, A₁) →
some (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝), VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | case h_1.refl.refl
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) (VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝)) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝)) (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝))
(VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ some (VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝), VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) =
some (e₁, A₁) →
some (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝), VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | exact ⟨⟨_, h4⟩, h3⟩ | case h_1.refl.refl
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) (VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝)) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝)) (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝))
(VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1.refl.refl
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
heq✝ : next ofv✝ v = none
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝)) (VLocalDecl.type (VLocalDecl.vlet type₂✝ value₂✝)) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VLocalDecl.value (VLocalDecl.vlet type₁✝ value₁✝)) (VLocalDecl.value (VLocalDecl.vlet type₂✝ value₂✝))
(VLocalDecl.type (VLocalDecl.vlet type₁✝ value₁✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | simp [bind, Option.bind_eq_some] | case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ (do
let __discr ← find? Δ₁✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) A)) =
some (e₁, A₁) →
(do
let __discr ← find? Δ₂✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) A)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ ∀ (x : VExpr × VExpr),
find? Δ₁✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) x.fst = e₁ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) x.snd = A₁ →
∀ (x : VExpr × VExpr),
find? Δ₂✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) x.fst = e₂ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) x.snd = A₂ →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ (do
let __discr ← find? Δ₁✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) A)) =
some (e₁, A₁) →
(do
let __discr ← find? Δ₂✝ v✝
match __discr with
| (e, A) =>
some
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) e,
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) A)) =
some (e₂, A₂) →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | rintro ⟨d₁', n₁'⟩ H1' rfl rfl ⟨d₂', n₂'⟩ H2' rfl rfl | case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ ∀ (x : VExpr × VExpr),
find? Δ₁✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) x.fst = e₁ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) x.snd = A₁ →
∀ (x : VExpr × VExpr),
find? Δ₂✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) x.fst = e₂ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) x.snd = A₂ →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁ | case h_2.mk.mk
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').snd) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
e₁ A₁ e₂ A₂ : VExpr
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
⊢ ∀ (x : VExpr × VExpr),
find? Δ₁✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) x.fst = e₁ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) x.snd = A₁ →
∀ (x : VExpr × VExpr),
find? Δ₂✝ v✝ = some x →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) x.fst = e₂ →
VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) x.snd = A₂ →
IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) A₁ A₂ ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝)) e₁ e₂ A₁
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.VLCtx.IsDefEq.find?_uniq | [260, 1] | [277, 59] | simpa [VLocalDecl.depth] using find?_uniq hΔ H1' H2' | case h_2.mk.mk
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').snd) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.mk.mk
env : VEnv
henv : Ordered env
U : Nat
Δ₁ Δ₂ : VLCtx
v : Nat ⊕ FVarId
hΔ✝ : IsDefEq env U Δ₁ Δ₂
ofv✝ : Option FVarId
d₁✝ d₂✝ : VLocalDecl
Δ₁✝ Δ₂✝ : VLCtx
hΔ : IsDefEq env U Δ₁✝ Δ₂✝
h1 : ∀ (fv : FVarId), ofv✝ = some fv → ¬fv ∈ VLCtx.fvars Δ₁✝
h2 : VLocalDecl.IsDefEq env U (toCtx Δ₁✝) d₁✝ d₂✝
value₁✝ value₂✝ type₁✝ type₂✝ : VExpr
u✝ : VLevel
h3 : VEnv.IsDefEq env U (toCtx Δ₁✝) value₁✝ value₂✝ type₁✝
h4 : VEnv.IsDefEq env U (toCtx Δ₁✝) type₁✝ type₂✝ (VExpr.sort u✝)
x✝ : Option (Nat ⊕ FVarId)
v✝ : Nat ⊕ FVarId
heq✝ : next ofv✝ v = some v✝
d₁' n₁' : VExpr
H1' : find? Δ₁✝ v✝ = some (d₁', n₁')
d₂' n₂' : VExpr
H2' : find? Δ₂✝ v✝ = some (d₂', n₂')
⊢ IsDefEqU env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').snd)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) (d₂', n₂').snd) ∧
VEnv.IsDefEq env U (toCtx ((ofv✝, VLocalDecl.vlet type₁✝ value₁✝) :: Δ₁✝))
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₂✝ value₂✝)) (d₂', n₂').fst)
(VExpr.liftN (VLocalDecl.depth (VLocalDecl.vlet type₁✝ value₁✝)) (d₁', n₁').snd)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | induction H with
| @bvar e A Δ i h1 =>
simp [InScope]
induction Δ generalizing i e A with
| nil => cases h1
| cons d Δ ih =>
match d, i with
| (none, _), 0 => exact Nat.succ_pos _
| (none, _), _ + 1 =>
simp [VLCtx.find?, VLCtx.next, bind] at h1
obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1
exact Nat.succ_lt_succ (ih h1)
| (some _, _), _ =>
simp [VLCtx.find?, VLCtx.next, bind] at h1
obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1
exact ih h1
| fvar h1 => exact VLCtx.find?_eq_some.1 ⟨_, h1⟩
| sort | const | lit | mdata => trivial
| app _ _ _ _ ih1 ih2
| lam _ _ _ ih1 ih2
| forallE _ _ _ _ ih1 ih2 => exact ⟨ih1, ih2⟩
| letE _ _ _ _ ih1 ih2 ih3 => exact ⟨ih1, ih2, ih3⟩
| proj _ _ ih => exact ih | env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' : VExpr
H : TrExpr env Us Δ e e'
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ) e (VLCtx.bvars Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' : VExpr
H : TrExpr env Us Δ e e'
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ) e (VLCtx.bvars Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | simp [InScope] | case bvar
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' e A : VExpr
Δ : VLCtx
i : Nat
h1 : VLCtx.find? Δ (Sum.inl i) = some (e, A)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ) (Expr.bvar i) (VLCtx.bvars Δ) | case bvar
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' e A : VExpr
Δ : VLCtx
i : Nat
h1 : VLCtx.find? Δ (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars Δ | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' e A : VExpr
Δ : VLCtx
i : Nat
h1 : VLCtx.find? Δ (Sum.inl i) = some (e, A)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ) (Expr.bvar i) (VLCtx.bvars Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | induction Δ generalizing i e A with
| nil => cases h1
| cons d Δ ih =>
match d, i with
| (none, _), 0 => exact Nat.succ_pos _
| (none, _), _ + 1 =>
simp [VLCtx.find?, VLCtx.next, bind] at h1
obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1
exact Nat.succ_lt_succ (ih h1)
| (some _, _), _ =>
simp [VLCtx.find?, VLCtx.next, bind] at h1
obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1
exact ih h1 | case bvar
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' e A : VExpr
Δ : VLCtx
i : Nat
h1 : VLCtx.find? Δ (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars Δ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' e A : VExpr
Δ : VLCtx
i : Nat
h1 : VLCtx.find? Δ (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars Δ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | cases h1 | case bvar.nil
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e✝ : Expr
e' e A : VExpr
i : Nat
h1 : VLCtx.find? [] (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.nil
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e✝ : Expr
e' e A : VExpr
i : Nat
h1 : VLCtx.find? [] (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | match d, i with
| (none, _), 0 => exact Nat.succ_pos _
| (none, _), _ + 1 =>
simp [VLCtx.find?, VLCtx.next, bind] at h1
obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1
exact Nat.succ_lt_succ (ih h1)
| (some _, _), _ =>
simp [VLCtx.find?, VLCtx.next, bind] at h1
obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1
exact ih h1 | case bvar.cons
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
h1 : VLCtx.find? (d :: Δ) (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars (d :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.cons
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
h1 : VLCtx.find? (d :: Δ) (Sum.inl i) = some (e, A)
⊢ i < VLCtx.bvars (d :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact Nat.succ_pos _ | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
h1 : VLCtx.find? ((none, snd✝) :: Δ) (Sum.inl 0) = some (e, A)
⊢ 0 < VLCtx.bvars ((none, snd✝) :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
h1 : VLCtx.find? ((none, snd✝) :: Δ) (Sum.inl 0) = some (e, A)
⊢ 0 < VLCtx.bvars ((none, snd✝) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | simp [VLCtx.find?, VLCtx.next, bind] at h1 | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
n✝ : Nat
h1 : VLCtx.find? ((none, snd✝) :: Δ) (Sum.inl (n✝ + 1)) = some (e, A)
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝) :: Δ) | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
n✝ : Nat
h1 :
∃ a,
VLCtx.find? Δ (Sum.inl n✝) = some a ∧
VExpr.liftN (VLocalDecl.depth snd✝) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth snd✝) a.snd = A
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝) :: Δ) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
n✝ : Nat
h1 : VLCtx.find? ((none, snd✝) :: Δ) (Sum.inl (n✝ + 1)) = some (e, A)
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1 | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
n✝ : Nat
h1 :
∃ a,
VLCtx.find? Δ (Sum.inl n✝) = some a ∧
VExpr.liftN (VLocalDecl.depth snd✝) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth snd✝) a.snd = A
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝) :: Δ) | case intro.mk.intro.intro
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
i : Nat
snd✝¹ : VLocalDecl
n✝ : Nat
fst✝ snd✝ : VExpr
h1 : VLCtx.find? Δ (Sum.inl n✝) = some (fst✝, snd✝)
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝¹) :: Δ) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
snd✝ : VLocalDecl
n✝ : Nat
h1 :
∃ a,
VLCtx.find? Δ (Sum.inl n✝) = some a ∧
VExpr.liftN (VLocalDecl.depth snd✝) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth snd✝) a.snd = A
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact Nat.succ_lt_succ (ih h1) | case intro.mk.intro.intro
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
i : Nat
snd✝¹ : VLocalDecl
n✝ : Nat
fst✝ snd✝ : VExpr
h1 : VLCtx.find? Δ (Sum.inl n✝) = some (fst✝, snd✝)
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝¹) :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro.intro
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
i : Nat
snd✝¹ : VLocalDecl
n✝ : Nat
fst✝ snd✝ : VExpr
h1 : VLCtx.find? Δ (Sum.inl n✝) = some (fst✝, snd✝)
⊢ n✝ + 1 < VLCtx.bvars ((none, snd✝¹) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | simp [VLCtx.find?, VLCtx.next, bind] at h1 | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
val✝ : FVarId
snd✝ : VLocalDecl
x✝ : Nat
h1 : VLCtx.find? ((some val✝, snd✝) :: Δ) (Sum.inl x✝) = some (e, A)
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝) :: Δ) | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
val✝ : FVarId
snd✝ : VLocalDecl
x✝ : Nat
h1 :
∃ a,
VLCtx.find? Δ (Sum.inl x✝) = some a ∧
VExpr.liftN (VLocalDecl.depth snd✝) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth snd✝) a.snd = A
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝) :: Δ) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
val✝ : FVarId
snd✝ : VLocalDecl
x✝ : Nat
h1 : VLCtx.find? ((some val✝, snd✝) :: Δ) (Sum.inl x✝) = some (e, A)
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | obtain ⟨⟨_, _⟩, h1, rfl, rfl⟩ := h1 | env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
val✝ : FVarId
snd✝ : VLocalDecl
x✝ : Nat
h1 :
∃ a,
VLCtx.find? Δ (Sum.inl x✝) = some a ∧
VExpr.liftN (VLocalDecl.depth snd✝) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth snd✝) a.snd = A
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝) :: Δ) | case intro.mk.intro.intro
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
i : Nat
val✝ : FVarId
snd✝¹ : VLocalDecl
x✝ : Nat
fst✝ snd✝ : VExpr
h1 : VLCtx.find? Δ (Sum.inl x✝) = some (fst✝, snd✝)
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝¹) :: Δ) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e✝ : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
e A : VExpr
i : Nat
val✝ : FVarId
snd✝ : VLocalDecl
x✝ : Nat
h1 :
∃ a,
VLCtx.find? Δ (Sum.inl x✝) = some a ∧
VExpr.liftN (VLocalDecl.depth snd✝) a.fst = e ∧ VExpr.liftN (VLocalDecl.depth snd✝) a.snd = A
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact ih h1 | case intro.mk.intro.intro
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
i : Nat
val✝ : FVarId
snd✝¹ : VLocalDecl
x✝ : Nat
fst✝ snd✝ : VExpr
h1 : VLCtx.find? Δ (Sum.inl x✝) = some (fst✝, snd✝)
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝¹) :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro.intro
env : VEnv
henv : Ordered env
Us : List Name
Δ✝ : VLCtx
e : Expr
e' : VExpr
d : Option FVarId × VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
ih : ∀ {e A : VExpr} {i : Nat}, VLCtx.find? Δ (Sum.inl i) = some (e, A) → i < VLCtx.bvars Δ
i : Nat
val✝ : FVarId
snd✝¹ : VLocalDecl
x✝ : Nat
fst✝ snd✝ : VExpr
h1 : VLCtx.find? Δ (Sum.inl x✝) = some (fst✝, snd✝)
⊢ x✝ < VLCtx.bvars ((some val✝, snd✝¹) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact VLCtx.find?_eq_some.1 ⟨_, h1⟩ | case fvar
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
fv✝ : FVarId
h1 : VLCtx.find? Δ✝ (Sum.inr fv✝) = some (e✝, A✝)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.fvar fv✝) (VLCtx.bvars Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case fvar
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
fv✝ : FVarId
h1 : VLCtx.find? Δ✝ (Sum.inr fv✝) = some (e✝, A✝)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.fvar fv✝) (VLCtx.bvars Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | trivial | case mdata
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
d✝ : MData
a✝ : TrExpr env Us Δ✝ e✝ e'✝
a_ih✝ : InScope (fun x => x ∈ VLCtx.fvars Δ✝) e✝ (VLCtx.bvars Δ✝)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.mdata d✝ e✝) (VLCtx.bvars Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mdata
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
d✝ : MData
a✝ : TrExpr env Us Δ✝ e✝ e'✝
a_ih✝ : InScope (fun x => x ∈ VLCtx.fvars Δ✝) e✝ (VLCtx.bvars Δ✝)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.mdata d✝ e✝) (VLCtx.bvars Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact ⟨ih1, ih2⟩ | case forallE
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
a✝³ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝² : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 : InScope (fun x => x ∈ VLCtx.fvars Δ✝) ty✝ (VLCtx.bvars Δ✝)
ih2 :
InScope (fun x => x ∈ VLCtx.fvars ((none, VLocalDecl.vlam ty'✝) :: Δ✝)) body✝
(VLCtx.bvars ((none, VLocalDecl.vlam ty'✝) :: Δ✝))
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.forallE name✝ ty✝ body✝ bi✝) (VLCtx.bvars Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' ty'✝ body'✝ : VExpr
Δ✝ : VLCtx
ty✝ body✝ : Expr
name✝ : Name
bi✝ : BinderInfo
a✝³ : IsType env (List.length Us) (VLCtx.toCtx Δ✝) ty'✝
a✝² : IsType env (List.length Us) (ty'✝ :: VLCtx.toCtx Δ✝) body'✝
a✝¹ : TrExpr env Us Δ✝ ty✝ ty'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlam ty'✝) :: Δ✝) body✝ body'✝
ih1 : InScope (fun x => x ∈ VLCtx.fvars Δ✝) ty✝ (VLCtx.bvars Δ✝)
ih2 :
InScope (fun x => x ∈ VLCtx.fvars ((none, VLocalDecl.vlam ty'✝) :: Δ✝)) body✝
(VLCtx.bvars ((none, VLocalDecl.vlam ty'✝) :: Δ✝))
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.forallE name✝ ty✝ body✝ bi✝) (VLCtx.bvars Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact ⟨ih1, ih2, ih3⟩ | case letE
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
a✝³ : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 : InScope (fun x => x ∈ VLCtx.fvars Δ✝) ty✝ (VLCtx.bvars Δ✝)
ih2 : InScope (fun x => x ∈ VLCtx.fvars Δ✝) val✝ (VLCtx.bvars Δ✝)
ih3 :
InScope (fun x => x ∈ VLCtx.fvars ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝)) body✝
(VLCtx.bvars ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝))
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VLCtx.bvars Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case letE
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' val'✝ ty'✝ : VExpr
Δ✝ : VLCtx
ty✝ val✝ body✝ : Expr
body'✝ : VExpr
name✝ : Name
bi✝ : Bool
a✝³ : HasType env (List.length Us) (VLCtx.toCtx Δ✝) val'✝ ty'✝
a✝² : TrExpr env Us Δ✝ ty✝ ty'✝
a✝¹ : TrExpr env Us Δ✝ val✝ val'✝
a✝ : TrExpr env Us ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝) body✝ body'✝
ih1 : InScope (fun x => x ∈ VLCtx.fvars Δ✝) ty✝ (VLCtx.bvars Δ✝)
ih2 : InScope (fun x => x ∈ VLCtx.fvars Δ✝) val✝ (VLCtx.bvars Δ✝)
ih3 :
InScope (fun x => x ∈ VLCtx.fvars ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝)) body✝
(VLCtx.bvars ((none, VLocalDecl.vlet ty'✝ val'✝) :: Δ✝))
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.letE name✝ ty✝ val✝ body✝ bi✝) (VLCtx.bvars Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.inScope | [280, 1] | [303, 28] | exact ih | case proj
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
s✝ : Name
i✝ : Nat
e''✝ : VExpr
a✝¹ : TrExpr env Us Δ✝ e✝ e'✝
a✝ : TrProj (VLCtx.toCtx Δ✝) s✝ i✝ e'✝ e''✝
ih : InScope (fun x => x ∈ VLCtx.fvars Δ✝) e✝ (VLCtx.bvars Δ✝)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.proj s✝ i✝ e✝) (VLCtx.bvars Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proj
env : VEnv
henv : Ordered env
Us : List Name
Δ : VLCtx
e : Expr
e' : VExpr
Δ✝ : VLCtx
e✝ : Expr
e'✝ : VExpr
s✝ : Name
i✝ : Nat
e''✝ : VExpr
a✝¹ : TrExpr env Us Δ✝ e✝ e'✝
a✝ : TrProj (VLCtx.toCtx Δ✝) s✝ i✝ e'✝ e''✝
ih : InScope (fun x => x ∈ VLCtx.fvars Δ✝) e✝ (VLCtx.bvars Δ✝)
⊢ InScope (fun x => x ∈ VLCtx.fvars Δ✝) (Expr.proj s✝ i✝ e✝) (VLCtx.bvars Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.wf | [308, 1] | [324, 40] | induction H with
| bvar h1 | fvar h1 => exact ⟨_, hΔ.find?_wf henv h1⟩
| sort h1 => exact ⟨_, .sort (.of_ofLevel h1)⟩
| const h1 h2 h3 =>
simp [List.mapM_eq_some] at h2
refine ⟨_, .const h1 (fun l hl => ?_) (h2.length_eq.symm.trans h3)⟩
have ⟨_, _, h⟩ := h2.forall_exists_r _ hl; exact .of_ofLevel h
| app h1 h2 => exact ⟨_, h1.app h2⟩
| lam h1 _ _ _ ih2 =>
have ⟨_, h1'⟩ := h1
have ⟨_, h2'⟩ := ih2 ⟨hΔ, nofun, h1⟩
refine ⟨_, h1'.lam h2'⟩
| forallE h1 h2 => have ⟨_, h1'⟩ := h1; have ⟨_, h2'⟩ := h2; exact ⟨_, .forallE h1' h2'⟩
| letE h1 _ _ _ _ _ ih3 => exact ih3 ⟨hΔ, nofun, h1⟩
| lit _ ih | mdata _ ih => exact ih hΔ
| proj _ h2 ih => exact h2.wf (ih hΔ) | env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
hΔ : VLCtx.WF env (List.length Us) Δ
e : Expr
e' : VExpr
H : TrExpr env Us Δ e e'
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ) e' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
hΔ : VLCtx.WF env (List.length Us) Δ
e : Expr
e' : VExpr
H : TrExpr env Us Δ e e'
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ) e'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.wf | [308, 1] | [324, 40] | exact ⟨_, hΔ.find?_wf henv h1⟩ | case fvar
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
fv✝ : FVarId
h1 : VLCtx.find? Δ✝ (Sum.inr fv✝) = some (e✝, A✝)
hΔ : VLCtx.WF env (List.length Us) Δ✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) e✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case fvar
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' e✝ A✝ : VExpr
Δ✝ : VLCtx
fv✝ : FVarId
h1 : VLCtx.find? Δ✝ (Sum.inr fv✝) = some (e✝, A✝)
hΔ : VLCtx.WF env (List.length Us) Δ✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.wf | [308, 1] | [324, 40] | exact ⟨_, .sort (.of_ofLevel h1)⟩ | case sort
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
u✝ : Level
u'✝ : VLevel
Δ✝ : VLCtx
h1 : VLevel.ofLevel Us u✝ = some u'✝
hΔ : VLCtx.WF env (List.length Us) Δ✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.sort u'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sort
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
u✝ : Level
u'✝ : VLevel
Δ✝ : VLCtx
h1 : VLevel.ofLevel Us u✝ = some u'✝
hΔ : VLCtx.WF env (List.length Us) Δ✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.sort u'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.wf | [308, 1] | [324, 40] | simp [List.mapM_eq_some] at h2 | case const
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h2 : List.mapM (VLevel.ofLevel Us) us✝ = some us'✝
h3 : List.length us✝ = ci✝.uvars
hΔ : VLCtx.WF env (List.length Us) Δ✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.const c✝ us'✝) | case const
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h3 : List.length us✝ = ci✝.uvars
hΔ : VLCtx.WF env (List.length Us) Δ✝
h2 : List.Forall₂ (fun x x_1 => VLevel.ofLevel Us x = some x_1) us✝ us'✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.const c✝ us'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h2 : List.mapM (VLevel.ofLevel Us) us✝ = some us'✝
h3 : List.length us✝ = ci✝.uvars
hΔ : VLCtx.WF env (List.length Us) Δ✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.const c✝ us'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/Typing/Lemmas.lean | Lean4Lean.TrExpr.wf | [308, 1] | [324, 40] | refine ⟨_, .const h1 (fun l hl => ?_) (h2.length_eq.symm.trans h3)⟩ | case const
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h3 : List.length us✝ = ci✝.uvars
hΔ : VLCtx.WF env (List.length Us) Δ✝
h2 : List.Forall₂ (fun x x_1 => VLevel.ofLevel Us x = some x_1) us✝ us'✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.const c✝ us'✝) | case const
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h3 : List.length us✝ = ci✝.uvars
hΔ : VLCtx.WF env (List.length Us) Δ✝
h2 : List.Forall₂ (fun x x_1 => VLevel.ofLevel Us x = some x_1) us✝ us'✝
l : VLevel
hl : l ∈ us'✝
⊢ VLevel.WF (List.length Us) l | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
Δ : VLCtx
henv : Ordered env
Us : List Name
e : Expr
e' : VExpr
c✝ : Name
ci✝ : VConstant
us'✝ : List VLevel
Δ✝ : VLCtx
us✝ : List Level
h1 : env.constants c✝ = some (some ci✝)
h3 : List.length us✝ = ci✝.uvars
hΔ : VLCtx.WF env (List.length Us) Δ✝
h2 : List.Forall₂ (fun x x_1 => VLevel.ofLevel Us x = some x_1) us✝ us'✝
⊢ VExpr.WF env (List.length Us) (VLCtx.toCtx Δ✝) (VExpr.const c✝ us'✝)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.