url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weakN_iff | [83, 1] | [85, 77] | refine ⟨fun h => have := henv; have := hΓ; sorry, fun h => h.weakN henv W⟩ | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
n k : Nat
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.LiftN n k Γ Γ'
⊢ IsDefEqU env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) ↔ IsDefEqU env U Γ e1 e2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
n k : Nat
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.LiftN n k Γ Γ'
⊢ IsDefEqU env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) ↔ IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.skips | [91, 1] | [98, 36] | obtain ⟨e₁, rfl⟩ := VExpr.skips_iff_exists.1 h1 | env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
H : IsDefEq env U Γ' e₁ e₂ A
h1 : VExpr.Skips e₁ n k
h2 : VExpr.Skips e₂ n k
⊢ ∃ B, IsDefEq env U Γ' e₁ e₂ B ∧ VExpr.Skips B n k | case intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
h2 : VExpr.Skips e₂ n k
e₁ : VExpr
H : IsDefEq env U Γ' (VExpr.liftN n e₁ k) e₂ A
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) e₂ B ∧ VExpr.Skips B n k | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
H : IsDefEq env U Γ' e₁ e₂ A
h1 : VExpr.Skips e₁ n k
h2 : VExpr.Skips e₂ n k
⊢ ∃ B, IsDefEq env U Γ' e₁ e₂ B ∧ VExpr.Skips B n k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.skips | [91, 1] | [98, 36] | obtain ⟨e₂, rfl⟩ := VExpr.skips_iff_exists.1 h2 | case intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
h2 : VExpr.Skips e₂ n k
e₁ : VExpr
H : IsDefEq env U Γ' (VExpr.liftN n e₁ k) e₂ A
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) e₂ B ∧ VExpr.Skips B n k | case intro.intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
e₁ : VExpr
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
e₂ : VExpr
h2 : VExpr.Skips (VExpr.liftN n e₂ k) n k
H : IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) A
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) B ∧ VExpr.Skips B n k | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
h2 : VExpr.Skips e₂ n k
e₁ : VExpr
H : IsDefEq env U Γ' (VExpr.liftN n e₁ k) e₂ A
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) e₂ B ∧ VExpr.Skips B n k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.skips | [91, 1] | [98, 36] | have ⟨_, H⟩ := (IsDefEqU.weakN_iff henv hΓ W).1 ⟨_, H⟩ | case intro.intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
e₁ : VExpr
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
e₂ : VExpr
h2 : VExpr.Skips (VExpr.liftN n e₂ k) n k
H : IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) A
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) B ∧ VExpr.Skips B n k | case intro.intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
e₁ : VExpr
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
e₂ : VExpr
h2 : VExpr.Skips (VExpr.liftN n e₂ k) n k
H✝ : IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) A
w✝ : VExpr
H : IsDefEq env U Γ e₁ e₂ w✝
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) B ∧ VExpr.Skips B n k | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
e₁ : VExpr
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
e₂ : VExpr
h2 : VExpr.Skips (VExpr.liftN n e₂ k) n k
H : IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) A
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) B ∧ VExpr.Skips B n k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.skips | [91, 1] | [98, 36] | exact ⟨_, H.weakN henv W, .liftN⟩ | case intro.intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
e₁ : VExpr
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
e₂ : VExpr
h2 : VExpr.Skips (VExpr.liftN n e₂ k) n k
H✝ : IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) A
w✝ : VExpr
H : IsDefEq env U Γ e₁ e₂ w✝
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) B ∧ VExpr.Skips B n k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
env : VEnv
Γ' : List VExpr
U n k : Nat
Γ : List VExpr
A : VExpr
henv : Ordered env
hΓ : OnCtx Γ' (IsType env U)
W : Ctx.LiftN n k Γ Γ'
e₁ : VExpr
h1 : VExpr.Skips (VExpr.liftN n e₁ k) n k
e₂ : VExpr
h2 : VExpr.Skips (VExpr.liftN n e₂ k) n k
H✝ : IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) A
w✝ : VExpr
H : IsDefEq env U Γ e₁ e₂ w✝
⊢ ∃ B, IsDefEq env U Γ' (VExpr.liftN n e₁ k) (VExpr.liftN n e₂ k) B ∧ VExpr.Skips B n k
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weakN_iff' | [101, 1] | [106, 84] | refine ⟨fun h => ?_, fun h => h.weakN henv W⟩ | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
⊢ IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k) ↔ IsDefEq env U Γ e1 e2 A | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
⊢ IsDefEq env U Γ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
⊢ IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k) ↔ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weakN_iff' | [101, 1] | [106, 84] | have ⟨_, H⟩ := (IsDefEqU.weakN_iff henv hΓ' W).1 ⟨_, h⟩ | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
⊢ IsDefEq env U Γ e1 e2 A | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
w✝ : VExpr
H : IsDefEq env U Γ e1 e2 w✝
⊢ IsDefEq env U Γ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
⊢ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weakN_iff' | [101, 1] | [106, 84] | refine IsDefEqU.defeqDF henv hΓ ?_ H | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
w✝ : VExpr
H : IsDefEq env U Γ e1 e2 w✝
⊢ IsDefEq env U Γ e1 e2 A | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
w✝ : VExpr
H : IsDefEq env U Γ e1 e2 w✝
⊢ IsDefEqU env U Γ w✝ A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
w✝ : VExpr
H : IsDefEq env U Γ e1 e2 w✝
⊢ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weakN_iff' | [101, 1] | [106, 84] | exact (IsDefEqU.weakN_iff henv hΓ' W).1 <| (H.weakN henv W).uniqU henv hΓ' h.symm | env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
w✝ : VExpr
H : IsDefEq env U Γ e1 e2 w✝
⊢ IsDefEqU env U Γ w✝ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
Γ : List VExpr
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
hΓ : OnCtx Γ (IsType env U)
n k : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
h : IsDefEq env U Γ' (VExpr.liftN n e1 k) (VExpr.liftN n e2 k) (VExpr.liftN n A k)
w✝ : VExpr
H : IsDefEq env U Γ e1 e2 w✝
⊢ IsDefEqU env U Γ w✝ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | induction W with
| zero As h =>
clear h
induction As with
| nil => exact H
| cons A As ih => exact ih H.1
| succ W ih =>
let ⟨H1, _, H2⟩ := H
exact ⟨ih H1, _, (IsDefEq.weakN_iff' henv H1 (ih H1) W).1 H2⟩ | env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
W : Ctx.LiftN n k Γ Γ'
H : OnCtx Γ' (IsType env U)
⊢ OnCtx Γ (IsType env U) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
W : Ctx.LiftN n k Γ Γ'
H : OnCtx Γ' (IsType env U)
⊢ OnCtx Γ (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | clear h | case zero
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ As : List VExpr
h : List.length As = n
H : OnCtx (As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U) | case zero
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ As : List VExpr
H : OnCtx (As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ As : List VExpr
h : List.length As = n
H : OnCtx (As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | induction As with
| nil => exact H
| cons A As ih => exact ih H.1 | case zero
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ As : List VExpr
H : OnCtx (As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ As : List VExpr
H : OnCtx (As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | exact H | case zero.nil
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ : List VExpr
H : OnCtx ([] ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.nil
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ : List VExpr
H : OnCtx ([] ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | exact ih H.1 | case zero.cons
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ : List VExpr
A : VExpr
As : List VExpr
ih : OnCtx (As ++ Γ✝) (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (A :: As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
Γ✝ : List VExpr
A : VExpr
As : List VExpr
ih : OnCtx (As ++ Γ✝) (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (A :: As ++ Γ✝) (IsType env U)
⊢ OnCtx Γ✝ (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | let ⟨H1, _, H2⟩ := H | case succ
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
W : Ctx.LiftN n k✝ Γ✝ Γ'✝
ih : OnCtx Γ'✝ (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (VExpr.liftN n A✝ k✝ :: Γ'✝) (IsType env U)
⊢ OnCtx (A✝ :: Γ✝) (IsType env U) | case succ
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
W : Ctx.LiftN n k✝ Γ✝ Γ'✝
ih : OnCtx Γ'✝ (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (VExpr.liftN n A✝ k✝ :: Γ'✝) (IsType env U)
H1 : OnCtx Γ'✝ (IsType env U)
w✝ : VLevel
H2 : HasType env U Γ'✝ (VExpr.liftN n A✝ k✝) (VExpr.sort w✝)
⊢ OnCtx (A✝ :: Γ✝) (IsType env U) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
W : Ctx.LiftN n k✝ Γ✝ Γ'✝
ih : OnCtx Γ'✝ (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (VExpr.liftN n A✝ k✝ :: Γ'✝) (IsType env U)
⊢ OnCtx (A✝ :: Γ✝) (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.OnCtx.weakN_inv | [109, 1] | [119, 66] | exact ⟨ih H1, _, (IsDefEq.weakN_iff' henv H1 (ih H1) W).1 H2⟩ | case succ
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
W : Ctx.LiftN n k✝ Γ✝ Γ'✝
ih : OnCtx Γ'✝ (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (VExpr.liftN n A✝ k✝ :: Γ'✝) (IsType env U)
H1 : OnCtx Γ'✝ (IsType env U)
w✝ : VLevel
H2 : HasType env U Γ'✝ (VExpr.liftN n A✝ k✝) (VExpr.sort w✝)
⊢ OnCtx (A✝ :: Γ✝) (IsType env U) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
W : Ctx.LiftN n k✝ Γ✝ Γ'✝
ih : OnCtx Γ'✝ (IsType env U) → OnCtx Γ✝ (IsType env U)
H : OnCtx (VExpr.liftN n A✝ k✝ :: Γ'✝) (IsType env U)
H1 : OnCtx Γ'✝ (IsType env U)
w✝ : VLevel
H2 : HasType env U Γ'✝ (VExpr.liftN n A✝ k✝) (VExpr.sort w✝)
⊢ OnCtx (A✝ :: Γ✝) (IsType env U)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weak'_iff | [142, 1] | [151, 77] | generalize e : l.depth = n | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.Lift' l Γ Γ'
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2 | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2 | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.Lift' l Γ Γ'
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weak'_iff | [142, 1] | [151, 77] | induction n generalizing l Γ' with
| zero => simp [VExpr.lift'_depth_zero e, W.depth_zero e]
| succ n ih =>
obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e
have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip
simp only [Lift.consN_skip_eq, VExpr.lift'_comp, VExpr.lift'_consN_skipN,
weakN_iff henv hΓ' W2, ih (hΓ'.weakN_inv henv W2) W1 Lift.depth_consN] | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weak'_iff | [142, 1] | [151, 77] | simp [VExpr.lift'_depth_zero e, W.depth_zero e] | case zero
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weak'_iff | [142, 1] | [151, 77] | obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e | case succ
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
n : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l : Lift},
Ctx.Lift' l Γ Γ' →
Lift.depth l = n → (IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2)
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2 | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEqU env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) ↔ IsDefEqU env U Γ e1 e2)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k)) ↔
IsDefEqU env U Γ e1 e2 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
n : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l : Lift},
Ctx.Lift' l Γ Γ' →
Lift.depth l = n → (IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2)
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) ↔ IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weak'_iff | [142, 1] | [151, 77] | have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEqU env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) ↔ IsDefEqU env U Γ e1 e2)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k)) ↔
IsDefEqU env U Γ e1 e2 | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEqU env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) ↔ IsDefEqU env U Γ e1 e2)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k)) ↔
IsDefEqU env U Γ e1 e2 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEqU env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) ↔ IsDefEqU env U Γ e1 e2)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k)) ↔
IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.weak'_iff | [142, 1] | [151, 77] | simp only [Lift.consN_skip_eq, VExpr.lift'_comp, VExpr.lift'_consN_skipN,
weakN_iff henv hΓ' W2, ih (hΓ'.weakN_inv henv W2) W1 Lift.depth_consN] | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEqU env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) ↔ IsDefEqU env U Γ e1 e2)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k)) ↔
IsDefEqU env U Γ e1 e2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEqU env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) ↔ IsDefEqU env U Γ e1 e2)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEqU env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k)) ↔
IsDefEqU env U Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weak'_iff | [154, 1] | [163, 77] | generalize e : l.depth = n | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weak'_iff | [154, 1] | [163, 77] | induction n generalizing l Γ' with
| zero => simp [VExpr.lift'_depth_zero e, W.depth_zero e]
| succ n ih =>
obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e
have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip
simp only [Lift.consN_skip_eq, VExpr.lift'_comp, VExpr.lift'_consN_skipN,
weakN_iff henv hΓ' W2, ih (hΓ'.weakN_inv henv W2) W1 Lift.depth_consN] | env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ' : List VExpr
U : Nat
henv : Ordered env
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weak'_iff | [154, 1] | [163, 77] | simp [VExpr.lift'_depth_zero e, W.depth_zero e] | case zero
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weak'_iff | [154, 1] | [163, 77] | obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e | case succ
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
n : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l : Lift},
Ctx.Lift' l Γ Γ' →
Lift.depth l = n →
(IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A)
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEq env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) (VExpr.lift' A l_1) ↔ IsDefEq env U Γ e1 e2 A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEq env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k))
(VExpr.lift' A (Lift.consN (Lift.skip l) k)) ↔
IsDefEq env U Γ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
n : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l : Lift},
Ctx.Lift' l Γ Γ' →
Lift.depth l = n →
(IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A)
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ IsDefEq env U Γ' (VExpr.lift' e1 l) (VExpr.lift' e2 l) (VExpr.lift' A l) ↔ IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weak'_iff | [154, 1] | [163, 77] | have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEq env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) (VExpr.lift' A l_1) ↔ IsDefEq env U Γ e1 e2 A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEq env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k))
(VExpr.lift' A (Lift.consN (Lift.skip l) k)) ↔
IsDefEq env U Γ e1 e2 A | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEq env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) (VExpr.lift' A l_1) ↔ IsDefEq env U Γ e1 e2 A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k))
(VExpr.lift' A (Lift.consN (Lift.skip l) k)) ↔
IsDefEq env U Γ e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEq env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) (VExpr.lift' A l_1) ↔ IsDefEq env U Γ e1 e2 A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEq env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k))
(VExpr.lift' A (Lift.consN (Lift.skip l) k)) ↔
IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.weak'_iff | [154, 1] | [163, 77] | simp only [Lift.consN_skip_eq, VExpr.lift'_comp, VExpr.lift'_consN_skipN,
weakN_iff henv hΓ' W2, ih (hΓ'.weakN_inv henv W2) W1 Lift.depth_consN] | case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEq env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) (VExpr.lift' A l_1) ↔ IsDefEq env U Γ e1 e2 A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k))
(VExpr.lift' A (Lift.consN (Lift.skip l) k)) ↔
IsDefEq env U Γ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
U : Nat
henv : Ordered env
Γ : List VExpr
e1 e2 A : VExpr
Γ' : List VExpr
hΓ' : OnCtx Γ' (IsType env U)
l : Lift
k : Nat
ih :
∀ {Γ' : List VExpr},
OnCtx Γ' (IsType env U) →
∀ {l_1 : Lift},
Ctx.Lift' l_1 Γ Γ' →
Lift.depth l_1 = Lift.depth l →
(IsDefEq env U Γ' (VExpr.lift' e1 l_1) (VExpr.lift' e2 l_1) (VExpr.lift' A l_1) ↔ IsDefEq env U Γ e1 e2 A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (VExpr.lift' e1 (Lift.consN (Lift.skip l) k)) (VExpr.lift' e2 (Lift.consN (Lift.skip l) k))
(VExpr.lift' A (Lift.consN (Lift.skip l) k)) ↔
IsDefEq env U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.isSuffix | [13, 1] | [21, 77] | induction H with
| @zero Γ As h => exact ⟨Γ, As, [], [], h, rfl, rfl, rfl, rfl⟩
| succ _ ih =>
obtain ⟨_, _, Δ, Δ', hn, hΔ, hΔ', rfl, rfl⟩ := ih
exact ⟨_, _, _ :: Δ, _ :: Δ', hn, by simp [hΔ], by simp [hΔ'], rfl, rfl⟩ | n k : Nat
Γ Γ' : List VExpr
H : LiftN n k Γ Γ'
⊢ ∃ Γ₀ As Δ Δ', List.length As = n ∧ List.length Δ = k ∧ List.length Δ' = k ∧ Γ = Δ ++ Γ₀ ∧ Γ' = Δ' ++ As ++ Γ₀ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
H : LiftN n k Γ Γ'
⊢ ∃ Γ₀ As Δ Δ', List.length As = n ∧ List.length Δ = k ∧ List.length Δ' = k ∧ Γ = Δ ++ Γ₀ ∧ Γ' = Δ' ++ As ++ Γ₀
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.isSuffix | [13, 1] | [21, 77] | exact ⟨Γ, As, [], [], h, rfl, rfl, rfl, rfl⟩ | case zero
n k : Nat
Γ✝ Γ' Γ As : List VExpr
h : List.length As = n
⊢ ∃ Γ₀ As_1 Δ Δ',
List.length As_1 = n ∧ List.length Δ = 0 ∧ List.length Δ' = 0 ∧ Γ = Δ ++ Γ₀ ∧ As ++ Γ = Δ' ++ As_1 ++ Γ₀ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n k : Nat
Γ✝ Γ' Γ As : List VExpr
h : List.length As = n
⊢ ∃ Γ₀ As_1 Δ Δ',
List.length As_1 = n ∧ List.length Δ = 0 ∧ List.length Δ' = 0 ∧ Γ = Δ ++ Γ₀ ∧ As ++ Γ = Δ' ++ As_1 ++ Γ₀
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.isSuffix | [13, 1] | [21, 77] | obtain ⟨_, _, Δ, Δ', hn, hΔ, hΔ', rfl, rfl⟩ := ih | case succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : ∃ Γ₀ As Δ Δ', List.length As = n ∧ List.length Δ = k✝ ∧ List.length Δ' = k✝ ∧ Γ✝ = Δ ++ Γ₀ ∧ Γ'✝ = Δ' ++ As ++ Γ₀
⊢ ∃ Γ₀ As Δ Δ',
List.length As = n ∧
List.length Δ = k✝ + 1 ∧ List.length Δ' = k✝ + 1 ∧ A✝ :: Γ✝ = Δ ++ Γ₀ ∧ liftN n A✝ k✝ :: Γ'✝ = Δ' ++ As ++ Γ₀ | case succ.intro.intro.intro.intro.intro.intro.intro.intro
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ ∃ Γ₀ As Δ_1 Δ'_1,
List.length As = n ∧
List.length Δ_1 = k✝ + 1 ∧
List.length Δ'_1 = k✝ + 1 ∧ A✝ :: (Δ ++ w✝¹) = Δ_1 ++ Γ₀ ∧ liftN n A✝ k✝ :: (Δ' ++ w✝ ++ w✝¹) = Δ'_1 ++ As ++ Γ₀ | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : ∃ Γ₀ As Δ Δ', List.length As = n ∧ List.length Δ = k✝ ∧ List.length Δ' = k✝ ∧ Γ✝ = Δ ++ Γ₀ ∧ Γ'✝ = Δ' ++ As ++ Γ₀
⊢ ∃ Γ₀ As Δ Δ',
List.length As = n ∧
List.length Δ = k✝ + 1 ∧ List.length Δ' = k✝ + 1 ∧ A✝ :: Γ✝ = Δ ++ Γ₀ ∧ liftN n A✝ k✝ :: Γ'✝ = Δ' ++ As ++ Γ₀
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.isSuffix | [13, 1] | [21, 77] | exact ⟨_, _, _ :: Δ, _ :: Δ', hn, by simp [hΔ], by simp [hΔ'], rfl, rfl⟩ | case succ.intro.intro.intro.intro.intro.intro.intro.intro
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ ∃ Γ₀ As Δ_1 Δ'_1,
List.length As = n ∧
List.length Δ_1 = k✝ + 1 ∧
List.length Δ'_1 = k✝ + 1 ∧ A✝ :: (Δ ++ w✝¹) = Δ_1 ++ Γ₀ ∧ liftN n A✝ k✝ :: (Δ' ++ w✝ ++ w✝¹) = Δ'_1 ++ As ++ Γ₀ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro.intro.intro.intro.intro.intro
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ ∃ Γ₀ As Δ_1 Δ'_1,
List.length As = n ∧
List.length Δ_1 = k✝ + 1 ∧
List.length Δ'_1 = k✝ + 1 ∧ A✝ :: (Δ ++ w✝¹) = Δ_1 ++ Γ₀ ∧ liftN n A✝ k✝ :: (Δ' ++ w✝ ++ w✝¹) = Δ'_1 ++ As ++ Γ₀
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.isSuffix | [13, 1] | [21, 77] | simp [hΔ] | n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ List.length (A✝ :: Δ) = k✝ + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ List.length (A✝ :: Δ) = k✝ + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.isSuffix | [13, 1] | [21, 77] | simp [hΔ'] | n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ List.length (liftN n A✝ k✝ :: Δ') = k✝ + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
A✝ : VExpr
w✝¹ w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n
hΔ : List.length Δ = k✝
hΔ' : List.length Δ' = k✝
a✝ : LiftN n k✝ (Δ ++ w✝¹) (Δ' ++ w✝ ++ w✝¹)
⊢ List.length (liftN n A✝ k✝ :: Δ') = k✝ + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.comp | [23, 1] | [33, 50] | obtain ⟨Γ₀', _, Δ, Δ', hn, hΔ, hΔ', eq, rfl⟩ := H2.isSuffix | k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂✝ Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
H2 : LiftN n2 k2 (As ++ Γ₀) Γ₂
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
⊢ LiftN (n1 + n2) 0 Γ₀ Γ₂ | case intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
Γ₀' w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
eq : As ++ Γ₀ = Δ ++ Γ₀'
H2 : LiftN n2 k2 (As ++ Γ₀) (Δ' ++ w✝ ++ Γ₀')
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ Γ₀') | Please generate a tactic in lean4 to solve the state.
STATE:
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂✝ Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
H2 : LiftN n2 k2 (As ++ Γ₀) Γ₂
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
⊢ LiftN (n1 + n2) 0 Γ₀ Γ₂
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.comp | [23, 1] | [33, 50] | obtain ⟨As, rfl, rfl⟩ := (List.append_eq_append_of_length_le (by rwa [h, hΔ])).1 eq.symm | case intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
Γ₀' w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
eq : As ++ Γ₀ = Δ ++ Γ₀'
H2 : LiftN n2 k2 (As ++ Γ₀) (Δ' ++ w✝ ++ Γ₀')
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ Γ₀') | case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ (As ++ Γ₀)) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
Γ₀' w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
eq : As ++ Γ₀ = Δ ++ Γ₀'
H2 : LiftN n2 k2 (As ++ Γ₀) (Δ' ++ w✝ ++ Γ₀')
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ Γ₀')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.comp | [23, 1] | [33, 50] | rw [← List.append_assoc] | case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ (As ++ Γ₀)) | case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ As ++ Γ₀) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ (As ++ Γ₀))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.comp | [23, 1] | [33, 50] | exact .zero _ (by simp [← h, hΔ, hΔ', hn, Nat.add_left_comm, Nat.add_comm]) | case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ As ++ Γ₀) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ LiftN (n1 + n2) 0 Γ₀ (Δ' ++ w✝ ++ As ++ Γ₀)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.comp | [23, 1] | [33, 50] | rwa [h, hΔ] | k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
Γ₀' w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
eq : As ++ Γ₀ = Δ ++ Γ₀'
H2 : LiftN n2 k2 (As ++ Γ₀) (Δ' ++ w✝ ++ Γ₀')
⊢ List.length Δ ≤ List.length As | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ As : List VExpr
h : List.length As = n1
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
Γ₀' w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
eq : As ++ Γ₀ = Δ ++ Γ₀'
H2 : LiftN n2 k2 (As ++ Γ₀) (Δ' ++ w✝ ++ Γ₀')
⊢ List.length Δ ≤ List.length As
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.comp | [23, 1] | [33, 50] | simp [← h, hΔ, hΔ', hn, Nat.add_left_comm, Nat.add_comm] | k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ List.length (Δ' ++ w✝ ++ As) = n1 + n2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k1 k2✝ n1 : Nat
Γ₀✝ Γ₁ : List VExpr
n2 : Nat
Γ₂ : List VExpr
k2 : Nat
Γ₀ : List VExpr
h1 : 0 ≤ k2
h2 : k2 ≤ n1 + 0
w✝ Δ Δ' : List VExpr
hn : List.length w✝ = n2
hΔ : List.length Δ = k2
hΔ' : List.length Δ' = k2
As : List VExpr
h : List.length (Δ ++ As) = n1
eq : Δ ++ As ++ Γ₀ = Δ ++ (As ++ Γ₀)
H2 : LiftN n2 k2 (Δ ++ As ++ Γ₀) (Δ' ++ w✝ ++ (As ++ Γ₀))
⊢ List.length (Δ' ++ w✝ ++ As) = n1 + n2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | constructor <;> intro h | n k : Nat
Γ Γ' : List VExpr
⊢ LiftN n k Γ Γ' ↔ Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' | case mp
n k : Nat
Γ Γ' : List VExpr
h : LiftN n k Γ Γ'
⊢ Lift' (Lift.consN (Lift.skipN n) k) Γ Γ'
case mpr
n k : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ Γ'
⊢ LiftN n k Γ Γ' | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
⊢ LiftN n k Γ Γ' ↔ Lift' (Lift.consN (Lift.skipN n) k) Γ Γ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | induction h with
| zero As =>
subst n
induction As with
| nil => simp [Lift'.refl]
| cons _ _ ih => exact .skip ih
| succ _ ih => rw [← lift'_consN_skipN]; exact .cons ih | case mp
n k : Nat
Γ Γ' : List VExpr
h : LiftN n k Γ Γ'
⊢ Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
n k : Nat
Γ Γ' : List VExpr
h : LiftN n k Γ Γ'
⊢ Lift' (Lift.consN (Lift.skipN n) k) Γ Γ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | subst n | case mp.zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
⊢ Lift' (Lift.consN (Lift.skipN n) 0) Γ✝ (As ++ Γ✝) | case mp.zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
⊢ Lift' (Lift.consN (Lift.skipN (List.length As)) 0) Γ✝ (As ++ Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
⊢ Lift' (Lift.consN (Lift.skipN n) 0) Γ✝ (As ++ Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | induction As with
| nil => simp [Lift'.refl]
| cons _ _ ih => exact .skip ih | case mp.zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
⊢ Lift' (Lift.consN (Lift.skipN (List.length As)) 0) Γ✝ (As ++ Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
⊢ Lift' (Lift.consN (Lift.skipN (List.length As)) 0) Γ✝ (As ++ Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | simp [Lift'.refl] | case mp.zero.nil
k : Nat
Γ Γ' Γ✝ : List VExpr
⊢ Lift' (Lift.consN (Lift.skipN (List.length [])) 0) Γ✝ ([] ++ Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.zero.nil
k : Nat
Γ Γ' Γ✝ : List VExpr
⊢ Lift' (Lift.consN (Lift.skipN (List.length [])) 0) Γ✝ ([] ++ Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | exact .skip ih | case mp.zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
head✝ : VExpr
tail✝ : List VExpr
ih : Lift' (Lift.consN (Lift.skipN (List.length tail✝)) 0) Γ✝ (tail✝ ++ Γ✝)
⊢ Lift' (Lift.consN (Lift.skipN (List.length (head✝ :: tail✝))) 0) Γ✝ (head✝ :: tail✝ ++ Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
head✝ : VExpr
tail✝ : List VExpr
ih : Lift' (Lift.consN (Lift.skipN (List.length tail✝)) 0) Γ✝ (tail✝ ++ Γ✝)
⊢ Lift' (Lift.consN (Lift.skipN (List.length (head✝ :: tail✝))) 0) Γ✝ (head✝ :: tail✝ ++ Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | rw [← lift'_consN_skipN] | case mp.succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : Lift' (Lift.consN (Lift.skipN n) k✝) Γ✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN n) (k✝ + 1)) (A✝ :: Γ✝) (liftN n A✝ k✝ :: Γ'✝) | case mp.succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : Lift' (Lift.consN (Lift.skipN n) k✝) Γ✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN n) (k✝ + 1)) (A✝ :: Γ✝) (lift' A✝ (Lift.consN (Lift.skipN n) k✝) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : Lift' (Lift.consN (Lift.skipN n) k✝) Γ✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN n) (k✝ + 1)) (A✝ :: Γ✝) (liftN n A✝ k✝ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | exact .cons ih | case mp.succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : Lift' (Lift.consN (Lift.skipN n) k✝) Γ✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN n) (k✝ + 1)) (A✝ :: Γ✝) (lift' A✝ (Lift.consN (Lift.skipN n) k✝) :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.succ
n k : Nat
Γ Γ' : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : LiftN n k✝ Γ✝ Γ'✝
ih : Lift' (Lift.consN (Lift.skipN n) k✝) Γ✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN n) (k✝ + 1)) (A✝ :: Γ✝) (lift' A✝ (Lift.consN (Lift.skipN n) k✝) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | induction k generalizing Γ Γ' with
| zero =>
obtain ⟨_, rfl, eq⟩ : ∃ As, Γ' = As ++ Γ ∧ As.length = n := by
induction n generalizing Γ' with
| zero => cases h; exact ⟨[], rfl, rfl⟩
| succ n ih => let .skip h := h; obtain ⟨_, rfl, rfl⟩ := ih h; exact ⟨_::_, rfl, rfl⟩
exact .zero _ eq
| succ k ih => let .cons h := h; rw [lift'_consN_skipN]; exact .succ (ih h) | case mpr
n k : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ Γ'
⊢ LiftN n k Γ Γ' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
n k : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ Γ'
⊢ LiftN n k Γ Γ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | obtain ⟨_, rfl, eq⟩ : ∃ As, Γ' = As ++ Γ ∧ As.length = n := by
induction n generalizing Γ' with
| zero => cases h; exact ⟨[], rfl, rfl⟩
| succ n ih => let .skip h := h; obtain ⟨_, rfl, rfl⟩ := ih h; exact ⟨_::_, rfl, rfl⟩ | case mpr.zero
n : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ'
⊢ LiftN n Nat.zero Γ Γ' | case mpr.zero.intro.intro
n : Nat
Γ w✝ : List VExpr
eq : List.length w✝ = n
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ (w✝ ++ Γ)
⊢ LiftN n Nat.zero Γ (w✝ ++ Γ) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.zero
n : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ'
⊢ LiftN n Nat.zero Γ Γ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | exact .zero _ eq | case mpr.zero.intro.intro
n : Nat
Γ w✝ : List VExpr
eq : List.length w✝ = n
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ (w✝ ++ Γ)
⊢ LiftN n Nat.zero Γ (w✝ ++ Γ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.zero.intro.intro
n : Nat
Γ w✝ : List VExpr
eq : List.length w✝ = n
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ (w✝ ++ Γ)
⊢ LiftN n Nat.zero Γ (w✝ ++ Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | induction n generalizing Γ' with
| zero => cases h; exact ⟨[], rfl, rfl⟩
| succ n ih => let .skip h := h; obtain ⟨_, rfl, rfl⟩ := ih h; exact ⟨_::_, rfl, rfl⟩ | n : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ'
⊢ ∃ As, Γ' = As ++ Γ ∧ List.length As = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ'
⊢ ∃ As, Γ' = As ++ Γ ∧ List.length As = n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | cases h | case zero
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN Nat.zero) Nat.zero) Γ Γ'
⊢ ∃ As, Γ' = As ++ Γ ∧ List.length As = Nat.zero | case zero.refl
Γ : List VExpr
⊢ ∃ As, Γ = As ++ Γ ∧ List.length As = Nat.zero | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN Nat.zero) Nat.zero) Γ Γ'
⊢ ∃ As, Γ' = As ++ Γ ∧ List.length As = Nat.zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | exact ⟨[], rfl, rfl⟩ | case zero.refl
Γ : List VExpr
⊢ ∃ As, Γ = As ++ Γ ∧ List.length As = Nat.zero | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.refl
Γ : List VExpr
⊢ ∃ As, Γ = As ++ Γ ∧ List.length As = Nat.zero
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | let .skip h := h | case succ
Γ : List VExpr
n : Nat
ih : ∀ {Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ' → ∃ As, Γ' = As ++ Γ ∧ List.length As = n
Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN (Nat.succ n)) Nat.zero) Γ Γ'
⊢ ∃ As, Γ' = As ++ Γ ∧ List.length As = Nat.succ n | case succ
Γ : List VExpr
n : Nat
ih : ∀ {Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ' → ∃ As, Γ' = As ++ Γ ∧ List.length As = n
Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN (Nat.succ n)) Nat.zero) Γ Γ'
Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.skipN n) Γ Γ'✝
⊢ ∃ As, A✝ :: Γ'✝ = As ++ Γ ∧ List.length As = Nat.succ n | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Γ : List VExpr
n : Nat
ih : ∀ {Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ' → ∃ As, Γ' = As ++ Γ ∧ List.length As = n
Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN (Nat.succ n)) Nat.zero) Γ Γ'
⊢ ∃ As, Γ' = As ++ Γ ∧ List.length As = Nat.succ n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | obtain ⟨_, rfl, rfl⟩ := ih h | case succ
Γ : List VExpr
n : Nat
ih : ∀ {Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ' → ∃ As, Γ' = As ++ Γ ∧ List.length As = n
Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN (Nat.succ n)) Nat.zero) Γ Γ'
Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.skipN n) Γ Γ'✝
⊢ ∃ As, A✝ :: Γ'✝ = As ++ Γ ∧ List.length As = Nat.succ n | case succ.intro.intro
Γ Γ' : List VExpr
A✝ : VExpr
w✝ : List VExpr
ih :
∀ {Γ' : List VExpr},
Lift' (Lift.consN (Lift.skipN (List.length w✝)) Nat.zero) Γ Γ' →
∃ As, Γ' = As ++ Γ ∧ List.length As = List.length w✝
h✝ : Lift' (Lift.consN (Lift.skipN (Nat.succ (List.length w✝))) Nat.zero) Γ Γ'
h : Lift' (Lift.skipN (List.length w✝)) Γ (w✝ ++ Γ)
⊢ ∃ As, A✝ :: (w✝ ++ Γ) = As ++ Γ ∧ List.length As = Nat.succ (List.length w✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Γ : List VExpr
n : Nat
ih : ∀ {Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) Nat.zero) Γ Γ' → ∃ As, Γ' = As ++ Γ ∧ List.length As = n
Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN (Nat.succ n)) Nat.zero) Γ Γ'
Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.skipN n) Γ Γ'✝
⊢ ∃ As, A✝ :: Γ'✝ = As ++ Γ ∧ List.length As = Nat.succ n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | exact ⟨_::_, rfl, rfl⟩ | case succ.intro.intro
Γ Γ' : List VExpr
A✝ : VExpr
w✝ : List VExpr
ih :
∀ {Γ' : List VExpr},
Lift' (Lift.consN (Lift.skipN (List.length w✝)) Nat.zero) Γ Γ' →
∃ As, Γ' = As ++ Γ ∧ List.length As = List.length w✝
h✝ : Lift' (Lift.consN (Lift.skipN (Nat.succ (List.length w✝))) Nat.zero) Γ Γ'
h : Lift' (Lift.skipN (List.length w✝)) Γ (w✝ ++ Γ)
⊢ ∃ As, A✝ :: (w✝ ++ Γ) = As ++ Γ ∧ List.length As = Nat.succ (List.length w✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro
Γ Γ' : List VExpr
A✝ : VExpr
w✝ : List VExpr
ih :
∀ {Γ' : List VExpr},
Lift' (Lift.consN (Lift.skipN (List.length w✝)) Nat.zero) Γ Γ' →
∃ As, Γ' = As ++ Γ ∧ List.length As = List.length w✝
h✝ : Lift' (Lift.consN (Lift.skipN (Nat.succ (List.length w✝))) Nat.zero) Γ Γ'
h : Lift' (Lift.skipN (List.length w✝)) Γ (w✝ ++ Γ)
⊢ ∃ As, A✝ :: (w✝ ++ Γ) = As ++ Γ ∧ List.length As = Nat.succ (List.length w✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | let .cons h := h | case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
⊢ LiftN n (Nat.succ k) Γ Γ' | case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ✝ Γ'✝
⊢ LiftN n (Nat.succ k) (A✝ :: Γ✝) (lift' A✝ (Lift.consN (Lift.skipN n) k) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
⊢ LiftN n (Nat.succ k) Γ Γ'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | rw [lift'_consN_skipN] | case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ✝ Γ'✝
⊢ LiftN n (Nat.succ k) (A✝ :: Γ✝) (lift' A✝ (Lift.consN (Lift.skipN n) k) :: Γ'✝) | case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ✝ Γ'✝
⊢ LiftN n (Nat.succ k) (A✝ :: Γ✝) (liftN n A✝ k :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ✝ Γ'✝
⊢ LiftN n (Nat.succ k) (A✝ :: Γ✝) (lift' A✝ (Lift.consN (Lift.skipN n) k) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.liftN_iff_lift' | [40, 1] | [56, 80] | exact .succ (ih h) | case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ✝ Γ'✝
⊢ LiftN n (Nat.succ k) (A✝ :: Γ✝) (liftN n A✝ k :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.succ
n k : Nat
ih : ∀ {Γ Γ' : List VExpr}, Lift' (Lift.consN (Lift.skipN n) k) Γ Γ' → LiftN n k Γ Γ'
Γ Γ' : List VExpr
h✝ : Lift' (Lift.consN (Lift.skipN n) (Nat.succ k)) Γ Γ'
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
h : Lift' (Lift.consN (Lift.skipN n) k) Γ✝ Γ'✝
⊢ LiftN n (Nat.succ k) (A✝ :: Γ✝) (liftN n A✝ k :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | induction H2 generalizing l₁ Γ₁ with
| refl => exact H1
| skip _ ih => exact .skip (ih H1)
| cons H2 ih =>
cases H1 with
| refl => exact .cons H2
| skip H1 => exact .skip (ih H1)
| cons H1 => rw [← VExpr.lift'_comp]; exact .cons (ih H1) | l₁ : Lift
Γ₁ Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
H1 : Lift' l₁ Γ₁ Γ₂
H2 : Lift' l₂ Γ₂ Γ₃
⊢ Lift' (Lift.comp l₁ l₂) Γ₁ Γ₃ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l₁ : Lift
Γ₁ Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
H1 : Lift' l₁ Γ₁ Γ₂
H2 : Lift' l₂ Γ₂ Γ₃
⊢ Lift' (Lift.comp l₁ l₂) Γ₁ Γ₃
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | exact H1 | case refl
Γ₂ : List VExpr
l₂ : Lift
Γ₃ Γ✝ : List VExpr
l₁ : Lift
Γ₁ : List VExpr
H1 : Lift' l₁ Γ₁ Γ✝
⊢ Lift' (Lift.comp l₁ Lift.refl) Γ₁ Γ✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
Γ₂ : List VExpr
l₂ : Lift
Γ₃ Γ✝ : List VExpr
l₁ : Lift
Γ₁ : List VExpr
H1 : Lift' l₁ Γ₁ Γ✝
⊢ Lift' (Lift.comp l₁ Lift.refl) Γ₁ Γ✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | exact .skip (ih H1) | case skip
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Lift' l✝ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝) Γ₁ Γ'✝
l₁ : Lift
Γ₁ : List VExpr
H1 : Lift' l₁ Γ₁ Γ✝
⊢ Lift' (Lift.comp l₁ (Lift.skip l✝)) Γ₁ (A✝ :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case skip
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Lift' l✝ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝) Γ₁ Γ'✝
l₁ : Lift
Γ₁ : List VExpr
H1 : Lift' l₁ Γ₁ Γ✝
⊢ Lift' (Lift.comp l₁ (Lift.skip l✝)) Γ₁ (A✝ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | cases H1 with
| refl => exact .cons H2
| skip H1 => exact .skip (ih H1)
| cons H1 => rw [← VExpr.lift'_comp]; exact .cons (ih H1) | case cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H2 : Lift' l✝ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝) Γ₁ Γ'✝
l₁ : Lift
Γ₁ : List VExpr
H1 : Lift' l₁ Γ₁ (A✝ :: Γ✝)
⊢ Lift' (Lift.comp l₁ (Lift.cons l✝)) Γ₁ (lift' A✝ l✝ :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H2 : Lift' l✝ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝) Γ₁ Γ'✝
l₁ : Lift
Γ₁ : List VExpr
H1 : Lift' l₁ Γ₁ (A✝ :: Γ✝)
⊢ Lift' (Lift.comp l₁ (Lift.cons l✝)) Γ₁ (lift' A✝ l✝ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | exact .cons H2 | case cons.refl
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H2 : Lift' l✝ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝) Γ₁ Γ'✝
⊢ Lift' (Lift.comp Lift.refl (Lift.cons l✝)) (A✝ :: Γ✝) (lift' A✝ l✝ :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.refl
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H2 : Lift' l✝ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝) Γ₁ Γ'✝
⊢ Lift' (Lift.comp Lift.refl (Lift.cons l✝)) (A✝ :: Γ✝) (lift' A✝ l✝ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | exact .skip (ih H1) | case cons.skip
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H2 : Lift' l✝¹ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
Γ₁ : List VExpr
l✝ : Lift
H1 : Lift' l✝ Γ₁ Γ✝
⊢ Lift' (Lift.comp (Lift.skip l✝) (Lift.cons l✝¹)) Γ₁ (lift' A✝ l✝¹ :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.skip
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H2 : Lift' l✝¹ Γ✝ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
Γ₁ : List VExpr
l✝ : Lift
H1 : Lift' l✝ Γ₁ Γ✝
⊢ Lift' (Lift.comp (Lift.skip l✝) (Lift.cons l✝¹)) Γ₁ (lift' A✝ l✝¹ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | rw [← VExpr.lift'_comp] | case cons.cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝¹ Γ'✝ : List VExpr
H2 : Lift' l✝¹ Γ✝¹ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝¹ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
l✝ : Lift
Γ✝ : List VExpr
A✝ : VExpr
H1 : Lift' l✝ Γ✝ Γ✝¹
⊢ Lift' (Lift.comp (Lift.cons l✝) (Lift.cons l✝¹)) (A✝ :: Γ✝) (lift' (lift' A✝ l✝) l✝¹ :: Γ'✝) | case cons.cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝¹ Γ'✝ : List VExpr
H2 : Lift' l✝¹ Γ✝¹ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝¹ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
l✝ : Lift
Γ✝ : List VExpr
A✝ : VExpr
H1 : Lift' l✝ Γ✝ Γ✝¹
⊢ Lift' (Lift.comp (Lift.cons l✝) (Lift.cons l✝¹)) (A✝ :: Γ✝) (lift' A✝ (Lift.comp l✝ l✝¹) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝¹ Γ'✝ : List VExpr
H2 : Lift' l✝¹ Γ✝¹ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝¹ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
l✝ : Lift
Γ✝ : List VExpr
A✝ : VExpr
H1 : Lift' l✝ Γ✝ Γ✝¹
⊢ Lift' (Lift.comp (Lift.cons l✝) (Lift.cons l✝¹)) (A✝ :: Γ✝) (lift' (lift' A✝ l✝) l✝¹ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.comp | [58, 1] | [67, 62] | exact .cons (ih H1) | case cons.cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝¹ Γ'✝ : List VExpr
H2 : Lift' l✝¹ Γ✝¹ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝¹ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
l✝ : Lift
Γ✝ : List VExpr
A✝ : VExpr
H1 : Lift' l✝ Γ✝ Γ✝¹
⊢ Lift' (Lift.comp (Lift.cons l✝) (Lift.cons l✝¹)) (A✝ :: Γ✝) (lift' A✝ (Lift.comp l✝ l✝¹) :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.cons
Γ₂ : List VExpr
l₂ : Lift
Γ₃ : List VExpr
l✝¹ : Lift
Γ✝¹ Γ'✝ : List VExpr
H2 : Lift' l✝¹ Γ✝¹ Γ'✝
ih : ∀ {l₁ : Lift} {Γ₁ : List VExpr}, Lift' l₁ Γ₁ Γ✝¹ → Lift' (Lift.comp l₁ l✝¹) Γ₁ Γ'✝
l✝ : Lift
Γ✝ : List VExpr
A✝ : VExpr
H1 : Lift' l✝ Γ✝ Γ✝¹
⊢ Lift' (Lift.comp (Lift.cons l✝) (Lift.cons l✝¹)) (A✝ :: Γ✝) (lift' A✝ (Lift.comp l✝ l✝¹) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | induction k generalizing Γ₁ Γ₃ with
| zero => let .skip H := H; exact ⟨_, H, .one⟩
| succ k ih =>
let .cons (A := A) H := H
let ⟨_, h1, h2⟩ := ih H
refine ⟨_, .cons h1, ?_⟩
simp only [Ctx.liftN_iff_lift'] at h2 ⊢
simpa [← VExpr.lift'_comp, ← Lift.consN_comp] using h2.cons (A := lift' A (.consN l k)) | l : Lift
k : Nat
Γ₁ Γ₃ : List VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃
⊢ ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
k : Nat
Γ₁ Γ₃ : List VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃
⊢ ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | let .skip H := H | case zero
l : Lift
Γ₁ Γ₃ : List VExpr
H : Lift' (Lift.consN (Lift.skip l) Nat.zero) Γ₁ Γ₃
⊢ ∃ Γ₂, Lift' (Lift.consN l Nat.zero) Γ₁ Γ₂ ∧ LiftN 1 Nat.zero Γ₂ Γ₃ | case zero
l : Lift
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) Nat.zero) Γ₁ Γ₃
Γ'✝ : List VExpr
A✝ : VExpr
H : Lift' l Γ₁ Γ'✝
⊢ ∃ Γ₂, Lift' (Lift.consN l Nat.zero) Γ₁ Γ₂ ∧ LiftN 1 Nat.zero Γ₂ (A✝ :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
l : Lift
Γ₁ Γ₃ : List VExpr
H : Lift' (Lift.consN (Lift.skip l) Nat.zero) Γ₁ Γ₃
⊢ ∃ Γ₂, Lift' (Lift.consN l Nat.zero) Γ₁ Γ₂ ∧ LiftN 1 Nat.zero Γ₂ Γ₃
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | exact ⟨_, H, .one⟩ | case zero
l : Lift
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) Nat.zero) Γ₁ Γ₃
Γ'✝ : List VExpr
A✝ : VExpr
H : Lift' l Γ₁ Γ'✝
⊢ ∃ Γ₂, Lift' (Lift.consN l Nat.zero) Γ₁ Γ₂ ∧ LiftN 1 Nat.zero Γ₂ (A✝ :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
l : Lift
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) Nat.zero) Γ₁ Γ₃
Γ'✝ : List VExpr
A✝ : VExpr
H : Lift' l Γ₁ Γ'✝
⊢ ∃ Γ₂, Lift' (Lift.consN l Nat.zero) Γ₁ Γ₂ ∧ LiftN 1 Nat.zero Γ₂ (A✝ :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | let .cons (A := A) H := H | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
⊢ ∃ Γ₂, Lift' (Lift.consN l (Nat.succ k)) Γ₁ Γ₂ ∧ LiftN 1 (Nat.succ k) Γ₂ Γ₃ | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
⊢ ∃ Γ₂,
Lift' (Lift.consN l (Nat.succ k)) (A :: Γ✝) Γ₂ ∧
LiftN 1 (Nat.succ k) Γ₂ (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
⊢ ∃ Γ₂, Lift' (Lift.consN l (Nat.succ k)) Γ₁ Γ₂ ∧ LiftN 1 (Nat.succ k) Γ₂ Γ₃
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | let ⟨_, h1, h2⟩ := ih H | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
⊢ ∃ Γ₂,
Lift' (Lift.consN l (Nat.succ k)) (A :: Γ✝) Γ₂ ∧
LiftN 1 (Nat.succ k) Γ₂ (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : LiftN 1 k w✝ Γ'✝
⊢ ∃ Γ₂,
Lift' (Lift.consN l (Nat.succ k)) (A :: Γ✝) Γ₂ ∧
LiftN 1 (Nat.succ k) Γ₂ (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
⊢ ∃ Γ₂,
Lift' (Lift.consN l (Nat.succ k)) (A :: Γ✝) Γ₂ ∧
LiftN 1 (Nat.succ k) Γ₂ (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | refine ⟨_, .cons h1, ?_⟩ | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : LiftN 1 k w✝ Γ'✝
⊢ ∃ Γ₂,
Lift' (Lift.consN l (Nat.succ k)) (A :: Γ✝) Γ₂ ∧
LiftN 1 (Nat.succ k) Γ₂ (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : LiftN 1 k w✝ Γ'✝
⊢ LiftN 1 (Nat.succ k) (lift' A (Lift.consN l k) :: w✝) (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : LiftN 1 k w✝ Γ'✝
⊢ ∃ Γ₂,
Lift' (Lift.consN l (Nat.succ k)) (A :: Γ✝) Γ₂ ∧
LiftN 1 (Nat.succ k) Γ₂ (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | simp only [Ctx.liftN_iff_lift'] at h2 ⊢ | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : LiftN 1 k w✝ Γ'✝
⊢ LiftN 1 (Nat.succ k) (lift' A (Lift.consN l k) :: w✝) (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : Lift' (Lift.consN (Lift.skipN 1) k) w✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN 1) (Nat.succ k)) (lift' A (Lift.consN l k) :: w✝)
(lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : LiftN 1 k w✝ Γ'✝
⊢ LiftN 1 (Nat.succ k) (lift' A (Lift.consN l k) :: w✝) (lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.of_cons_skip | [69, 1] | [78, 92] | simpa [← VExpr.lift'_comp, ← Lift.consN_comp] using h2.cons (A := lift' A (.consN l k)) | case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : Lift' (Lift.consN (Lift.skipN 1) k) w✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN 1) (Nat.succ k)) (lift' A (Lift.consN l k) :: w✝)
(lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
l : Lift
k : Nat
ih :
∀ {Γ₁ Γ₃ : List VExpr},
Lift' (Lift.consN (Lift.skip l) k) Γ₁ Γ₃ → ∃ Γ₂, Lift' (Lift.consN l k) Γ₁ Γ₂ ∧ LiftN 1 k Γ₂ Γ₃
Γ₁ Γ₃ : List VExpr
H✝ : Lift' (Lift.consN (Lift.skip l) (Nat.succ k)) Γ₁ Γ₃
Γ✝ Γ'✝ : List VExpr
A : VExpr
H : Lift' (Lift.consN (Lift.skip l) k) Γ✝ Γ'✝
w✝ : List VExpr
h1 : Lift' (Lift.consN l k) Γ✝ w✝
h2 : Lift' (Lift.consN (Lift.skipN 1) k) w✝ Γ'✝
⊢ Lift' (Lift.consN (Lift.skipN 1) (Nat.succ k)) (lift' A (Lift.consN l k) :: w✝)
(lift' A (Lift.consN (Lift.skip l) k) :: Γ'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.Lift'.depth_zero | [80, 1] | [82, 91] | rw [VExpr.lift'_depth_zero (l := l) h, H.depth_zero (l := l) h] | l✝ : Lift
Γ Γ' : List VExpr
l : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H : Lift' l Γ✝ Γ'✝
h : Lift.depth (Lift.cons l) = 0
⊢ A✝ :: Γ✝ = lift' A✝ l :: Γ'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l✝ : Lift
Γ Γ' : List VExpr
l : Lift
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
H : Lift' l Γ✝ Γ'✝
h : Lift.depth (Lift.cons l) = 0
⊢ A✝ :: Γ✝ = lift' A✝ l :: Γ'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.lt | [89, 1] | [92, 43] | induction H with
| zero => apply Nat.succ_pos
| succ _ ih => apply Nat.succ_lt_succ ih | Γ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ i A
⊢ i < List.length Γ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Γ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ i A
⊢ i < List.length Γ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.lt | [89, 1] | [92, 43] | apply Nat.succ_pos | case zero
Γ : List VExpr
i : Nat
A ty✝ : VExpr
Γ✝ : List VExpr
⊢ 0 < List.length (ty✝ :: Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
Γ : List VExpr
i : Nat
A ty✝ : VExpr
Γ✝ : List VExpr
⊢ 0 < List.length (ty✝ :: Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.lt | [89, 1] | [92, 43] | apply Nat.succ_lt_succ ih | case succ
Γ : List VExpr
i : Nat
A : VExpr
Γ✝ : List VExpr
n✝ : Nat
ty✝ A✝ : VExpr
a✝ : Lookup Γ✝ n✝ ty✝
ih : n✝ < List.length Γ✝
⊢ n✝ + 1 < List.length (A✝ :: Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Γ : List VExpr
i : Nat
A : VExpr
Γ✝ : List VExpr
n✝ : Nat
ty✝ A✝ : VExpr
a✝ : Lookup Γ✝ n✝ ty✝
ih : n✝ < List.length Γ✝
⊢ n✝ + 1 < List.length (A✝ :: Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | induction W generalizing i A with
| zero As =>
rw [liftVar_base, Nat.add_comm]
subst n
induction As with simp [*]
| cons _ _ ih => rw [liftN_succ]; exact .succ ih
| @succ k _ _ _ _ ih =>
match H with
| .zero => rw [liftVar_zero, ← lift_liftN']; exact .zero
| .succ H => rw [liftVar_succ, ← lift_liftN']; exact (ih H).succ | n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : Lookup Γ i A
⊢ Lookup Γ' (liftVar n i k) (liftN n A k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : Lookup Γ i A
⊢ Lookup Γ' (liftVar n i k) (liftN n A k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | rw [liftVar_base, Nat.add_comm] | case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (liftVar n i) (liftN n A) | case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (i + n) (liftN n A) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (liftVar n i) (liftN n A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | subst n | case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (i + n) (liftN n A) | case zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (i + n) (liftN n A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | induction As with simp [*]
| cons _ _ ih => rw [liftN_succ]; exact .succ ih | case zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | rw [liftN_succ] | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
head✝ : VExpr
tail✝ : List VExpr
ih : Lookup (tail✝ ++ Γ✝) (i + List.length tail✝) (liftN (List.length tail✝) A)
⊢ Lookup (head✝ :: (tail✝ ++ Γ✝)) (i + Nat.succ (List.length tail✝)) (liftN (Nat.succ (List.length tail✝)) A) | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
head✝ : VExpr
tail✝ : List VExpr
ih : Lookup (tail✝ ++ Γ✝) (i + List.length tail✝) (liftN (List.length tail✝) A)
⊢ Lookup (head✝ :: (tail✝ ++ Γ✝)) (i + Nat.succ (List.length tail✝)) (lift (liftN (List.length tail✝) A)) | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
head✝ : VExpr
tail✝ : List VExpr
ih : Lookup (tail✝ ++ Γ✝) (i + List.length tail✝) (liftN (List.length tail✝) A)
⊢ Lookup (head✝ :: (tail✝ ++ Γ✝)) (i + Nat.succ (List.length tail✝)) (liftN (Nat.succ (List.length tail✝)) A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | exact .succ ih | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
head✝ : VExpr
tail✝ : List VExpr
ih : Lookup (tail✝ ++ Γ✝) (i + List.length tail✝) (liftN (List.length tail✝) A)
⊢ Lookup (head✝ :: (tail✝ ++ Γ✝)) (i + Nat.succ (List.length tail✝)) (lift (liftN (List.length tail✝) A)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
head✝ : VExpr
tail✝ : List VExpr
ih : Lookup (tail✝ ++ Γ✝) (i + List.length tail✝) (liftN (List.length tail✝) A)
⊢ Lookup (head✝ :: (tail✝ ++ Γ✝)) (i + Nat.succ (List.length tail✝)) (lift (liftN (List.length tail✝) A))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | match H with
| .zero => rw [liftVar_zero, ← lift_liftN']; exact .zero
| .succ H => rw [liftVar_succ, ← lift_liftN']; exact (ih H).succ | case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) (liftN n A (k + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) (liftN n A (k + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | rw [liftVar_zero, ← lift_liftN'] | n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n 0 (k + 1)) (liftN n (lift A✝) (k + 1)) | n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) 0 (lift (liftN n A✝ k)) | Please generate a tactic in lean4 to solve the state.
STATE:
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n 0 (k + 1)) (liftN n (lift A✝) (k + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | exact .zero | n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) 0 (lift (liftN n A✝ k)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H : Lookup (A✝ :: Γ✝) i A
⊢ Lookup (liftN n A✝ k :: Γ'✝) 0 (lift (liftN n A✝ k))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | rw [liftVar_succ, ← lift_liftN'] | n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H✝ : Lookup (A✝ :: Γ✝) i A
n✝ : Nat
ty✝ : VExpr
H : Lookup Γ✝ n✝ ty✝
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n (n✝ + 1) (k + 1)) (liftN n (lift ty✝) (k + 1)) | n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H✝ : Lookup (A✝ :: Γ✝) i A
n✝ : Nat
ty✝ : VExpr
H : Lookup Γ✝ n✝ ty✝
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n n✝ k + 1) (lift (liftN n ty✝ k)) | Please generate a tactic in lean4 to solve the state.
STATE:
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H✝ : Lookup (A✝ :: Γ✝) i A
n✝ : Nat
ty✝ : VExpr
H : Lookup Γ✝ n✝ ty✝
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n (n✝ + 1) (k + 1)) (liftN n (lift ty✝) (k + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN | [104, 1] | [115, 69] | exact (ih H).succ | n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H✝ : Lookup (A✝ :: Γ✝) i A
n✝ : Nat
ty✝ : VExpr
H : Lookup Γ✝ n✝ ty✝
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n n✝ k + 1) (lift (liftN n ty✝ k)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ✝ i A → Lookup Γ'✝ (liftVar n i k) (liftN n A k)
i : Nat
A : VExpr
H✝ : Lookup (A✝ :: Γ✝) i A
n✝ : Nat
ty✝ : VExpr
H : Lookup Γ✝ n✝ ty✝
⊢ Lookup (liftN n A✝ k :: Γ'✝) (liftVar n n✝ k + 1) (lift (liftN n ty✝ k))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | refine ⟨fun H => ?_, fun H => H.weakN W⟩ | n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
⊢ Lookup Γ' (liftVar n i k) (liftN n A k) ↔ Lookup Γ i A | n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : Lookup Γ' (liftVar n i k) (liftN n A k)
⊢ Lookup Γ i A | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
⊢ Lookup Γ' (liftVar n i k) (liftN n A k) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | induction W generalizing i A with
| zero As =>
rw [liftVar_base, Nat.add_comm] at H
subst n
induction As with simp at H
| nil => exact H
| cons A As ih =>
rw [liftN_succ] at H
generalize eq : lift (liftN ..) = A' at H
obtain _|H := H; cases liftN_inj.1 eq
exact ih H
| @succ k _ _ _ _ ih =>
generalize eA : liftN n A (k+1) = A' at H
cases i with
| zero =>
simp at H; let .zero := H
rw [lift, liftN'_comm (h := Nat.zero_le _), Nat.add_comm 1, liftN_inj] at eA
subst A; exact .zero
| succ i =>
simp at H; let .succ H := H
obtain ⟨_, rfl, rfl⟩ := of_liftN_eq_liftN (k2 := 0) eA
exact .succ (ih H) | n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : Lookup Γ' (liftVar n i k) (liftN n A k)
⊢ Lookup Γ i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : Nat
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : Lookup Γ' (liftVar n i k) (liftN n A k)
⊢ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | rw [liftVar_base, Nat.add_comm] at H | case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (liftVar n i) (liftN n A)
⊢ Lookup Γ✝ i A | case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (i + n) (liftN n A)
⊢ Lookup Γ✝ i A | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (liftVar n i) (liftN n A)
⊢ Lookup Γ✝ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | subst n | case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (i + n) (liftN n A)
⊢ Lookup Γ✝ i A | case zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A)
⊢ Lookup Γ✝ i A | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n k : Nat
Γ Γ' Γ✝ As : List VExpr
h✝ : List.length As = n
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (i + n) (liftN n A)
⊢ Lookup Γ✝ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | induction As with simp at H
| nil => exact H
| cons A As ih =>
rw [liftN_succ] at H
generalize eq : lift (liftN ..) = A' at H
obtain _|H := H; cases liftN_inj.1 eq
exact ih H | case zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A)
⊢ Lookup Γ✝ i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
k : Nat
Γ Γ' Γ✝ As : List VExpr
i : Nat
A : VExpr
H : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A)
⊢ Lookup Γ✝ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | exact H | case zero.nil
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup Γ✝ i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.nil
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A : VExpr
H : Lookup Γ✝ i A
⊢ Lookup Γ✝ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | rw [liftN_succ] at H | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) (liftN (Nat.succ (List.length As)) A✝)
⊢ Lookup Γ✝ i A✝ | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) (lift (liftN (List.length As) A✝))
⊢ Lookup Γ✝ i A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) (liftN (Nat.succ (List.length As)) A✝)
⊢ Lookup Γ✝ i A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | generalize eq : lift (liftN ..) = A' at H | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) (lift (liftN (List.length As) A✝))
⊢ Lookup Γ✝ i A✝ | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
A' : VExpr
eq : lift (liftN (List.length As) A✝) = A'
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) A'
⊢ Lookup Γ✝ i A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) (lift (liftN (List.length As) A✝))
⊢ Lookup Γ✝ i A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | obtain _|H := H | case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
A' : VExpr
eq : lift (liftN (List.length As) A✝) = A'
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) A'
⊢ Lookup Γ✝ i A✝ | case zero.cons.succ
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
ty✝ : VExpr
H : Lookup (As ++ Γ✝) (Nat.add i (List.length As)) ty✝
eq : lift (liftN (List.length As) A✝) = lift ty✝
⊢ Lookup Γ✝ i A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
A' : VExpr
eq : lift (liftN (List.length As) A✝) = A'
H : Lookup (A :: (As ++ Γ✝)) (i + Nat.succ (List.length As)) A'
⊢ Lookup Γ✝ i A✝
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.