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/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | induction H generalizing k Γ' with
| bvar | sort | const => exact rfl
| app _ _ ih1 ih2 => exact .app (ih1 W) (ih2 W)
| lam _ _ ih1 ih2 => exact .lam (ih1 W) (ih2 W.succ)
| forallE _ _ ih1 ih2 => exact .forallE (ih1 W) (ih2 W.succ)
| beta _ _ ih1 ih2 =>
simp [liftN, liftN_inst_hi]
exact .beta (ih1 W.succ) (ih2 W)
| extra _ ih =>
refine .extra fun a a' h => ?_
obtain ⟨_, _, h', rfl, rfl⟩ := HE W h
exact ih _ _ h' W | E : Extra
HE : Extra.IsWeakN E
n k : Nat
Γ Γ' : List VExpr
e1 e2 : VExpr
W : Ctx.LiftN n k Γ Γ'
H : ParRed E Γ e1 e2
⊢ ParRed E Γ' (liftN n e1 k) (liftN n e2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Extra
HE : Extra.IsWeakN E
n k : Nat
Γ Γ' : List VExpr
e1 e2 : VExpr
W : Ctx.LiftN n k Γ Γ'
H : ParRed E Γ e1 e2
⊢ ParRed E Γ' (liftN n e1 k) (liftN n e2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | exact rfl | case const
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
c✝ : Name
ls✝ : List VLevel
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
c✝ : Name
ls✝ : List VLevel
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | exact .app (ih1 W) (ih2 W) | case app
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
f✝ f'✝ a✝² a'✝ : VExpr
a✝¹ : ParRed E Γ✝ f✝ f'✝
a✝ : ParRed E Γ✝ a✝² a'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n f✝ k) (liftN n f'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a✝² k) (liftN n a'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.app f✝ a✝²) k) (liftN n (VExpr.app f'✝ a'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case app
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
f✝ f'✝ a✝² a'✝ : VExpr
a✝¹ : ParRed E Γ✝ f✝ f'✝
a✝ : ParRed E Γ✝ a✝² a'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n f✝ k) (liftN n f'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a✝² k) (liftN n a'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.app f✝ a✝²) k) (liftN n (VExpr.app f'✝ a'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | exact .lam (ih1 W) (ih2 W.succ) | case lam
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ body✝ body'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) body✝ body'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n A✝ k) (liftN n A'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n body✝ k) (liftN n body'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.lam A✝ body✝) k) (liftN n (VExpr.lam A'✝ body'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lam
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ body✝ body'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) body✝ body'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n A✝ k) (liftN n A'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n body✝ k) (liftN n body'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.lam A✝ body✝) k) (liftN n (VExpr.lam A'✝ body'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | exact .forallE (ih1 W) (ih2 W.succ) | case forallE
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ B✝ B'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) B✝ B'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n A✝ k) (liftN n A'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n B✝ k) (liftN n B'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.forallE A✝ B✝) k) (liftN n (VExpr.forallE A'✝ B'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ B✝ B'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) B✝ B'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n A✝ k) (liftN n A'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n B✝ k) (liftN n B'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.forallE A✝ B✝) k) (liftN n (VExpr.forallE A'✝ B'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | simp [liftN, liftN_inst_hi] | case beta
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n e₁✝ k) (liftN n e₁'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n e₂✝ k) (liftN n e₂'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.app (VExpr.lam A✝ e₁✝) e₂✝) k) (liftN n (inst e₁'✝ e₂'✝) k) | case beta
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n e₁✝ k) (liftN n e₁'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n e₂✝ k) (liftN n e₂'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (VExpr.app (VExpr.lam (liftN n A✝ k) (liftN n e₁✝ (k + 1))) (liftN n e₂✝ k))
(inst (liftN n e₁'✝ (k + 1)) (liftN n e₂'✝ k)) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n e₁✝ k) (liftN n e₁'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n e₂✝ k) (liftN n e₂'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n (VExpr.app (VExpr.lam A✝ e₁✝) e₂✝) k) (liftN n (inst e₁'✝ e₂'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | exact .beta (ih1 W.succ) (ih2 W) | case beta
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n e₁✝ k) (liftN n e₁'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n e₂✝ k) (liftN n e₂'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (VExpr.app (VExpr.lam (liftN n A✝ k) (liftN n e₁✝ (k + 1))) (liftN n e₂✝ k))
(inst (liftN n e₁'✝ (k + 1)) (liftN n e₂'✝ k)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k (A✝ :: Γ✝) Γ' → ParRed E Γ' (liftN n e₁✝ k) (liftN n e₁'✝ k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n e₂✝ k) (liftN n e₂'✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (VExpr.app (VExpr.lam (liftN n A✝ k) (liftN n e₁✝ (k + 1))) (liftN n e₂✝ k))
(inst (liftN n e₁'✝ (k + 1)) (liftN n e₂'✝ k))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | refine .extra fun a a' h => ?_ | case extra
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n e✝ k) (liftN n e'✝ k) | case extra
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
a a' : VExpr
h : E Γ' (liftN n e✝ k) (liftN n e'✝ k) a a'
⊢ ParRed E Γ' a a' | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ ParRed E Γ' (liftN n e✝ k) (liftN n e'✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | obtain ⟨_, _, h', rfl, rfl⟩ := HE W h | case extra
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
a a' : VExpr
h : E Γ' (liftN n e✝ k) (liftN n e'✝ k) a a'
⊢ ParRed E Γ' a a' | case extra.intro.intro.intro.intro
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
w✝¹ w✝ : VExpr
h' : E Γ✝ e✝ e'✝ w✝¹ w✝
h : E Γ' (liftN n e✝ k) (liftN n e'✝ k) (liftN n w✝¹ k) (liftN n w✝ k)
⊢ ParRed E Γ' (liftN n w✝¹ k) (liftN n w✝ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
a a' : VExpr
h : E Γ' (liftN n e✝ k) (liftN n e'✝ k) a a'
⊢ ParRed E Γ' a a'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.weakN | [44, 1] | [57, 22] | exact ih _ _ h' W | case extra.intro.intro.intro.intro
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
w✝¹ w✝ : VExpr
h' : E Γ✝ e✝ e'✝ w✝¹ w✝
h : E Γ' (liftN n e✝ k) (liftN n e'✝ k) (liftN n w✝¹ k) (liftN n w✝ k)
⊢ ParRed E Γ' (liftN n w✝¹ k) (liftN n w✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.intro.intro.intro.intro
E : Extra
HE : Extra.IsWeakN E
n : Nat
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → ParRed E Γ' (liftN n a k) (liftN n a' k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
w✝¹ w✝ : VExpr
h' : E Γ✝ e✝ e'✝ w✝¹ w✝
h : E Γ' (liftN n e✝ k) (liftN n e'✝ k) (liftN n w✝¹ k) (liftN n w✝ k)
⊢ ParRed E Γ' (liftN n w✝¹ k) (liftN n w✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | induction H generalizing Γ k with
| @bvar _ i =>
dsimp [inst]
induction W generalizing i with
| zero =>
cases i with simp [inst_lift]
| zero => exact H0
| succ h => exact rfl
| succ _ ih =>
cases i with simp
| zero => exact rfl
| succ h => exact ih.weakN HE.1 .one
| sort | const => exact rfl
| app _ _ ih1 ih2 => exact .app (ih1 W) (ih2 W)
| lam _ _ ih1 ih2 => exact .lam (ih1 W) (ih2 W.succ)
| forallE _ _ ih1 ih2 => exact .forallE (ih1 W) (ih2 W.succ)
| beta _ _ ih1 ih2 =>
simp [inst, inst0_inst_hi]
exact .beta (ih1 W.succ) (ih2 W)
| extra _ ih =>
refine .extra fun a a' h => ?_
obtain ⟨_, _, h', rfl, rfl⟩ := HE.2 W h
exact ih _ _ h' W | E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
k : Nat
Γ₁ Γ : List VExpr
e1 e2 : VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ₁ Γ
H : ParRed E Γ₁ e1 e2
⊢ ParRed E Γ (inst e1 a1 k) (inst e2 a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
k : Nat
Γ₁ Γ : List VExpr
e1 e2 : VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ₁ Γ
H : ParRed E Γ₁ e1 e2
⊢ ParRed E Γ (inst e1 a1 k) (inst e2 a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | dsimp [inst] | case bvar
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
i k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.bvar i) a1 k) (inst (VExpr.bvar i) a2 k) | case bvar
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
i k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (instVar i a1 k) (instVar i a2 k) | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
i k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.bvar i) a1 k) (inst (VExpr.bvar i) a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | induction W generalizing i with
| zero =>
cases i with simp [inst_lift]
| zero => exact H0
| succ h => exact rfl
| succ _ ih =>
cases i with simp
| zero => exact rfl
| succ h => exact ih.weakN HE.1 .one | case bvar
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
i k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (instVar i a1 k) (instVar i a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
i k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (instVar i a1 k) (instVar i a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | cases i with simp [inst_lift]
| zero => exact H0
| succ h => exact rfl | case bvar.zero
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
i : Nat
⊢ ParRed E Γ₀ (instVar i a1) (instVar i a2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
i : Nat
⊢ ParRed E Γ₀ (instVar i a1) (instVar i a2)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact H0 | case bvar.zero.zero
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
⊢ ParRed E Γ₀ a1 a2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero.zero
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
⊢ ParRed E Γ₀ a1 a2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact rfl | case bvar.zero.succ
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
h : Nat
⊢ ParRed E Γ₀ (VExpr.bvar h) (VExpr.bvar h) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero.succ
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
h : Nat
⊢ ParRed E Γ₀ (VExpr.bvar h) (VExpr.bvar h)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | cases i with simp
| zero => exact rfl
| succ h => exact ih.weakN HE.1 .one | case bvar.succ
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ a1 A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat}, ParRed E Γ'✝ (instVar i a1 k✝) (instVar i a2 k✝)
i : Nat
⊢ ParRed E (inst A✝ a1 k✝ :: Γ'✝) (instVar i a1 (k✝ + 1)) (instVar i a2 (k✝ + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ a1 A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat}, ParRed E Γ'✝ (instVar i a1 k✝) (instVar i a2 k✝)
i : Nat
⊢ ParRed E (inst A✝ a1 k✝ :: Γ'✝) (instVar i a1 (k✝ + 1)) (instVar i a2 (k✝ + 1))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact rfl | case bvar.succ.zero
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ a1 A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat}, ParRed E Γ'✝ (instVar i a1 k✝) (instVar i a2 k✝)
⊢ ParRed E (inst A✝ a1 k✝ :: Γ'✝) (VExpr.bvar 0) (VExpr.bvar 0) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ.zero
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ a1 A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat}, ParRed E Γ'✝ (instVar i a1 k✝) (instVar i a2 k✝)
⊢ ParRed E (inst A✝ a1 k✝ :: Γ'✝) (VExpr.bvar 0) (VExpr.bvar 0)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact ih.weakN HE.1 .one | case bvar.succ.succ
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ a1 A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat}, ParRed E Γ'✝ (instVar i a1 k✝) (instVar i a2 k✝)
h : Nat
⊢ ParRed E (inst A✝ a1 k✝ :: Γ'✝) (lift (instVar h a1 k✝)) (lift (instVar h a2 k✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ.succ
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝¹ : List VExpr
k : Nat
Γ : List VExpr
k✝ : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.InstN Γ₀ a1 A₀ k✝ Γ✝ Γ'✝
ih : ∀ {i : Nat}, ParRed E Γ'✝ (instVar i a1 k✝) (instVar i a2 k✝)
h : Nat
⊢ ParRed E (inst A✝ a1 k✝ :: Γ'✝) (lift (instVar h a1 k✝)) (lift (instVar h a2 k✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact rfl | case const
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
c✝ : Name
ls✝ : List VLevel
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.const c✝ ls✝) a1 k) (inst (VExpr.const c✝ ls✝) a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
c✝ : Name
ls✝ : List VLevel
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.const c✝ ls✝) a1 k) (inst (VExpr.const c✝ ls✝) a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact .app (ih1 W) (ih2 W) | case app
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
f✝ f'✝ a✝² a'✝ : VExpr
a✝¹ : ParRed E Γ✝ f✝ f'✝
a✝ : ParRed E Γ✝ a✝² a'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst f✝ a1 k) (inst f'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a✝² a1 k) (inst a'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.app f✝ a✝²) a1 k) (inst (VExpr.app f'✝ a'✝) a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case app
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
f✝ f'✝ a✝² a'✝ : VExpr
a✝¹ : ParRed E Γ✝ f✝ f'✝
a✝ : ParRed E Γ✝ a✝² a'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst f✝ a1 k) (inst f'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a✝² a1 k) (inst a'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.app f✝ a✝²) a1 k) (inst (VExpr.app f'✝ a'✝) a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact .lam (ih1 W) (ih2 W.succ) | case lam
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ body✝ body'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) body✝ body'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst A✝ a1 k) (inst A'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst body✝ a1 k) (inst body'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.lam A✝ body✝) a1 k) (inst (VExpr.lam A'✝ body'✝) a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lam
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ body✝ body'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) body✝ body'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst A✝ a1 k) (inst A'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst body✝ a1 k) (inst body'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.lam A✝ body✝) a1 k) (inst (VExpr.lam A'✝ body'✝) a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact .forallE (ih1 W) (ih2 W.succ) | case forallE
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ B✝ B'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) B✝ B'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst A✝ a1 k) (inst A'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst B✝ a1 k) (inst B'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.forallE A✝ B✝) a1 k) (inst (VExpr.forallE A'✝ B'✝) a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallE
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ A'✝ B✝ B'✝ : VExpr
a✝¹ : ParRed E Γ✝ A✝ A'✝
a✝ : ParRed E (A✝ :: Γ✝) B✝ B'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst A✝ a1 k) (inst A'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst B✝ a1 k) (inst B'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.forallE A✝ B✝) a1 k) (inst (VExpr.forallE A'✝ B'✝) a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | simp [inst, inst0_inst_hi] | case beta
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst e₁✝ a1 k) (inst e₁'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst e₂✝ a1 k) (inst e₂'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.app (VExpr.lam A✝ e₁✝) e₂✝) a1 k) (inst (inst e₁'✝ e₂'✝) a2 k) | case beta
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst e₁✝ a1 k) (inst e₁'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst e₂✝ a1 k) (inst e₂'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (VExpr.app (VExpr.lam (inst A✝ a1 k) (inst e₁✝ a1 (k + 1))) (inst e₂✝ a1 k))
(inst (inst e₁'✝ a2 (k + 1)) (inst e₂'✝ a2 k)) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst e₁✝ a1 k) (inst e₁'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst e₂✝ a1 k) (inst e₂'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst (VExpr.app (VExpr.lam A✝ e₁✝) e₂✝) a1 k) (inst (inst e₁'✝ e₂'✝) a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact .beta (ih1 W.succ) (ih2 W) | case beta
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst e₁✝ a1 k) (inst e₁'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst e₂✝ a1 k) (inst e₂'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (VExpr.app (VExpr.lam (inst A✝ a1 k) (inst e₁✝ a1 (k + 1))) (inst e₂✝ a1 k))
(inst (inst e₁'✝ a2 (k + 1)) (inst e₂'✝ a2 k)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 A✝ : VExpr
Γ✝ : List VExpr
e₁✝ e₁'✝ e₂✝ e₂'✝ : VExpr
a✝¹ : ParRed E (A✝ :: Γ✝) e₁✝ e₁'✝
a✝ : ParRed E Γ✝ e₂✝ e₂'✝
ih1 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k (A✝ :: Γ✝) Γ → ParRed E Γ (inst e₁✝ a1 k) (inst e₁'✝ a2 k)
ih2 : ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst e₂✝ a1 k) (inst e₂'✝ a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (VExpr.app (VExpr.lam (inst A✝ a1 k) (inst e₁✝ a1 (k + 1))) (inst e₂✝ a1 k))
(inst (inst e₁'✝ a2 (k + 1)) (inst e₂'✝ a2 k))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | refine .extra fun a a' h => ?_ | case extra
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst e✝ a1 k) (inst e'✝ a2 k) | case extra
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
a a' : VExpr
h : E Γ (inst e✝ a1 k) (inst e'✝ a2 k) a a'
⊢ ParRed E Γ a a' | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
⊢ ParRed E Γ (inst e✝ a1 k) (inst e'✝ a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | obtain ⟨_, _, h', rfl, rfl⟩ := HE.2 W h | case extra
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
a a' : VExpr
h : E Γ (inst e✝ a1 k) (inst e'✝ a2 k) a a'
⊢ ParRed E Γ a a' | case extra.intro.intro.intro.intro
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
w✝¹ w✝ : VExpr
h' : E Γ✝ e✝ e'✝ w✝¹ w✝
h : E Γ (inst e✝ a1 k) (inst e'✝ a2 k) (inst w✝¹ a1 k) (inst w✝ a2 k)
⊢ ParRed E Γ (inst w✝¹ a1 k) (inst w✝ a2 k) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
a a' : VExpr
h : E Γ (inst e✝ a1 k) (inst e'✝ a2 k) a a'
⊢ ParRed E Γ a a'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.ParRed.instN | [66, 1] | [90, 22] | exact ih _ _ h' W | case extra.intro.intro.intro.intro
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
w✝¹ w✝ : VExpr
h' : E Γ✝ e✝ e'✝ w✝¹ w✝
h : E Γ (inst e✝ a1 k) (inst e'✝ a2 k) (inst w✝¹ a1 k) (inst w✝ a2 k)
⊢ ParRed E Γ (inst w✝¹ a1 k) (inst w✝ a2 k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra.intro.intro.intro.intro
E : Extra
Γ₀ : List VExpr
a1 a2 : VExpr
HE : Extra.IsInstN E
H0 : ParRed E Γ₀ a1 a2
A₀ : VExpr
Γ₁ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ e'✝ : VExpr
a✝ : ∀ (a a' : VExpr), E Γ✝ e✝ e'✝ a a' → ParRed E Γ✝ a a'
ih :
∀ (a a' : VExpr),
E Γ✝ e✝ e'✝ a a' → ∀ {k : Nat} {Γ : List VExpr}, Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ → ParRed E Γ (inst a a1 k) (inst a' a2 k)
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ a1 A₀ k Γ✝ Γ
w✝¹ w✝ : VExpr
h' : E Γ✝ e✝ e'✝ w✝¹ w✝
h : E Γ (inst e✝ a1 k) (inst e'✝ a2 k) (inst w✝¹ a1 k) (inst w✝ a2 k)
⊢ ParRed E Γ (inst w✝¹ a1 k) (inst w✝ a2 k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | induction H with
| refl h => exact TY.refl h
| sortDF h1 h2 h3 => exact TY.sortDF h1 h2 h3
| appDF hf₁ _ ha₁ _ _ _ ih1 ih2 => exact TY.appDF hf₁ ih1 ha₁ ih2
| lamDF hA hA₁ _ _ ihA ihB =>
have ⟨_, hB⟩ := TY.has_type ihB
exact TY.trans (TY.symm <| TY.lamDF hA (TY.symm hA₁) (TY.refl hB))
(TY.lamDF hA (TY.trans (TY.symm hA₁) ihA) ihB)
| forallEDF hA hA₁ _ hB₁ _ ihA ihB =>
exact TY.trans (TY.symm <| TY.forallEDF hA (TY.symm hA₁) hB₁ (TY.refl hB₁))
(TY.forallEDF hA (TY.trans (TY.symm hA₁) ihA) hB₁ ihB)
| etaL h1 _ ih =>
have ⟨_, AB⟩ := TY.is_type h1
have ⟨_, _, hA, _⟩ := TY.forallE_inv AB
exact TY.trans (TY.lamDF hA (TY.refl hA) ih) (TY.eta h1)
| etaR h1 _ ih =>
have ⟨_, AB⟩ := TY.is_type h1
have ⟨_, _, hA, _⟩ := TY.forallE_inv AB
exact TY.trans (TY.symm (TY.eta h1)) (TY.lamDF hA (TY.refl hA) ih)
| proofIrrel h1 h2 h3 => exact TY.proofIrrel h1 h2 h3 | TY : Typing
Γ : List VExpr
e1 e2 : VExpr
H : NormalEq TY Γ e1 e2
⊢ TY.IsDefEq Γ e1 e2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
H : NormalEq TY Γ e1 e2
⊢ TY.IsDefEq Γ e1 e2
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.refl h | case refl
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ A✝ : VExpr
h : TY.HasType Γ✝ e✝ A✝
⊢ TY.IsDefEq Γ✝ e✝ e✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e✝ A✝ : VExpr
h : TY.HasType Γ✝ e✝ A✝
⊢ TY.IsDefEq Γ✝ e✝ e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.sortDF h1 h2 h3 | case sortDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
l₁✝ l₂✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF TY.univs l₁✝
h2 : VLevel.WF TY.univs l₂✝
h3 : l₁✝ ≈ l₂✝
⊢ TY.IsDefEq Γ✝ (sort l₁✝) (sort l₂✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
l₁✝ l₂✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF TY.univs l₁✝
h2 : VLevel.WF TY.univs l₂✝
h3 : l₁✝ ≈ l₂✝
⊢ TY.IsDefEq Γ✝ (sort l₁✝) (sort l₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.appDF hf₁ ih1 ha₁ ih2 | case appDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
f₁✝ A✝ B✝ f₂✝ a₁✝ a₂✝ : VExpr
hf₁ : TY.HasType Γ✝ f₁✝ (forallE A✝ B✝)
a✝³ : TY.HasType Γ✝ f₂✝ (forallE A✝ B✝)
ha₁ : TY.HasType Γ✝ a₁✝ A✝
a✝² : TY.HasType Γ✝ a₂✝ A✝
a✝¹ : NormalEq TY Γ✝ f₁✝ f₂✝
a✝ : NormalEq TY Γ✝ a₁✝ a₂✝
ih1 : TY.IsDefEq Γ✝ f₁✝ f₂✝
ih2 : TY.IsDefEq Γ✝ a₁✝ a₂✝
⊢ TY.IsDefEq Γ✝ (app f₁✝ a₁✝) (app f₂✝ a₂✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
f₁✝ A✝ B✝ f₂✝ a₁✝ a₂✝ : VExpr
hf₁ : TY.HasType Γ✝ f₁✝ (forallE A✝ B✝)
a✝³ : TY.HasType Γ✝ f₂✝ (forallE A✝ B✝)
ha₁ : TY.HasType Γ✝ a₁✝ A✝
a✝² : TY.HasType Γ✝ a₂✝ A✝
a✝¹ : NormalEq TY Γ✝ f₁✝ f₂✝
a✝ : NormalEq TY Γ✝ a₁✝ a₂✝
ih1 : TY.IsDefEq Γ✝ f₁✝ f₂✝
ih2 : TY.IsDefEq Γ✝ a₁✝ a₂✝
⊢ TY.IsDefEq Γ✝ (app f₁✝ a₁✝) (app f₂✝ a₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | have ⟨_, hB⟩ := TY.has_type ihB | case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) body₁✝ body₂✝
⊢ TY.IsDefEq Γ✝ (lam A₁✝ body₁✝) (lam A₂✝ body₂✝) | case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) body₁✝ body₂✝
w✝ : VExpr
hB : TY.HasType (A✝ :: Γ✝) body₁✝ w✝
⊢ TY.IsDefEq Γ✝ (lam A₁✝ body₁✝) (lam A₂✝ body₂✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) body₁✝ body₂✝
⊢ TY.IsDefEq Γ✝ (lam A₁✝ body₁✝) (lam A₂✝ body₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.trans (TY.symm <| TY.lamDF hA (TY.symm hA₁) (TY.refl hB))
(TY.lamDF hA (TY.trans (TY.symm hA₁) ihA) ihB) | case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) body₁✝ body₂✝
w✝ : VExpr
hB : TY.HasType (A✝ :: Γ✝) body₁✝ w✝
⊢ TY.IsDefEq Γ✝ (lam A₁✝ body₁✝) (lam A₂✝ body₂✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) body₁✝ body₂✝
w✝ : VExpr
hB : TY.HasType (A✝ :: Γ✝) body₁✝ w✝
⊢ TY.IsDefEq Γ✝ (lam A₁✝ body₁✝) (lam A₂✝ body₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.trans (TY.symm <| TY.forallEDF hA (TY.symm hA₁) hB₁ (TY.refl hB₁))
(TY.forallEDF hA (TY.trans (TY.symm hA₁) ihA) hB₁ ihB) | case forallEDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ B₁✝ : VExpr
v✝ : VLevel
B₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
hB₁ : TY.HasType (A✝ :: Γ✝) B₁✝ (sort v✝)
a✝ : NormalEq TY (A✝ :: Γ✝) B₁✝ B₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) B₁✝ B₂✝
⊢ TY.IsDefEq Γ✝ (forallE A₁✝ B₁✝) (forallE A₂✝ B₂✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ B₁✝ : VExpr
v✝ : VLevel
B₂✝ : VExpr
hA : TY.HasType Γ✝ A✝ (sort u✝)
hA₁ : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
hB₁ : TY.HasType (A✝ :: Γ✝) B₁✝ (sort v✝)
a✝ : NormalEq TY (A✝ :: Γ✝) B₁✝ B₂✝
ihA : TY.IsDefEq Γ✝ A₁✝ A₂✝
ihB : TY.IsDefEq (A✝ :: Γ✝) B₁✝ B₂✝
⊢ TY.IsDefEq Γ✝ (forallE A₁✝ B₁✝) (forallE A₂✝ B₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | have ⟨_, AB⟩ := TY.is_type h1 | case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝ | case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
w✝ : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝)
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | have ⟨_, _, hA, _⟩ := TY.forallE_inv AB | case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
w✝ : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝)
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝ | case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
w✝² : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝²)
w✝¹ w✝ : VLevel
hA : TY.HasType Γ✝ A✝ (sort w✝¹)
right✝ : TY.HasType (A✝ :: Γ✝) A✝ (sort w✝)
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
w✝ : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝)
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.trans (TY.lamDF hA (TY.refl hA) ih) (TY.eta h1) | case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
w✝² : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝²)
w✝¹ w✝ : VLevel
hA : TY.HasType Γ✝ A✝ (sort w✝¹)
right✝ : TY.HasType (A✝ :: Γ✝) A✝ (sort w✝)
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : TY.IsDefEq (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
w✝² : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝²)
w✝¹ w✝ : VLevel
hA : TY.HasType Γ✝ A✝ (sort w✝¹)
right✝ : TY.HasType (A✝ :: Γ✝) A✝ (sort w✝)
⊢ TY.IsDefEq Γ✝ (lam A✝ e✝) e'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | have ⟨_, AB⟩ := TY.is_type h1 | case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝) | case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
w✝ : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝)
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | have ⟨_, _, hA, _⟩ := TY.forallE_inv AB | case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
w✝ : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝)
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝) | case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
w✝² : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝²)
w✝¹ w✝ : VLevel
hA : TY.HasType Γ✝ A✝ (sort w✝¹)
right✝ : TY.HasType (A✝ :: Γ✝) A✝ (sort w✝)
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
w✝ : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝)
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.trans (TY.symm (TY.eta h1)) (TY.lamDF hA (TY.refl hA) ih) | case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
w✝² : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝²)
w✝¹ w✝ : VLevel
hA : TY.HasType Γ✝ A✝ (sort w✝¹)
right✝ : TY.HasType (A✝ :: Γ✝) A✝ (sort w✝)
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : TY.IsDefEq (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
w✝² : VLevel
AB : TY.HasType Γ✝ (forallE A✝ B✝) (sort w✝²)
w✝¹ w✝ : VLevel
hA : TY.HasType Γ✝ A✝ (sort w✝¹)
right✝ : TY.HasType (A✝ :: Γ✝) A✝ (sort w✝)
⊢ TY.IsDefEq Γ✝ e'✝ (lam A✝ e✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.defeq | [162, 1] | [182, 56] | exact TY.proofIrrel h1 h2 h3 | case proofIrrel
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
h1 : TY.HasType Γ✝ p✝ (sort VLevel.zero)
h2 : TY.HasType Γ✝ h✝ p✝
h3 : TY.HasType Γ✝ h'✝ p✝
⊢ TY.IsDefEq Γ✝ h✝ h'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
h1 : TY.HasType Γ✝ p✝ (sort VLevel.zero)
h2 : TY.HasType Γ✝ h✝ p✝
h3 : TY.HasType Γ✝ h'✝ p✝
⊢ TY.IsDefEq Γ✝ h✝ h'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | induction H with
| refl h => exact .refl h
| sortDF h1 h2 h3 => exact .sortDF h2 h1 h3.symm
| appDF h1 h2 h3 h4 _ _ ih1 ih2 => exact .appDF h2 h1 h4 h3 ih1 ih2
| lamDF h1 h2 _ _ ih1 ih2 => exact .lamDF h1 (TY.trans ih1.defeq h2) ih1 ih2
| forallEDF h1 h2 _ h4 h5 ih1 ih2 =>
exact .forallEDF h1 (TY.trans ih1.defeq h2) ih1 (TY.defeq_l h5.defeq h4) ih2
| etaL h1 _ ih => exact .etaR h1 ih
| etaR h1 _ ih => exact .etaL h1 ih
| proofIrrel h1 h2 h3 => exact .proofIrrel h1 h3 h2 | TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
H : NormalEq TY Γ e1 e2
⊢ NormalEq TY Γ e2 e1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
H : NormalEq TY Γ e1 e2
⊢ NormalEq TY Γ e2 e1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .refl h | case refl
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
e✝ A✝ : VExpr
h : TY.HasType Γ✝ e✝ A✝
⊢ NormalEq TY Γ✝ e✝ e✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
e✝ A✝ : VExpr
h : TY.HasType Γ✝ e✝ A✝
⊢ NormalEq TY Γ✝ e✝ e✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .sortDF h2 h1 h3.symm | case sortDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
l₁✝ l₂✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF TY.univs l₁✝
h2 : VLevel.WF TY.univs l₂✝
h3 : l₁✝ ≈ l₂✝
⊢ NormalEq TY Γ✝ (sort l₂✝) (sort l₁✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
l₁✝ l₂✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF TY.univs l₁✝
h2 : VLevel.WF TY.univs l₂✝
h3 : l₁✝ ≈ l₂✝
⊢ NormalEq TY Γ✝ (sort l₂✝) (sort l₁✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .appDF h2 h1 h4 h3 ih1 ih2 | case appDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
f₁✝ A✝ B✝ f₂✝ a₁✝ a₂✝ : VExpr
h1 : TY.HasType Γ✝ f₁✝ (forallE A✝ B✝)
h2 : TY.HasType Γ✝ f₂✝ (forallE A✝ B✝)
h3 : TY.HasType Γ✝ a₁✝ A✝
h4 : TY.HasType Γ✝ a₂✝ A✝
a✝¹ : NormalEq TY Γ✝ f₁✝ f₂✝
a✝ : NormalEq TY Γ✝ a₁✝ a₂✝
ih1 : NormalEq TY Γ✝ f₂✝ f₁✝
ih2 : NormalEq TY Γ✝ a₂✝ a₁✝
⊢ NormalEq TY Γ✝ (app f₂✝ a₂✝) (app f₁✝ a₁✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
f₁✝ A✝ B✝ f₂✝ a₁✝ a₂✝ : VExpr
h1 : TY.HasType Γ✝ f₁✝ (forallE A✝ B✝)
h2 : TY.HasType Γ✝ f₂✝ (forallE A✝ B✝)
h3 : TY.HasType Γ✝ a₁✝ A✝
h4 : TY.HasType Γ✝ a₂✝ A✝
a✝¹ : NormalEq TY Γ✝ f₁✝ f₂✝
a✝ : NormalEq TY Γ✝ a₁✝ a₂✝
ih1 : NormalEq TY Γ✝ f₂✝ f₁✝
ih2 : NormalEq TY Γ✝ a₂✝ a₁✝
⊢ NormalEq TY Γ✝ (app f₂✝ a₂✝) (app f₁✝ a₁✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .lamDF h1 (TY.trans ih1.defeq h2) ih1 ih2 | case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
h1 : TY.HasType Γ✝ A✝ (sort u✝)
h2 : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ih1 : NormalEq TY Γ✝ A₂✝ A₁✝
ih2 : NormalEq TY (A✝ :: Γ✝) body₂✝ body₁✝
⊢ NormalEq TY Γ✝ (lam A₂✝ body₂✝) (lam A₁✝ body₁✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ body₁✝ body₂✝ : VExpr
h1 : TY.HasType Γ✝ A✝ (sort u✝)
h2 : TY.IsDefEq Γ✝ A₁✝ A✝
a✝¹ : NormalEq TY Γ✝ A₁✝ A₂✝
a✝ : NormalEq TY (A✝ :: Γ✝) body₁✝ body₂✝
ih1 : NormalEq TY Γ✝ A₂✝ A₁✝
ih2 : NormalEq TY (A✝ :: Γ✝) body₂✝ body₁✝
⊢ NormalEq TY Γ✝ (lam A₂✝ body₂✝) (lam A₁✝ body₁✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .forallEDF h1 (TY.trans ih1.defeq h2) ih1 (TY.defeq_l h5.defeq h4) ih2 | case forallEDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ B₁✝ : VExpr
v✝ : VLevel
B₂✝ : VExpr
h1 : TY.HasType Γ✝ A✝ (sort u✝)
h2 : TY.IsDefEq Γ✝ A₁✝ A✝
a✝ : NormalEq TY Γ✝ A₁✝ A₂✝
h4 : TY.HasType (A✝ :: Γ✝) B₁✝ (sort v✝)
h5 : NormalEq TY (A✝ :: Γ✝) B₁✝ B₂✝
ih1 : NormalEq TY Γ✝ A₂✝ A₁✝
ih2 : NormalEq TY (A✝ :: Γ✝) B₂✝ B₁✝
⊢ NormalEq TY Γ✝ (forallE A₂✝ B₂✝) (forallE A₁✝ B₁✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
A₁✝ A₂✝ B₁✝ : VExpr
v✝ : VLevel
B₂✝ : VExpr
h1 : TY.HasType Γ✝ A✝ (sort u✝)
h2 : TY.IsDefEq Γ✝ A₁✝ A✝
a✝ : NormalEq TY Γ✝ A₁✝ A₂✝
h4 : TY.HasType (A✝ :: Γ✝) B₁✝ (sort v✝)
h5 : NormalEq TY (A✝ :: Γ✝) B₁✝ B₂✝
ih1 : NormalEq TY Γ✝ A₂✝ A₁✝
ih2 : NormalEq TY (A✝ :: Γ✝) B₂✝ B₁✝
⊢ NormalEq TY Γ✝ (forallE A₂✝ B₂✝) (forallE A₁✝ B₁✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .etaR h1 ih | case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
⊢ NormalEq TY Γ✝ e'✝ (lam A✝ e✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case etaL
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
ih : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
⊢ NormalEq TY Γ✝ e'✝ (lam A✝ e✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .etaL h1 ih | case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
⊢ NormalEq TY Γ✝ (lam A✝ e✝) e'✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case etaR
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
e'✝ A✝ B✝ e✝ : VExpr
h1 : TY.HasType Γ✝ e'✝ (forallE A✝ B✝)
a✝ : NormalEq TY (A✝ :: Γ✝) (app (lift e'✝) (bvar 0)) e✝
ih : NormalEq TY (A✝ :: Γ✝) e✝ (app (lift e'✝) (bvar 0))
⊢ NormalEq TY Γ✝ (lam A✝ e✝) e'✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.symm | [184, 1] | [194, 54] | exact .proofIrrel h1 h3 h2 | case proofIrrel
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
h1 : TY.HasType Γ✝ p✝ (sort VLevel.zero)
h2 : TY.HasType Γ✝ h✝ p✝
h3 : TY.HasType Γ✝ h'✝ p✝
⊢ NormalEq TY Γ✝ h'✝ h✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
TY : Typing
Γ : List VExpr
e1 e2 : VExpr
env : VEnv
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
h1 : TY.HasType Γ✝ p✝ (sort VLevel.zero)
h2 : TY.HasType Γ✝ h✝ p✝
h3 : TY.HasType Γ✝ h'✝ p✝
⊢ NormalEq TY Γ✝ h'✝ h✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/ParallelReduction.lean | Lean4Lean.NormalEq.trans | [197, 1] | [200, 8] | sorry | TY : Typing
Γ : List VExpr
e1 e2 e3 : VExpr
H1 : NormalEq TY Γ e1 e2
H2 : NormalEq TY Γ e2 e3
⊢ NormalEq TY Γ e1 e3 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
TY : Typing
Γ : List VExpr
e1 e2 e3 : VExpr
H1 : NormalEq TY Γ e1 e2
H2 : NormalEq TY Γ e2 e3
⊢ NormalEq TY Γ e1 e3
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.nodupKeys_cons | [10, 9] | [11, 32] | simp [nodupKeys_iff_pairwise] | α✝ : Type u_1
β✝ : Type u_2
a : α✝ × β✝
l : List (α✝ × β✝)
⊢ NodupKeys (a :: l) ↔ (∀ (a' : α✝ × β✝), a' ∈ l → a.fst ≠ a'.fst) ∧ NodupKeys l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type u_1
β✝ : Type u_2
a : α✝ × β✝
l : List (α✝ × β✝)
⊢ NodupKeys (a :: l) ↔ (∀ (a' : α✝ × β✝), a' ∈ l → a.fst ≠ a'.fst) ∧ NodupKeys l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | induction h with
| nil => rfl
| cons _ _ ih => simp [lookup]; split <;> [rfl; exact ih (pairwise_cons.1 nd).2]
| swap _ h ih =>
simp at nd
simp [lookup]; split <;> split <;> rename_i h1 _ h2 <;> try rfl
simp at h1 h2; cases nd.1.1 (by rw [← h1, h2])
| trans h1 _ ih1 ih2 => exact (ih1 nd).trans (ih2 (h1.nodupKeys_iff.1 nd)) | α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
h : l₁ ~ l₂
nd : NodupKeys l₁
⊢ lookup a l₁ = lookup a l₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
h : l₁ ~ l₂
nd : NodupKeys l₁
⊢ lookup a l₁ = lookup a l₂
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | rfl | case nil
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
nd : NodupKeys []
⊢ lookup a [] = lookup a [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
nd : NodupKeys []
⊢ lookup a [] = lookup a []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | simp [lookup] | case cons
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ : α × β
l₁✝ l₂✝ : List (α × β)
a✝ : l₁✝ ~ l₂✝
ih : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
nd : NodupKeys (x✝ :: l₁✝)
⊢ lookup a (x✝ :: l₁✝) = lookup a (x✝ :: l₂✝) | case cons
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ : α × β
l₁✝ l₂✝ : List (α × β)
a✝ : l₁✝ ~ l₂✝
ih : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
nd : NodupKeys (x✝ :: l₁✝)
⊢ (match a == x✝.fst with
| true => some x✝.snd
| false => lookup a l₁✝) =
match a == x✝.fst with
| true => some x✝.snd
| false => lookup a l₂✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ : α × β
l₁✝ l₂✝ : List (α × β)
a✝ : l₁✝ ~ l₂✝
ih : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
nd : NodupKeys (x✝ :: l₁✝)
⊢ lookup a (x✝ :: l₁✝) = lookup a (x✝ :: l₂✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | split <;> [rfl; exact ih (pairwise_cons.1 nd).2] | case cons
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ : α × β
l₁✝ l₂✝ : List (α × β)
a✝ : l₁✝ ~ l₂✝
ih : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
nd : NodupKeys (x✝ :: l₁✝)
⊢ (match a == x✝.fst with
| true => some x✝.snd
| false => lookup a l₁✝) =
match a == x✝.fst with
| true => some x✝.snd
| false => lookup a l₂✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ : α × β
l₁✝ l₂✝ : List (α × β)
a✝ : l₁✝ ~ l₂✝
ih : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
nd : NodupKeys (x✝ :: l₁✝)
⊢ (match a == x✝.fst with
| true => some x✝.snd
| false => lookup a l₁✝) =
match a == x✝.fst with
| true => some x✝.snd
| false => lookup a l₂✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | simp at nd | case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd : NodupKeys (h :: x✝ :: ih)
⊢ lookup a (h :: x✝ :: ih) = lookup a (x✝ :: h :: ih) | case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝.fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝.fst = a'.fst) ∧ NodupKeys ih
⊢ lookup a (h :: x✝ :: ih) = lookup a (x✝ :: h :: ih) | Please generate a tactic in lean4 to solve the state.
STATE:
case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd : NodupKeys (h :: x✝ :: ih)
⊢ lookup a (h :: x✝ :: ih) = lookup a (x✝ :: h :: ih)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | simp [lookup] | case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝.fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝.fst = a'.fst) ∧ NodupKeys ih
⊢ lookup a (h :: x✝ :: ih) = lookup a (x✝ :: h :: ih) | case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝.fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝.fst = a'.fst) ∧ NodupKeys ih
⊢ (match a == h.fst with
| true => some h.snd
| false =>
match a == x✝.fst with
| true => some x✝.snd
| false => lookup a ih) =
match a == x✝.fst with
| true => some x✝.snd
| false =>
match a == h.fst with
| true => some h.snd
| false => lookup a ih | Please generate a tactic in lean4 to solve the state.
STATE:
case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝.fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝.fst = a'.fst) ∧ NodupKeys ih
⊢ lookup a (h :: x✝ :: ih) = lookup a (x✝ :: h :: ih)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | split <;> split <;> rename_i h1 _ h2 <;> try rfl | case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝.fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝.fst = a'.fst) ∧ NodupKeys ih
⊢ (match a == h.fst with
| true => some h.snd
| false =>
match a == x✝.fst with
| true => some x✝.snd
| false => lookup a ih) =
match a == x✝.fst with
| true => some x✝.snd
| false =>
match a == h.fst with
| true => some h.snd
| false => lookup a ih | case swap.h_1.h_1
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ : Bool
h1 : (a == h.fst) = true
x✝ : Bool
h2 : (a == x✝².fst) = true
⊢ some h.snd = some x✝².snd | Please generate a tactic in lean4 to solve the state.
STATE:
case swap
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝ h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝.fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝.fst = a'.fst) ∧ NodupKeys ih
⊢ (match a == h.fst with
| true => some h.snd
| false =>
match a == x✝.fst with
| true => some x✝.snd
| false => lookup a ih) =
match a == x✝.fst with
| true => some x✝.snd
| false =>
match a == h.fst with
| true => some h.snd
| false => lookup a ih
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | simp at h1 h2 | case swap.h_1.h_1
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ : Bool
h1 : (a == h.fst) = true
x✝ : Bool
h2 : (a == x✝².fst) = true
⊢ some h.snd = some x✝².snd | case swap.h_1.h_1
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ x✝ : Bool
h1 : a = h.fst
h2 : a = x✝².fst
⊢ some h.snd = some x✝².snd | Please generate a tactic in lean4 to solve the state.
STATE:
case swap.h_1.h_1
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ : Bool
h1 : (a == h.fst) = true
x✝ : Bool
h2 : (a == x✝².fst) = true
⊢ some h.snd = some x✝².snd
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | cases nd.1.1 (by rw [← h1, h2]) | case swap.h_1.h_1
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ x✝ : Bool
h1 : a = h.fst
h2 : a = x✝².fst
⊢ some h.snd = some x✝².snd | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case swap.h_1.h_1
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ x✝ : Bool
h1 : a = h.fst
h2 : a = x✝².fst
⊢ some h.snd = some x✝².snd
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | rfl | case swap.h_2.h_2
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ : Bool
h1 : (a == h.fst) = false
x✝ : Bool
h2 : (a == x✝².fst) = false
⊢ lookup a ih = lookup a ih | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case swap.h_2.h_2
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ : Bool
h1 : (a == h.fst) = false
x✝ : Bool
h2 : (a == x✝².fst) = false
⊢ lookup a ih = lookup a ih
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | rw [← h1, h2] | α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ x✝ : Bool
h1 : a = h.fst
h2 : a = x✝².fst
⊢ h.fst = x✝².fst | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
x✝² h : α × β
ih : List (α × β)
nd :
(¬h.fst = x✝².fst ∧ ∀ (a : α × β), a ∈ ih → ¬h.fst = a.fst) ∧
(∀ (a' : α × β), a' ∈ ih → ¬x✝².fst = a'.fst) ∧ NodupKeys ih
x✝¹ x✝ : Bool
h1 : a = h.fst
h2 : a = x✝².fst
⊢ h.fst = x✝².fst
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.Perm.lookup_eq | [16, 1] | [25, 77] | exact (ih1 nd).trans (ih2 (h1.nodupKeys_iff.1 nd)) | case trans
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
l₁✝ l₂✝ l₃✝ : List (α × β)
h1 : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih1 : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
ih2 : NodupKeys l₂✝ → lookup a l₂✝ = lookup a l₃✝
nd : NodupKeys l₁✝
⊢ lookup a l₁✝ = lookup a l₃✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
α : Type u_1
β : Type u_2
a : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List (α × β)
l₁✝ l₂✝ l₃✝ : List (α × β)
h1 : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih1 : NodupKeys l₁✝ → lookup a l₁✝ = lookup a l₂✝
ih2 : NodupKeys l₂✝ → lookup a l₂✝ = lookup a l₃✝
nd : NodupKeys l₁✝
⊢ lookup a l₁✝ = lookup a l₃✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | simp | case nil
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
nd : NodupKeys []
⊢ lookup a [] = some b ↔ (a, b) ∈ [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
nd : NodupKeys []
⊢ lookup a [] = some b ↔ (a, b) ∈ []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | let (a', b') := p | case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
nd : NodupKeys (p :: l)
⊢ lookup a (p :: l) = some b ↔ (a, b) ∈ p :: l | case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : NodupKeys ((a', b') :: l)
⊢ lookup a ((a', b') :: l) = some b ↔ (a, b) ∈ (a', b') :: l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
nd : NodupKeys (p :: l)
⊢ lookup a (p :: l) = some b ↔ (a, b) ∈ p :: l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | simp [lookup] at nd ⊢ | case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : NodupKeys ((a', b') :: l)
⊢ lookup a ((a', b') :: l) = some b ↔ (a, b) ∈ (a', b') :: l | case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
⊢ (match a == a' with
| true => some b'
| false => lookup a l) =
some b ↔
a = a' ∧ b = b' ∨ (a, b) ∈ l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : NodupKeys ((a', b') :: l)
⊢ lookup a ((a', b') :: l) = some b ↔ (a, b) ∈ (a', b') :: l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | split <;> rename_i h | case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
⊢ (match a == a' with
| true => some b'
| false => lookup a l) =
some b ↔
a = a' ∧ b = b' ∨ (a, b) ∈ l | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : (a == a') = true
⊢ some b' = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l
case cons.h_2
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : (a == a') = false
⊢ lookup a l = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
⊢ (match a == a' with
| true => some b'
| false => lookup a l) =
some b ↔
a = a' ∧ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | simp at h | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : (a == a') = true
⊢ some b' = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : a = a'
⊢ some b' = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : (a == a') = true
⊢ some b' = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | subst a' | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : a = a'
⊢ some b' = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
⊢ some b' = some b ↔ a = a ∧ b = b' ∨ (a, b) ∈ l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : a = a'
⊢ some b' = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | simp [eq_comm] | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
⊢ some b' = some b ↔ a = a ∧ b = b' ∨ (a, b) ∈ l | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
⊢ b = b' ↔ b = b' ∨ (a, b) ∈ l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
⊢ some b' = some b ↔ a = a ∧ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | refine (or_iff_left_of_imp fun h => ?_).symm | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
⊢ b = b' ↔ b = b' ∨ (a, b) ∈ l | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
h : (a, b) ∈ l
⊢ b = b' | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
⊢ b = b' ↔ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | cases nd.1 _ h rfl | case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
h : (a, b) ∈ l
⊢ b = b' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_1
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
b' : β
x✝ : Bool
nd : (∀ (a' : α × β), a' ∈ l → ¬a = a'.fst) ∧ NodupKeys l
h : (a, b) ∈ l
⊢ b = b'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | simp at h | case cons.h_2
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : (a == a') = false
⊢ lookup a l = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | case cons.h_2
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : ¬a = a'
⊢ lookup a l = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_2
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : (a == a') = false
⊢ lookup a l = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Std/NodupKeys.lean | List.NodupKeys.lookup_eq_some | [27, 1] | [37, 35] | simp [h, ih nd.2] | case cons.h_2
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : ¬a = a'
⊢ lookup a l = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.h_2
α : Type u_1
β : Type u_2
a : α
b : β
inst✝¹ : BEq α
inst✝ : LawfulBEq α
p : α × β
l : List (α × β)
ih : NodupKeys l → (lookup a l = some b ↔ (a, b) ∈ l)
a' : α
b' : β
nd : (∀ (a'_1 : α × β), a'_1 ∈ l → ¬a' = a'_1.fst) ∧ NodupKeys l
x✝ : Bool
h : ¬a = a'
⊢ lookup a l = some b ↔ a = a' ∧ b = b' ∨ (a, b) ∈ l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | simp [List.lookup, find?, next] | fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome (List.lookup (some fv) ((ofv, d) :: Δ)) = Option.isSome (find? ((ofv, d) :: Δ) (Sum.inr fv)) | fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome
(match some fv == ofv with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match ofv, Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | Please generate a tactic in lean4 to solve the state.
STATE:
fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome (List.lookup (some fv) ((ofv, d) :: Δ)) = Option.isSome (find? ((ofv, d) :: Δ) (Sum.inr fv))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | cases ofv with
| none =>
simp [show (some fv == none) = false from rfl, lookup_isSome]
cases find? Δ (.inr fv) <;> simp [bind]
| some fv' =>
simp [show (some fv == some fv') = (fv == fv') from rfl, beq_comm fv]
cases fv' == fv <;> simp [lookup_isSome]
cases find? Δ (.inr fv) <;> simp [bind] | fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome
(match some fv == ofv with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match ofv, Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome
(match some fv == ofv with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match ofv, Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | simp [show (some fv == none) = false from rfl, lookup_isSome] | case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome
(match some fv == none with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match none, Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome (find? Δ (Sum.inr fv)) =
Option.isSome
(Option.bind (find? Δ (Sum.inr fv)) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | Please generate a tactic in lean4 to solve the state.
STATE:
case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome
(match some fv == none with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match none, Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | cases find? Δ (.inr fv) <;> simp [bind] | case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome (find? Δ (Sum.inr fv)) =
Option.isSome
(Option.bind (find? Δ (Sum.inr fv)) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ Option.isSome (find? Δ (Sum.inr fv)) =
Option.isSome
(Option.bind (find? Δ (Sum.inr fv)) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | simp [show (some fv == some fv') = (fv == fv') from rfl, beq_comm fv] | case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome
(match some fv == some fv' with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match some fv', Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome
(match fv' == fv with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match if (fv' == fv) = true then none else some (Sum.inr fv) with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | Please generate a tactic in lean4 to solve the state.
STATE:
case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome
(match some fv == some fv' with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match
match some fv', Sum.inr fv with
| none, Sum.inl 0 => none
| none, Sum.inl (Nat.succ n) => some (Sum.inl n)
| some val, Sum.inl n => some (Sum.inl n)
| none, Sum.inr fv' => some (Sum.inr fv')
| some fv, Sum.inr fv' => if (fv == fv') = true then none else some (Sum.inr fv') with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | cases fv' == fv <;> simp [lookup_isSome] | case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome
(match fv' == fv with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match if (fv' == fv) = true then none else some (Sum.inr fv) with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | case some.false
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome (find? Δ (Sum.inr fv)) =
Option.isSome
(Option.bind (find? Δ (Sum.inr fv)) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | Please generate a tactic in lean4 to solve the state.
STATE:
case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome
(match fv' == fv with
| true => some d
| false => List.lookup (some fv) Δ) =
Option.isSome
(match if (fv' == fv) = true then none else some (Sum.inr fv) with
| none => some (VLocalDecl.value d, VLocalDecl.type d)
| some v =>
Option.bind (find? Δ v) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_isSome | [72, 1] | [83, 46] | cases find? Δ (.inr fv) <;> simp [bind] | case some.false
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome (find? Δ (Sum.inr fv)) =
Option.isSome
(Option.bind (find? Δ (Sum.inr fv)) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case some.false
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ Option.isSome (find? Δ (Sum.inr fv)) =
Option.isSome
(Option.bind (find? Δ (Sum.inr fv)) fun __discr =>
some (VExpr.liftN (VLocalDecl.depth d) __discr.fst, VExpr.liftN (VLocalDecl.depth d) __discr.snd))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_eq_some | [85, 1] | [92, 69] | simp | fv : FVarId
⊢ (∃ x, List.lookup (some fv) [] = some x) ↔ fv ∈ fvars [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fv : FVarId
⊢ (∃ x, List.lookup (some fv) [] = some x) ↔ fv ∈ fvars []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_eq_some | [85, 1] | [92, 69] | cases ofv with
| none => simp [List.lookup, show (some fv == none) = false from rfl, lookup_eq_some]
| some fv' =>
simp [List.lookup, show (some fv == some fv') = (fv == fv') from rfl]
cases e : fv == fv' <;> simp at e <;> simp [e, lookup_eq_some] | fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ (∃ x, List.lookup (some fv) ((ofv, d) :: Δ) = some x) ↔ fv ∈ fvars ((ofv, d) :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fv : FVarId
ofv : Option FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ (∃ x, List.lookup (some fv) ((ofv, d) :: Δ) = some x) ↔ fv ∈ fvars ((ofv, d) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_eq_some | [85, 1] | [92, 69] | simp [List.lookup, show (some fv == none) = false from rfl, lookup_eq_some] | case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ (∃ x, List.lookup (some fv) ((none, d) :: Δ) = some x) ↔ fv ∈ fvars ((none, d) :: Δ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case none
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
⊢ (∃ x, List.lookup (some fv) ((none, d) :: Δ) = some x) ↔ fv ∈ fvars ((none, d) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_eq_some | [85, 1] | [92, 69] | simp [List.lookup, show (some fv == some fv') = (fv == fv') from rfl] | case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ (∃ x, List.lookup (some fv) ((some fv', d) :: Δ) = some x) ↔ fv ∈ fvars ((some fv', d) :: Δ) | case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ (∃ x,
(match fv == fv' with
| true => some d
| false => List.lookup (some fv) Δ) =
some x) ↔
fv = fv' ∨ fv ∈ fvars Δ | Please generate a tactic in lean4 to solve the state.
STATE:
case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ (∃ x, List.lookup (some fv) ((some fv', d) :: Δ) = some x) ↔ fv ∈ fvars ((some fv', d) :: Δ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.lookup_eq_some | [85, 1] | [92, 69] | cases e : fv == fv' <;> simp at e <;> simp [e, lookup_eq_some] | case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ (∃ x,
(match fv == fv' with
| true => some d
| false => List.lookup (some fv) Δ) =
some x) ↔
fv = fv' ∨ fv ∈ fvars Δ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case some
fv : FVarId
d : VLocalDecl
Δ : List (Option FVarId × VLocalDecl)
fv' : FVarId
⊢ (∃ x,
(match fv == fv' with
| true => some d
| false => List.lookup (some fv) Δ) =
some x) ↔
fv = fv' ∨ fv ∈ fvars Δ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/VLCtx.lean | Lean4Lean.VLCtx.find?_eq_some | [94, 1] | [95, 93] | rw [← Option.isSome_iff_exists, ← lookup_isSome, Option.isSome_iff_exists, lookup_eq_some] | fv : FVarId
Δ : VLCtx
⊢ (∃ x, find? Δ (Sum.inr fv) = some x) ↔ fv ∈ fvars Δ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fv : FVarId
Δ : VLCtx
⊢ (∃ x, find? Δ (Sum.inr fv) = some x) ↔ fv ∈ fvars Δ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.map_toList | [43, 1] | [49, 39] | simp [LocalContext.toList] | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
⊢ PersistentHashMap.toList' { fvarIdToDecl := PersistentHashMap.empty, decls := PersistentArray.empty }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList { fvarIdToDecl := PersistentHashMap.empty, decls := PersistentArray.empty }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
⊢ PersistentHashMap.toList' { fvarIdToDecl := PersistentHashMap.empty, decls := PersistentArray.empty }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList { fvarIdToDecl := PersistentHashMap.empty, decls := PersistentArray.empty })
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.map_toList | [43, 1] | [49, 39] | subst h1 | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
fv✝ : FVarId
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
h1 : LocalDecl.fvarId d✝ = fv✝
h2 : PersistentHashMap.find? map✝ fv✝ = none
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
⊢ PersistentHashMap.toList'
{ fvarIdToDecl := PersistentHashMap.insert map✝ fv✝ d✝,
decls := PersistentArray.push arr✝ (some d✝) }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ fv✝ d✝, decls := PersistentArray.push arr✝ (some d✝) }) | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ PersistentHashMap.toList'
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) }) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
fv✝ : FVarId
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
h1 : LocalDecl.fvarId d✝ = fv✝
h2 : PersistentHashMap.find? map✝ fv✝ = none
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
⊢ PersistentHashMap.toList'
{ fvarIdToDecl := PersistentHashMap.insert map✝ fv✝ d✝,
decls := PersistentArray.push arr✝ (some d✝) }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ fv✝ d✝, decls := PersistentArray.push arr✝ (some d✝) })
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.map_toList | [43, 1] | [49, 39] | simp [LocalContext.toList] | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ PersistentHashMap.toList'
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) }) | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ PersistentHashMap.toList' (PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝) ~
(LocalDecl.fvarId d✝, d✝) ::
List.map (fun d => (LocalDecl.fvarId d, d)) (List.filterMap id (List.reverse (PersistentArray.toList' arr✝))) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ PersistentHashMap.toList'
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) }.fvarIdToDecl ~
List.map (fun d => (LocalDecl.fvarId d, d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) })
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.map_toList | [43, 1] | [49, 39] | exact h4.map_wf.toList'_insert _ _ (by rwa [h4.map_wf.find?_eq] at h2)
|>.trans (.cons _ h4.map_toList) | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ PersistentHashMap.toList' (PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝) ~
(LocalDecl.fvarId d✝, d✝) ::
List.map (fun d => (LocalDecl.fvarId d, d)) (List.filterMap id (List.reverse (PersistentArray.toList' arr✝))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ PersistentHashMap.toList' (PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝) ~
(LocalDecl.fvarId d✝, d✝) ::
List.map (fun d => (LocalDecl.fvarId d, d)) (List.filterMap id (List.reverse (PersistentArray.toList' arr✝)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.map_toList | [43, 1] | [49, 39] | rwa [h4.map_wf.find?_eq] at h2 | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.lookup (LocalDecl.fvarId d✝) (PersistentHashMap.toList' { fvarIdToDecl := map✝, decls := arr✝ }.fvarIdToDecl) =
none | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
h5 : TrLocalDecl env Us Δ✝ d✝ d'✝
h2 : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.lookup (LocalDecl.fvarId d✝) (PersistentHashMap.toList' { fvarIdToDecl := map✝, decls := arr✝ }.fvarIdToDecl) =
none
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.forall₂ | [51, 1] | [54, 93] | simp [LocalContext.toList] | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList { fvarIdToDecl := PersistentHashMap.empty, decls := PersistentArray.empty }) [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList { fvarIdToDecl := PersistentHashMap.empty, decls := PersistentArray.empty }) []
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.forall₂ | [51, 1] | [54, 93] | subst h1 | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
fv✝ : FVarId
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
h1 : LocalDecl.fvarId d✝ = fv✝
a✝² : PersistentHashMap.find? map✝ fv✝ = none
a✝¹ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝ : TrLocalDecl env Us Δ✝ d✝ d'✝
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ fv✝ d✝, decls := PersistentArray.push arr✝ (some d✝) })
((some fv✝, d'✝) :: Δ✝) | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝² : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝¹ : TrLocalDecl env Us Δ✝ d✝ d'✝
a✝ : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) })
((some (LocalDecl.fvarId d✝), d'✝) :: Δ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
fv✝ : FVarId
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
h1 : LocalDecl.fvarId d✝ = fv✝
a✝² : PersistentHashMap.find? map✝ fv✝ = none
a✝¹ : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝ : TrLocalDecl env Us Δ✝ d✝ d'✝
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ fv✝ d✝, decls := PersistentArray.push arr✝ (some d✝) })
((some fv✝, d'✝) :: Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.forall₂ | [51, 1] | [54, 93] | simp [LocalContext.toList] | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝² : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝¹ : TrLocalDecl env Us Δ✝ d✝ d'✝
a✝ : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) })
((some (LocalDecl.fvarId d✝), d'✝) :: Δ✝) | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝² : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝¹ : TrLocalDecl env Us Δ✝ d✝ d'✝
a✝ : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(d✝ :: List.filterMap id (List.reverse (PersistentArray.toList' arr✝))) ((some (LocalDecl.fvarId d✝), d'✝) :: Δ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝² : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝¹ : TrLocalDecl env Us Δ✝ d✝ d'✝
a✝ : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(LocalContext.toList
{ fvarIdToDecl := PersistentHashMap.insert map✝ (LocalDecl.fvarId d✝) d✝,
decls := PersistentArray.push arr✝ (some d✝) })
((some (LocalDecl.fvarId d✝), d'✝) :: Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.forall₂ | [51, 1] | [54, 93] | exact .cons rfl h4.forall₂ | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝² : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝¹ : TrLocalDecl env Us Δ✝ d✝ d'✝
a✝ : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(d✝ :: List.filterMap id (List.reverse (PersistentArray.toList' arr✝))) ((some (LocalDecl.fvarId d✝), d'✝) :: Δ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
map✝ : PersistentHashMap FVarId LocalDecl
arr✝ : PersistentArray (Option LocalDecl)
Δ✝ : VLCtx
d✝ : LocalDecl
d'✝ : VLocalDecl
a✝² : LocalDecl.index d✝ = arr✝.size
h4 : TrLCtx env Us { fvarIdToDecl := map✝, decls := arr✝ } Δ✝
a✝¹ : TrLocalDecl env Us Δ✝ d✝ d'✝
a✝ : PersistentHashMap.find? map✝ (LocalDecl.fvarId d✝) = none
⊢ List.Forall₂ (fun d d' => d'.fst = some (LocalDecl.fvarId d))
(d✝ :: List.filterMap id (List.reverse (PersistentArray.toList' arr✝))) ((some (LocalDecl.fvarId d✝), d'✝) :: Δ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.fvars_eq | [56, 1] | [60, 42] | simp [LocalContext.fvars, VLCtx.fvars, LocalContext.toList] | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
H : TrLCtx env Us lctx Δ
⊢ LocalContext.fvars lctx = VLCtx.fvars Δ | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
H : TrLCtx env Us lctx Δ
⊢ List.map (fun x => LocalDecl.fvarId x) (List.filterMap id (List.reverse (PersistentArray.toList' lctx.decls))) =
List.filterMap (fun x => x.fst) Δ | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
H : TrLCtx env Us lctx Δ
⊢ LocalContext.fvars lctx = VLCtx.fvars Δ
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Verify/LocalContext.lean | Lean4Lean.TrLCtx.fvars_eq | [56, 1] | [60, 42] | induction H with
| nil => rfl
| cons h1 _ _ _ _ ih => simp [h1, ← ih] | env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
H : TrLCtx env Us lctx Δ
⊢ List.map (fun x => LocalDecl.fvarId x) (List.filterMap id (List.reverse (PersistentArray.toList' lctx.decls))) =
List.filterMap (fun x => x.fst) Δ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Us : List Name
lctx : LocalContext
Δ : VLCtx
H : TrLCtx env Us lctx Δ
⊢ List.map (fun x => LocalDecl.fvarId x) (List.filterMap id (List.reverse (PersistentArray.toList' lctx.decls))) =
List.filterMap (fun x => x.fst) Δ
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.