url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | cases liftN_inj.1 eq | case zero.cons.succ
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
ty✝ : VExpr
H : Lookup (As ++ Γ✝) (Nat.add i (List.length As)) ty✝
eq : lift (liftN (List.length As) A✝) = lift ty✝
⊢ Lookup Γ✝ i A✝ | case zero.cons.succ.refl
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (As ++ Γ✝) (Nat.add i (List.length As)) (liftN (List.length As) A✝)
eq : lift (liftN (List.length As) A✝) = lift (liftN (List.length As) A✝)
⊢ Lookup Γ✝ i A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons.succ
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
ty✝ : VExpr
H : Lookup (As ++ Γ✝) (Nat.add i (List.length As)) ty✝
eq : lift (liftN (List.length As) A✝) = lift ty✝
⊢ Lookup Γ✝ i A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | exact ih H | case zero.cons.succ.refl
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (As ++ Γ✝) (Nat.add i (List.length As)) (liftN (List.length As) A✝)
eq : lift (liftN (List.length As) A✝) = lift (liftN (List.length As) A✝)
⊢ Lookup Γ✝ i A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero.cons.succ.refl
k : Nat
Γ Γ' Γ✝ : List VExpr
i : Nat
A✝ A : VExpr
As : List VExpr
ih : Lookup (As ++ Γ✝) (i + List.length As) (liftN (List.length As) A✝) → Lookup Γ✝ i A✝
H : Lookup (As ++ Γ✝) (Nat.add i (List.length As)) (liftN (List.length As) A✝)
eq : lift (liftN (List.length As) A✝) = lift (liftN (List.length As) A✝)
⊢ Lookup Γ✝ i A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | generalize eA : liftN n A (k+1) = A' at H | case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
i : Nat
A : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) (liftN n A (k + 1))
⊢ Lookup (A✝ :: Γ✝) i A | case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
i : Nat
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) i A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
i : Nat
A : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) (liftN n A (k + 1))
⊢ Lookup (A✝ :: Γ✝) i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | cases i with
| zero =>
simp at H; let .zero := H
rw [lift, liftN'_comm (h := Nat.zero_le _), Nat.add_comm 1, liftN_inj] at eA
subst A; exact .zero
| succ i =>
simp at H; let .succ H := H
obtain ⟨_, rfl, rfl⟩ := of_liftN_eq_liftN (k2 := 0) eA
exact .succ (ih H) | case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
i : Nat
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
i : Nat
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | simp at H | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n Nat.zero (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n Nat.zero (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | let .zero := H | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
eA : liftN n A (k + 1) = lift (liftN n A✝ k)
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | rw [lift, liftN'_comm (h := Nat.zero_le _), Nat.add_comm 1, liftN_inj] at eA | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
eA : liftN n A (k + 1) = lift (liftN n A✝ k)
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
eA : A = liftN 1 A✝
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
eA : liftN n A (k + 1) = lift (liftN n A✝ k)
⊢ Lookup (A✝ :: Γ✝) Nat.zero A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | subst A | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
eA : A = liftN 1 A✝
⊢ Lookup (A✝ :: Γ✝) Nat.zero A | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero (liftN 1 A✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
eA : A = liftN 1 A✝
⊢ Lookup (A✝ :: Γ✝) Nat.zero A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | exact .zero | case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero (liftN 1 A✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.zero
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A' : VExpr
H : Lookup (liftN n A✝ k :: Γ'✝) 0 A'
⊢ Lookup (A✝ :: Γ✝) Nat.zero (liftN 1 A✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | simp at H | case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
i : Nat
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n (Nat.succ i) (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A | case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
i : Nat
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
i : Nat
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n (Nat.succ i) (k + 1)) A'
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | let .succ H := H | case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
i : Nat
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A | case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
i : Nat
H✝ : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
ty✝ : VExpr
H : Lookup Γ'✝ (liftVar n i k) ty✝
eA : liftN n A (k + 1) = lift ty✝
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
eA : liftN n A (k + 1) = A'
i : Nat
H : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | obtain ⟨_, rfl, rfl⟩ := of_liftN_eq_liftN (k2 := 0) eA | case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
i : Nat
H✝ : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
ty✝ : VExpr
H : Lookup Γ'✝ (liftVar n i k) ty✝
eA : liftN n A (k + 1) = lift ty✝
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A | case succ.succ.intro.intro
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A' : VExpr
i : Nat
H✝ : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
w✝ : VExpr
H : Lookup Γ'✝ (liftVar n i k) (liftN n w✝ (k + 0))
eA : liftN n (liftN 1 w✝) (k + 1) = lift (liftN n w✝ (k + 0))
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) (liftN 1 w✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A A' : VExpr
i : Nat
H✝ : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
ty✝ : VExpr
H : Lookup Γ'✝ (liftVar n i k) ty✝
eA : liftN n A (k + 1) = lift ty✝
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weakN_iff | [117, 1] | [141, 25] | exact .succ (ih H) | case succ.succ.intro.intro
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A' : VExpr
i : Nat
H✝ : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
w✝ : VExpr
H : Lookup Γ'✝ (liftVar n i k) (liftN n w✝ (k + 0))
eA : liftN n (liftN 1 w✝) (k + 1) = lift (liftN n w✝ (k + 0))
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) (liftN 1 w✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.succ.intro.intro
n k✝ : Nat
Γ Γ' : List VExpr
k : Nat
Γ✝ Γ'✝ : List VExpr
A✝ : VExpr
a✝ : Ctx.LiftN n k Γ✝ Γ'✝
ih : ∀ {i : Nat} {A : VExpr}, Lookup Γ'✝ (liftVar n i k) (liftN n A k) → Lookup Γ✝ i A
A' : VExpr
i : Nat
H✝ : Lookup (liftN n A✝ k :: Γ'✝) (liftVar n i k + 1) A'
w✝ : VExpr
H : Lookup Γ'✝ (liftVar n i k) (liftN n w✝ (k + 0))
eA : liftN n (liftN 1 w✝) (k + 1) = lift (liftN n w✝ (k + 0))
⊢ Lookup (A✝ :: Γ✝) (Nat.succ i) (liftN 1 w✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weak'_iff | [143, 1] | [152, 44] | generalize e : l.depth = n | l : Lift
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.Lift' l Γ Γ'
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A | l : Lift
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.Lift' l Γ Γ'
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weak'_iff | [143, 1] | [152, 44] | induction n generalizing l Γ' with
| zero => rw [liftVar_depth_zero e, VExpr.lift'_depth_zero e, W.depth_zero e]
| succ n ih =>
obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e
have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip
rw [Lift.consN_skip_eq, liftVar_comp, liftVar_consN_skipN, lift'_comp, lift'_consN_skipN,
weakN_iff W2, ih W1 Lift.depth_consN] | l : Lift
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
l : Lift
Γ Γ' : List VExpr
i : Nat
A : VExpr
W : Ctx.Lift' l Γ Γ'
n : Nat
e : Lift.depth l = n
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weak'_iff | [143, 1] | [152, 44] | rw [liftVar_depth_zero e, VExpr.lift'_depth_zero e, W.depth_zero e] | case zero
Γ : List VExpr
i : Nat
A : VExpr
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
Γ : List VExpr
i : Nat
A : VExpr
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weak'_iff | [143, 1] | [152, 44] | obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e | case succ
Γ : List VExpr
i : Nat
A : VExpr
n : Nat
ih :
∀ {l : Lift} {Γ' : List VExpr},
Ctx.Lift' l Γ Γ' → Lift.depth l = n → (Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A)
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A | case succ.intro.intro.intro
Γ : List VExpr
i : Nat
A : VExpr
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → (Lookup Γ' (Lift.liftVar l_1 i) (lift' A l_1) ↔ Lookup Γ i A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ Lookup Γ' (Lift.liftVar (Lift.consN (Lift.skip l) k) i) (lift' A (Lift.consN (Lift.skip l) k)) ↔ Lookup Γ i A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
Γ : List VExpr
i : Nat
A : VExpr
n : Nat
ih :
∀ {l : Lift} {Γ' : List VExpr},
Ctx.Lift' l Γ Γ' → Lift.depth l = n → (Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A)
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ Lookup Γ' (Lift.liftVar l i) (lift' A l) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weak'_iff | [143, 1] | [152, 44] | have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip | case succ.intro.intro.intro
Γ : List VExpr
i : Nat
A : VExpr
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → (Lookup Γ' (Lift.liftVar l_1 i) (lift' A l_1) ↔ Lookup Γ i A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ Lookup Γ' (Lift.liftVar (Lift.consN (Lift.skip l) k) i) (lift' A (Lift.consN (Lift.skip l) k)) ↔ Lookup Γ i A | case succ.intro.intro.intro
Γ : List VExpr
i : Nat
A : VExpr
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → (Lookup Γ' (Lift.liftVar l_1 i) (lift' A l_1) ↔ Lookup Γ i A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ Lookup Γ' (Lift.liftVar (Lift.consN (Lift.skip l) k) i) (lift' A (Lift.consN (Lift.skip l) k)) ↔ Lookup Γ i A | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
Γ : List VExpr
i : Nat
A : VExpr
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → (Lookup Γ' (Lift.liftVar l_1 i) (lift' A l_1) ↔ Lookup Γ i A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ Lookup Γ' (Lift.liftVar (Lift.consN (Lift.skip l) k) i) (lift' A (Lift.consN (Lift.skip l) k)) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Lookup.weak'_iff | [143, 1] | [152, 44] | rw [Lift.consN_skip_eq, liftVar_comp, liftVar_consN_skipN, lift'_comp, lift'_consN_skipN,
weakN_iff W2, ih W1 Lift.depth_consN] | case succ.intro.intro.intro
Γ : List VExpr
i : Nat
A : VExpr
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → (Lookup Γ' (Lift.liftVar l_1 i) (lift' A l_1) ↔ Lookup Γ i A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ Lookup Γ' (Lift.liftVar (Lift.consN (Lift.skip l) k) i) (lift' A (Lift.consN (Lift.skip l) k)) ↔ Lookup Γ i A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
Γ : List VExpr
i : Nat
A : VExpr
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → (Lookup Γ' (Lift.liftVar l_1 i) (lift' A l_1) ↔ Lookup Γ i A)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ Lookup Γ' (Lift.liftVar (Lift.consN (Lift.skip l) k) i) (lift' A (Lift.consN (Lift.skip l) k)) ↔ Lookup Γ i A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.right | [180, 1] | [184, 86] | simpa using LiftN.zero (Γ := []) Γ' | Γ : List VExpr
h : CtxClosed Γ
Γ' : List VExpr
x✝ : CtxClosed []
⊢ LiftN (List.length Γ') (List.length []) [] ([] ++ Γ') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Γ : List VExpr
h : CtxClosed Γ
Γ' : List VExpr
x✝ : CtxClosed []
⊢ LiftN (List.length Γ') (List.length []) [] ([] ++ Γ')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.Ctx.LiftN.right | [180, 1] | [184, 86] | simpa [h2.liftN_eq (Nat.le_refl _)] using LiftN.succ (LiftN.right h1 Γ') (A := A) | Γ✝ : List VExpr
h : CtxClosed Γ✝
Γ' : List VExpr
A : VExpr
Γ : List VExpr
h1 : OnCtx Γ fun Γ A => ClosedN A (List.length Γ)
h2 : (fun Γ A => ClosedN A (List.length Γ)) Γ A
⊢ LiftN (List.length Γ') (List.length (A :: Γ)) (A :: Γ) (A :: Γ ++ Γ') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Γ✝ : List VExpr
h : CtxClosed Γ✝
Γ' : List VExpr
A : VExpr
Γ : List VExpr
h1 : OnCtx Γ fun Γ A => ClosedN A (List.length Γ)
h2 : (fun Γ A => ClosedN A (List.length Γ)) Γ A
⊢ LiftN (List.length Γ') (List.length (A :: Γ)) (A :: Γ) (A :: Γ ++ Γ')
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | unfold addConst at h | n : Name
oci : Option VConstant
env env' : VEnv
h : addConst env n oci = some env'
⊢ env ≤ env' | n : Name
oci : Option VConstant
env env' : VEnv
h :
(match env.constants n with
| some val => none
| none => some { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }) =
some env'
⊢ env ≤ env' | Please generate a tactic in lean4 to solve the state.
STATE:
n : Name
oci : Option VConstant
env env' : VEnv
h : addConst env n oci = some env'
⊢ env ≤ env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | split at h <;> cases h | n : Name
oci : Option VConstant
env env' : VEnv
h :
(match env.constants n with
| some val => none
| none => some { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }) =
some env'
⊢ env ≤ env' | case h_2.refl
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
⊢ env ≤ { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs } | Please generate a tactic in lean4 to solve the state.
STATE:
n : Name
oci : Option VConstant
env env' : VEnv
h :
(match env.constants n with
| some val => none
| none => some { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }) =
some env'
⊢ env ≤ env'
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | refine ⟨fun n ci h => ?_, fun _ => id⟩ | case h_2.refl
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
⊢ env ≤ { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs } | case h_2.refl
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ { constants := fun n => if n✝ = n then some oci else env.constants n, defeqs := env.defeqs }.constants n = some ci | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
⊢ env ≤ { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | simp | case h_2.refl
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ { constants := fun n => if n✝ = n then some oci else env.constants n, defeqs := env.defeqs }.constants n = some ci | case h_2.refl
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ (if n✝ = n then some oci else env.constants n) = some ci | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ { constants := fun n => if n✝ = n then some oci else env.constants n, defeqs := env.defeqs }.constants n = some ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | rwa [if_neg] | case h_2.refl
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ (if n✝ = n then some oci else env.constants n) = some ci | case h_2.refl.hnc
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ ¬n✝ = n | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ (if n✝ = n then some oci else env.constants n) = some ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | rintro rfl | case h_2.refl.hnc
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ ¬n✝ = n | case h_2.refl.hnc
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
ci : Option VConstant
h : env.constants n = some ci
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl.hnc
n✝ : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n✝ = none
n : Name
ci : Option VConstant
h : env.constants n = some ci
⊢ ¬n✝ = n
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_le | [192, 1] | [195, 64] | cases h.symm.trans ‹_ = none› | case h_2.refl.hnc
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
ci : Option VConstant
h : env.constants n = some ci
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl.hnc
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
ci : Option VConstant
h : env.constants n = some ci
⊢ False
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_self | [197, 1] | [199, 53] | unfold addConst at h | n : Name
oci : Option VConstant
env env' : VEnv
h : addConst env n oci = some env'
⊢ env'.constants n = some oci | n : Name
oci : Option VConstant
env env' : VEnv
h :
(match env.constants n with
| some val => none
| none => some { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }) =
some env'
⊢ env'.constants n = some oci | Please generate a tactic in lean4 to solve the state.
STATE:
n : Name
oci : Option VConstant
env env' : VEnv
h : addConst env n oci = some env'
⊢ env'.constants n = some oci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_self | [197, 1] | [199, 53] | split at h <;> cases h | n : Name
oci : Option VConstant
env env' : VEnv
h :
(match env.constants n with
| some val => none
| none => some { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }) =
some env'
⊢ env'.constants n = some oci | case h_2.refl
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
⊢ { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }.constants n =
some oci | Please generate a tactic in lean4 to solve the state.
STATE:
n : Name
oci : Option VConstant
env env' : VEnv
h :
(match env.constants n with
| some val => none
| none => some { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }) =
some env'
⊢ env'.constants n = some oci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addConst_self | [197, 1] | [199, 53] | simp | case h_2.refl
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
⊢ { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }.constants n =
some oci | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl
n : Name
oci : Option VConstant
env : VEnv
x✝ : Option (Option VConstant)
heq✝ : env.constants n = none
⊢ { constants := fun n_1 => if n = n_1 then some oci else env.constants n_1, defeqs := env.defeqs }.constants n =
some oci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.addDefEq_le | [201, 1] | [202, 53] | simp [addDefEq, h] | df✝ : VDefEq
env : VEnv
df : VDefEq
h : env.defeqs df
⊢ (addDefEq env df✝).defeqs df | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
df✝ : VDefEq
env : VEnv
df : VDefEq
h : env.defeqs df
⊢ (addDefEq env df✝).defeqs df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | exact ⟨nofun, nofun⟩ | case empty
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
⊢ OnTypes ∅ (motive ∅) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
⊢ OnTypes ∅ (motive ∅)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | apply OnTypes.mono .rfl (mono (addConst_le h3)) | case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ (motive env'✝) | case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ (motive env'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | unfold addConst at h3 | case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ fun {U} {e A} => motive env✝ U e A | case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 :
(match env✝.constants n✝ with
| some val => none
| none => some { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }) =
some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | split at h3 <;> cases h3 | case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 :
(match env✝.constants n✝ with
| some val => none
| none => some { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }) =
some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ fun {U} {e A} => motive env✝ U e A | case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
⊢ OnTypes { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }
fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 :
(match env✝.constants n✝ with
| some val => none
| none => some { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }) =
some env'✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes env'✝ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | refine ⟨fun h => ?_, ih.2⟩ | case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
⊢ OnTypes { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }
fun {U} {e A} => motive env✝ U e A | case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h :
{ constants := fun n => if n✝¹ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }.constants n✝ =
some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
⊢ OnTypes { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }
fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | simp at h | case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h :
{ constants := fun n => if n✝¹ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }.constants n✝ =
some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h : (if n✝¹ = n✝ then some oci✝ else env✝.constants n✝) = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h :
{ constants := fun n => if n✝¹ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }.constants n✝ =
some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | split at h | case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h : (if n✝¹ = n✝ then some oci✝ else env✝.constants n✝) = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | case const.h_2.refl.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h : some oci✝ = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A
case const.h_2.refl.inr
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : ¬n✝¹ = n✝
h : env✝.constants n✝ = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h : (if n✝¹ = n✝ then some oci✝ else env✝.constants n✝) = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | cases h | case const.h_2.refl.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h : some oci✝ = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | case const.h_2.refl.inl.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
n✝¹ : Name
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h2 : ∀ (ci : VConstant), some ci✝ = some ci → VConstant.WF env✝ ci
⊢ Exists fun u {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h : some oci✝ = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | let ⟨_, ht⟩ := h2 _ rfl | case const.h_2.refl.inl.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
n✝¹ : Name
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h2 : ∀ (ci : VConstant), some ci✝ = some ci → VConstant.WF env✝ ci
⊢ Exists fun u {U} {e A} => motive env✝ U e A | case const.h_2.refl.inl.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
n✝¹ : Name
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h2 : ∀ (ci : VConstant), some ci✝ = some ci → VConstant.WF env✝ ci
w✝ : VLevel
ht : HasType env✝ ci✝.uvars [] ci✝.type (sort w✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl.inl.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
n✝¹ : Name
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h2 : ∀ (ci : VConstant), some ci✝ = some ci → VConstant.WF env✝ ci
⊢ Exists fun u {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | exact ⟨_, type h1 ih ht⟩ | case const.h_2.refl.inl.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
n✝¹ : Name
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h2 : ∀ (ci : VConstant), some ci✝ = some ci → VConstant.WF env✝ ci
w✝ : VLevel
ht : HasType env✝ ci✝.uvars [] ci✝.type (sort w✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl.inl.refl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
n✝¹ : Name
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : n✝¹ = n✝
h2 : ∀ (ci : VConstant), some ci✝ = some ci → VConstant.WF env✝ ci
w✝ : VLevel
ht : HasType env✝ ci✝.uvars [] ci✝.type (sort w✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | exact ih.1 h | case const.h_2.refl.inr
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : ¬n✝¹ = n✝
h : env✝.constants n✝ = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl.inr
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
oci✝ : Option VConstant
n✝¹ : Name
h1 : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : OnTypes env✝ (motive env✝)
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝¹ = none
n✝ : Name
ci✝ : VConstant
h✝ : ¬n✝¹ = n✝
h : env✝.constants n✝ = some (some ci✝)
⊢ Exists fun u {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | apply OnTypes.mono .rfl (mono addDefEq_le) | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes (addDefEq env✝ df✝) (motive (addDefEq env✝ df✝)) | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes (addDefEq env✝ df✝) fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes (addDefEq env✝ df✝) (motive (addDefEq env✝ df✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | refine ⟨ih.1, fun hdf => ?_⟩ | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes (addDefEq env✝ df✝) fun {U} {e A} => motive env✝ U e A | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : (addDefEq env✝ df✝¹).defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝
ih : OnTypes env✝ (motive env✝)
⊢ OnTypes (addDefEq env✝ df✝) fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | simp [addDefEq] at hdf | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : (addDefEq env✝ df✝¹).defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : df✝ = df✝¹ ∨ env✝.defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : (addDefEq env✝ df✝¹).defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | obtain rfl | hdf := hdf | case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : df✝ = df✝¹ ∨ env✝.defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | case defeq.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
h2 : VDefEq.WF env✝ df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A
case defeq.inr
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : env✝.defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : df✝ = df✝¹ ∨ env✝.defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | let ⟨hl, hr⟩ := h2 | case defeq.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
h2 : VDefEq.WF env✝ df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | case defeq.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
h2 : VDefEq.WF env✝ df✝
hl : HasType env✝ df✝.uvars [] df✝.lhs df✝.type
hr : HasType env✝ df✝.uvars [] df✝.rhs df✝.type
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
h2 : VDefEq.WF env✝ df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | exact ⟨type h1 ih hl, type h1 ih hr⟩ | case defeq.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
h2 : VDefEq.WF env✝ df✝
hl : HasType env✝ df✝.uvars [] df✝.lhs df✝.type
hr : HasType env✝ df✝.uvars [] df✝.rhs df✝.type
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq.inl
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
h1 : Ordered env✝
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
h2 : VDefEq.WF env✝ df✝
hl : HasType env✝ df✝.uvars [] df✝.lhs df✝.type
hr : HasType env✝ df✝.uvars [] df✝.rhs df✝.type
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.induction | [269, 1] | [292, 21] | exact ih.2 hdf | case defeq.inr
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : env✝.defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq.inr
env : VEnv
motive : VEnv → Nat → VExpr → VExpr → Prop
mono : ∀ {env env' : VEnv} {U : Nat} {e A : VExpr}, env ≤ env' → motive env U e A → motive env' U e A
type :
∀ {env : VEnv} {U : Nat} {e A : VExpr},
Ordered env → OnTypes env (motive env) → HasType env U [] e A → motive env U e A
env✝ : VEnv
df✝¹ : VDefEq
h1 : Ordered env✝
h2 : VDefEq.WF env✝ df✝¹
ih : OnTypes env✝ (motive env✝)
df✝ : VDefEq
hdf : env✝.defeqs df✝
⊢ (fun {U} {e A} => motive env✝ U e A) ∧ fun {U} {e A} => motive env✝ U e A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | induction H with
| bvar h => exact ⟨h.lt, h.lt, hΓ.lookup h⟩
| constDF h1 =>
let ⟨_, h, _⟩ := henv.1 h1
exact ⟨trivial, trivial, h.instL.mono (Nat.zero_le _)⟩
| sortDF => exact ⟨trivial, trivial, trivial⟩
| symm _ ih => let ⟨h1, h2, h3⟩ := ih hΓ; exact ⟨h2, h1, h3⟩
| trans _ _ ih1 ih2 => exact ⟨(ih1 hΓ).1, (ih2 hΓ).2.1, (ih1 hΓ).2.2⟩
| appDF _ _ ih1 ih2 =>
let ⟨hf, hf', _, hB⟩ := ih1 hΓ
let ⟨ha, ha', _⟩ := ih2 hΓ
exact ⟨⟨hf, ha⟩, ⟨hf', ha'⟩, hB.inst ha⟩
| lamDF _ _ ih1 ih2 =>
let ⟨hA, hA', _⟩ := ih1 hΓ
let ⟨hb, hb', hB⟩ := ih2 ⟨hΓ, hA⟩
exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, hA, hB⟩
| forallEDF _ _ ih1 ih2 =>
let ⟨hA, hA', _⟩ := ih1 hΓ
let ⟨hb, hb', _⟩ := ih2 ⟨hΓ, hA⟩
exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, trivial⟩
| defeqDF _ _ ih1 ih2 => exact ⟨(ih2 hΓ).1, (ih2 hΓ).2.1, (ih1 hΓ).2.1⟩
| beta _ _ ih1 ih2 =>
let ⟨he', _, hA⟩ := ih2 hΓ
let ⟨he, _, hB⟩ := ih1 ⟨hΓ, hA⟩
exact ⟨⟨⟨hA, he⟩, he'⟩, he.inst he', hB.inst he'⟩
| eta _ ih =>
let ⟨he, _, hA, hB⟩ := ih hΓ
exact ⟨⟨hA, he.liftN, Nat.succ_pos _⟩, he, hA, hB⟩
| proofIrrel _ _ _ _ ih2 ih3 =>
let ⟨hh, _, _⟩ := ih2 hΓ
let ⟨hh', _, hp⟩ := ih3 hΓ
exact ⟨hh, hh', hp⟩
| extra h1 _ _ =>
let ⟨⟨hl, _⟩, ⟨hr, hA⟩⟩ := henv.2 h1
exact ⟨
hl.instL.mono (Nat.zero_le _),
hr.instL.mono (Nat.zero_le _),
hA.instL.mono (Nat.zero_le _)⟩ | env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
hΓ : CtxClosed Γ
⊢ ClosedN e1 (List.length Γ) ∧ ClosedN e2 (List.length Γ) ∧ ClosedN A (List.length Γ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
hΓ : CtxClosed Γ
⊢ ClosedN e1 (List.length Γ) ∧ ClosedN e2 (List.length Γ) ∧ ClosedN A (List.length Γ)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨h.lt, h.lt, hΓ.lookup h⟩ | case bvar
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.bvar i✝) (List.length Γ✝) ∧ ClosedN (VExpr.bvar i✝) (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.bvar i✝) (List.length Γ✝) ∧ ClosedN (VExpr.bvar i✝) (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨_, h, _⟩ := henv.1 h1 | case constDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
a✝³ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.const c✝ ls✝) (List.length Γ✝) ∧
ClosedN (VExpr.const c✝ ls'✝) (List.length Γ✝) ∧ ClosedN (instL ls✝ ci✝.type) (List.length Γ✝) | case constDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
a✝³ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : CtxClosed Γ✝
w✝ : VLevel
h : ClosedN ci✝.type
right✝ : ClosedN (VExpr.sort w✝)
⊢ ClosedN (VExpr.const c✝ ls✝) (List.length Γ✝) ∧
ClosedN (VExpr.const c✝ ls'✝) (List.length Γ✝) ∧ ClosedN (instL ls✝ ci✝.type) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
a✝³ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.const c✝ ls✝) (List.length Γ✝) ∧
ClosedN (VExpr.const c✝ ls'✝) (List.length Γ✝) ∧ ClosedN (instL ls✝ ci✝.type) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨trivial, trivial, h.instL.mono (Nat.zero_le _)⟩ | case constDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
a✝³ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : CtxClosed Γ✝
w✝ : VLevel
h : ClosedN ci✝.type
right✝ : ClosedN (VExpr.sort w✝)
⊢ ClosedN (VExpr.const c✝ ls✝) (List.length Γ✝) ∧
ClosedN (VExpr.const c✝ ls'✝) (List.length Γ✝) ∧ ClosedN (instL ls✝ ci✝.type) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
a✝³ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝² : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
a✝¹ : List.length ls✝ = ci✝.uvars
a✝ : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
hΓ : CtxClosed Γ✝
w✝ : VLevel
h : ClosedN ci✝.type
right✝ : ClosedN (VExpr.sort w✝)
⊢ ClosedN (VExpr.const c✝ ls✝) (List.length Γ✝) ∧
ClosedN (VExpr.const c✝ ls'✝) (List.length Γ✝) ∧ ClosedN (instL ls✝ ci✝.type) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨trivial, trivial, trivial⟩ | case sortDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
a✝² : VLevel.WF U l✝
a✝¹ : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.sort l✝) (List.length Γ✝) ∧
ClosedN (VExpr.sort l'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.succ l✝)) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
a✝² : VLevel.WF U l✝
a✝¹ : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.sort l✝) (List.length Γ✝) ∧
ClosedN (VExpr.sort l'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.succ l✝)) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨h1, h2, h3⟩ := ih hΓ | case symm
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : CtxClosed Γ✝ → ClosedN e✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝) | case symm
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : CtxClosed Γ✝ → ClosedN e✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
h1 : ClosedN e✝ (List.length Γ✝)
h2 : ClosedN e'✝ (List.length Γ✝)
h3 : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : CtxClosed Γ✝ → ClosedN e✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨h2, h1, h3⟩ | case symm
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : CtxClosed Γ✝ → ClosedN e✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
h1 : ClosedN e✝ (List.length Γ✝)
h2 : ClosedN e'✝ (List.length Γ✝)
h3 : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : CtxClosed Γ✝ → ClosedN e✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
h1 : ClosedN e✝ (List.length Γ✝)
h2 : ClosedN e'✝ (List.length Γ✝)
h3 : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨(ih1 hΓ).1, (ih2 hΓ).2.1, (ih1 hΓ).2.2⟩ | case trans
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 : CtxClosed Γ✝ → ClosedN e₁✝ (List.length Γ✝) ∧ ClosedN e₂✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN e₂✝ (List.length Γ✝) ∧ ClosedN e₃✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN e₁✝ (List.length Γ✝) ∧ ClosedN e₃✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 : CtxClosed Γ✝ → ClosedN e₁✝ (List.length Γ✝) ∧ ClosedN e₂✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN e₂✝ (List.length Γ✝) ∧ ClosedN e₃✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN e₁✝ (List.length Γ✝) ∧ ClosedN e₃✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hf, hf', _, hB⟩ := ih1 hΓ | case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝) | case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hf : ClosedN f✝ (List.length Γ✝)
hf' : ClosedN f'✝ (List.length Γ✝)
left✝ : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨ha, ha', _⟩ := ih2 hΓ | case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hf : ClosedN f✝ (List.length Γ✝)
hf' : ClosedN f'✝ (List.length Γ✝)
left✝ : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝) | case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hf : ClosedN f✝ (List.length Γ✝)
hf' : ClosedN f'✝ (List.length Γ✝)
left✝ : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
ha : ClosedN a✝² (List.length Γ✝)
ha' : ClosedN a'✝ (List.length Γ✝)
right✝ : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hf : ClosedN f✝ (List.length Γ✝)
hf' : ClosedN f'✝ (List.length Γ✝)
left✝ : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨⟨hf, ha⟩, ⟨hf', ha'⟩, hB.inst ha⟩ | case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hf : ClosedN f✝ (List.length Γ✝)
hf' : ClosedN f'✝ (List.length Γ✝)
left✝ : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
ha : ClosedN a✝² (List.length Γ✝)
ha' : ClosedN a'✝ (List.length Γ✝)
right✝ : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 :
CtxClosed Γ✝ →
ClosedN f✝ (List.length Γ✝) ∧ ClosedN f'✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN a✝² (List.length Γ✝) ∧ ClosedN a'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hf : ClosedN f✝ (List.length Γ✝)
hf' : ClosedN f'✝ (List.length Γ✝)
left✝ : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
ha : ClosedN a✝² (List.length Γ✝)
ha' : ClosedN a'✝ (List.length Γ✝)
right✝ : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN (app f✝ a✝²) (List.length Γ✝) ∧
ClosedN (app f'✝ a'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ a✝²) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hA, hA', _⟩ := ih1 hΓ | case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hb, hb', hB⟩ := ih2 ⟨hΓ, hA⟩ | case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
hb : ClosedN body✝ (List.length (A✝ :: Γ✝))
hb' : ClosedN body'✝ (List.length (A✝ :: Γ✝))
hB : ClosedN B✝ (List.length (A✝ :: Γ✝))
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, hA, hB⟩ | case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
hb : ClosedN body✝ (List.length (A✝ :: Γ✝))
hb' : ClosedN body'✝ (List.length (A✝ :: Γ✝))
hB : ClosedN B✝ (List.length (A✝ :: Γ✝))
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
hb : ClosedN body✝ (List.length (A✝ :: Γ✝))
hb' : ClosedN body'✝ (List.length (A✝ :: Γ✝))
hB : ClosedN B✝ (List.length (A✝ :: Γ✝))
⊢ ClosedN (lam A✝ body✝) (List.length Γ✝) ∧
ClosedN (lam A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hA, hA', _⟩ := ih1 hΓ | case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝) | case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hb, hb', _⟩ := ih2 ⟨hΓ, hA⟩ | case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝) | case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝¹ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
hb : ClosedN body✝ (List.length (A✝ :: Γ✝))
hb' : ClosedN body'✝ (List.length (A✝ :: Γ✝))
right✝ : ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, trivial⟩ | case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝¹ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
hb : ClosedN body✝ (List.length (A✝ :: Γ✝))
hb' : ClosedN body'✝ (List.length (A✝ :: Γ✝))
right✝ : ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN A'✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 :
CtxClosed (A✝ :: Γ✝) →
ClosedN body✝ (List.length (A✝ :: Γ✝)) ∧
ClosedN body'✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
hΓ : CtxClosed Γ✝
hA : ClosedN A✝ (List.length Γ✝)
hA' : ClosedN A'✝ (List.length Γ✝)
right✝¹ : ClosedN (VExpr.sort u✝) (List.length Γ✝)
hb : ClosedN body✝ (List.length (A✝ :: Γ✝))
hb' : ClosedN body'✝ (List.length (A✝ :: Γ✝))
right✝ : ClosedN (VExpr.sort v✝) (List.length (A✝ :: Γ✝))
⊢ ClosedN (VExpr.forallE A✝ body✝) (List.length Γ✝) ∧
ClosedN (VExpr.forallE A'✝ body'✝) (List.length Γ✝) ∧ ClosedN (VExpr.sort (VLevel.imax u✝ v✝)) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨(ih2 hΓ).1, (ih2 hΓ).2.1, (ih1 hΓ).2.1⟩ | case defeqDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN B✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN e1✝ (List.length Γ✝) ∧ ClosedN e2✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN e1✝ (List.length Γ✝) ∧ ClosedN e2✝ (List.length Γ✝) ∧ ClosedN B✝ (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 :
CtxClosed Γ✝ → ClosedN A✝ (List.length Γ✝) ∧ ClosedN B✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort u✝) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN e1✝ (List.length Γ✝) ∧ ClosedN e2✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN e1✝ (List.length Γ✝) ∧ ClosedN e2✝ (List.length Γ✝) ∧ ClosedN B✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨he', _, hA⟩ := ih2 hΓ | case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝) | case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
he' left✝ : ClosedN e'✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨he, _, hB⟩ := ih1 ⟨hΓ, hA⟩ | case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
he' left✝ : ClosedN e'✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝) | case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
he' left✝¹ : ClosedN e'✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
he left✝ : ClosedN e✝ (List.length (A✝ :: Γ✝))
hB : ClosedN B✝ (List.length (A✝ :: Γ✝))
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
he' left✝ : ClosedN e'✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨⟨⟨hA, he⟩, he'⟩, he.inst he', hB.inst he'⟩ | case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
he' left✝¹ : ClosedN e'✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
he left✝ : ClosedN e✝ (List.length (A✝ :: Γ✝))
hB : ClosedN B✝ (List.length (A✝ :: Γ✝))
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 :
CtxClosed (A✝ :: Γ✝) →
ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN e✝ (List.length (A✝ :: Γ✝)) ∧ ClosedN B✝ (List.length (A✝ :: Γ✝))
ih2 : CtxClosed Γ✝ → ClosedN e'✝ (List.length Γ✝) ∧ ClosedN e'✝ (List.length Γ✝) ∧ ClosedN A✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
he' left✝¹ : ClosedN e'✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
he left✝ : ClosedN e✝ (List.length (A✝ :: Γ✝))
hB : ClosedN B✝ (List.length (A✝ :: Γ✝))
⊢ ClosedN (app (lam A✝ e✝) e'✝) (List.length Γ✝) ∧
ClosedN (inst e✝ e'✝) (List.length Γ✝) ∧ ClosedN (inst B✝ e'✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨he, _, hA, hB⟩ := ih hΓ | case eta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
CtxClosed Γ✝ →
ClosedN e✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (List.length Γ✝) ∧
ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | case eta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
CtxClosed Γ✝ →
ClosedN e✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
hΓ : CtxClosed Γ✝
he left✝ : ClosedN e✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
⊢ ClosedN (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (List.length Γ✝) ∧
ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
CtxClosed Γ✝ →
ClosedN e✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (List.length Γ✝) ∧
ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨⟨hA, he.liftN, Nat.succ_pos _⟩, he, hA, hB⟩ | case eta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
CtxClosed Γ✝ →
ClosedN e✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
hΓ : CtxClosed Γ✝
he left✝ : ClosedN e✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
⊢ ClosedN (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (List.length Γ✝) ∧
ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
CtxClosed Γ✝ →
ClosedN e✝ (List.length Γ✝) ∧ ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
hΓ : CtxClosed Γ✝
he left✝ : ClosedN e✝ (List.length Γ✝)
hA : ClosedN A✝ (List.length Γ✝)
hB : ClosedN B✝ (List.length Γ✝ + 1)
⊢ ClosedN (lam A✝ (app (lift e✝) (VExpr.bvar 0))) (List.length Γ✝) ∧
ClosedN e✝ (List.length Γ✝) ∧ ClosedN (VExpr.forallE A✝ B✝) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hh, _, _⟩ := ih2 hΓ | case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) | case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hh left✝ : ClosedN h✝ (List.length Γ✝)
right✝ : ClosedN p✝ (List.length Γ✝)
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨hh', _, hp⟩ := ih3 hΓ | case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hh left✝ : ClosedN h✝ (List.length Γ✝)
right✝ : ClosedN p✝ (List.length Γ✝)
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) | case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hh left✝¹ : ClosedN h✝ (List.length Γ✝)
right✝ : ClosedN p✝ (List.length Γ✝)
hh' left✝ : ClosedN h'✝ (List.length Γ✝)
hp : ClosedN p✝ (List.length Γ✝)
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hh left✝ : ClosedN h✝ (List.length Γ✝)
right✝ : ClosedN p✝ (List.length Γ✝)
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨hh, hh', hp⟩ | case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hh left✝¹ : ClosedN h✝ (List.length Γ✝)
right✝ : ClosedN p✝ (List.length Γ✝)
hh' left✝ : ClosedN h'✝ (List.length Γ✝)
hp : ClosedN p✝ (List.length Γ✝)
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
a_ih✝ :
CtxClosed Γ✝ →
ClosedN p✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝) ∧ ClosedN (VExpr.sort VLevel.zero) (List.length Γ✝)
ih2 : CtxClosed Γ✝ → ClosedN h✝ (List.length Γ✝) ∧ ClosedN h✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
ih3 : CtxClosed Γ✝ → ClosedN h'✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
hΓ : CtxClosed Γ✝
hh left✝¹ : ClosedN h✝ (List.length Γ✝)
right✝ : ClosedN p✝ (List.length Γ✝)
hh' left✝ : ClosedN h'✝ (List.length Γ✝)
hp : ClosedN p✝ (List.length Γ✝)
⊢ ClosedN h✝ (List.length Γ✝) ∧ ClosedN h'✝ (List.length Γ✝) ∧ ClosedN p✝ (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | let ⟨⟨hl, _⟩, ⟨hr, hA⟩⟩ := henv.2 h1 | case extra
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
a✝¹ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : CtxClosed Γ✝
⊢ ClosedN (instL ls✝ df✝.lhs) (List.length Γ✝) ∧
ClosedN (instL ls✝ df✝.rhs) (List.length Γ✝) ∧ ClosedN (instL ls✝ df✝.type) (List.length Γ✝) | case extra
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
a✝¹ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : CtxClosed Γ✝
hl : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hr : ClosedN df✝.rhs
hA : ClosedN df✝.type
⊢ ClosedN (instL ls✝ df✝.lhs) (List.length Γ✝) ∧
ClosedN (instL ls✝ df✝.rhs) (List.length Γ✝) ∧ ClosedN (instL ls✝ df✝.type) (List.length Γ✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
a✝¹ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : CtxClosed Γ✝
⊢ ClosedN (instL ls✝ df✝.lhs) (List.length Γ✝) ∧
ClosedN (instL ls✝ df✝.rhs) (List.length Γ✝) ∧ ClosedN (instL ls✝ df✝.type) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.closedN' | [314, 1] | [353, 37] | exact ⟨
hl.instL.mono (Nat.zero_le _),
hr.instL.mono (Nat.zero_le _),
hA.instL.mono (Nat.zero_le _)⟩ | case extra
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
a✝¹ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : CtxClosed Γ✝
hl : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hr : ClosedN df✝.rhs
hA : ClosedN df✝.type
⊢ ClosedN (instL ls✝ df✝.lhs) (List.length Γ✝) ∧
ClosedN (instL ls✝ df✝.rhs) (List.length Γ✝) ∧ ClosedN (instL ls✝ df✝.type) (List.length Γ✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : OnTypes env fun x e A => ClosedN e ∧ ClosedN A
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
a✝¹ : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
hΓ : CtxClosed Γ✝
hl : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hr : ClosedN df✝.rhs
hA : ClosedN df✝.type
⊢ ClosedN (instL ls✝ df✝.lhs) (List.length Γ✝) ∧
ClosedN (instL ls✝ df✝.rhs) (List.length Γ✝) ∧ ClosedN (instL ls✝ df✝.type) (List.length Γ✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEqCtx.closed | [367, 1] | [372, 92] | simpa [h1.length_eq] using h2.symm.closedN henv c1 | env : VEnv
henv : Ordered env
Γ₀ : List VExpr
U : Nat
Γ₁ Γ₂ : List VExpr
H : CtxClosed Γ₀
Γ₁✝ Γ₂✝ : List VExpr
A₁✝ A₂✝ : VExpr
u✝ : VLevel
h1 : IsDefEqCtx env U Γ₀ Γ₁✝ Γ₂✝
h2 : IsDefEq env U Γ₁✝ A₁✝ A₂✝ (sort u✝)
c1 : CtxClosed Γ₁✝
c2 : CtxClosed Γ₂✝
⊢ (fun Γ A => ClosedN A (List.length Γ)) Γ₂✝ A₂✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Γ₀ : List VExpr
U : Nat
Γ₁ Γ₂ : List VExpr
H : CtxClosed Γ₀
Γ₁✝ Γ₂✝ : List VExpr
A₁✝ A₂✝ : VExpr
u✝ : VLevel
h1 : IsDefEqCtx env U Γ₀ Γ₁✝ Γ₂✝
h2 : IsDefEq env U Γ₁✝ A₁✝ A₂✝ (sort u✝)
c1 : CtxClosed Γ₁✝
c2 : CtxClosed Γ₂✝
⊢ (fun Γ A => ClosedN A (List.length Γ)) Γ₂✝ A₂✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | induction H with
| bvar h => exact .bvar h
| constDF h1 h2 h3 h4 h5 => exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| appDF _ _ ih1 ih2 => exact .appDF ih1 ih2
| lamDF _ _ ih1 ih2 => exact .lamDF ih1 ih2
| forallEDF _ _ ih1 ih2 => exact .forallEDF ih1 ih2
| defeqDF _ _ ih1 ih2 => exact .defeqDF ih1 ih2
| beta _ _ ih1 ih2 => exact .beta ih1 ih2
| eta _ ih => exact .eta ih
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 => exact .extra (henv.2 _ h1) h2 h3 | env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env' U Γ e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env' U Γ e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .bvar h | case bvar
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ IsDefEq env' U Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝) A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ IsDefEq env' U Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝) A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5 | case constDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
⊢ IsDefEq env' U Γ✝ (VExpr.const c✝ ls✝) (VExpr.const c✝ ls'✝) (instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
⊢ IsDefEq env' U Γ✝ (VExpr.const c✝ ls✝) (VExpr.const c✝ ls'✝) (instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .sortDF h1 h2 h3 | case sortDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env' U Γ✝ (VExpr.sort l✝) (VExpr.sort l'✝) (VExpr.sort (VLevel.succ l✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env' U Γ✝ (VExpr.sort l✝) (VExpr.sort l'✝) (VExpr.sort (VLevel.succ l✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .symm ih | case symm
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : IsDefEq env' U Γ✝ e✝ e'✝ A✝
⊢ IsDefEq env' U Γ✝ e'✝ e✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : IsDefEq env' U Γ✝ e✝ e'✝ A✝
⊢ IsDefEq env' U Γ✝ e'✝ e✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .trans ih1 ih2 | case trans
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 : IsDefEq env' U Γ✝ e₁✝ e₂✝ A✝
ih2 : IsDefEq env' U Γ✝ e₂✝ e₃✝ A✝
⊢ IsDefEq env' U Γ✝ e₁✝ e₃✝ A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 : IsDefEq env' U Γ✝ e₁✝ e₂✝ A✝
ih2 : IsDefEq env' U Γ✝ e₂✝ e₃✝ A✝
⊢ IsDefEq env' U Γ✝ e₁✝ e₃✝ A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .appDF ih1 ih2 | case appDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 : IsDefEq env' U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
ih2 : IsDefEq env' U Γ✝ a✝² a'✝ A✝
⊢ IsDefEq env' U Γ✝ (app f✝ a✝²) (app f'✝ a'✝) (inst B✝ a✝²) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 : IsDefEq env' U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
ih2 : IsDefEq env' U Γ✝ a✝² a'✝ A✝
⊢ IsDefEq env' U Γ✝ (app f✝ a✝²) (app f'✝ a'✝) (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .lamDF ih1 ih2 | case lamDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 : IsDefEq env' U Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U (A✝ :: Γ✝) body✝ body'✝ B✝
⊢ IsDefEq env' U Γ✝ (lam A✝ body✝) (lam A'✝ body'✝) (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 : IsDefEq env' U Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U (A✝ :: Γ✝) body✝ body'✝ B✝
⊢ IsDefEq env' U Γ✝ (lam A✝ body✝) (lam A'✝ body'✝) (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .forallEDF ih1 ih2 | case forallEDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 : IsDefEq env' U Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
⊢ IsDefEq env' U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 : IsDefEq env' U Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
⊢ IsDefEq env' U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .defeqDF ih1 ih2 | case defeqDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 : IsDefEq env' U Γ✝ A✝ B✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U Γ✝ e1✝ e2✝ A✝
⊢ IsDefEq env' U Γ✝ e1✝ e2✝ B✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 : IsDefEq env' U Γ✝ A✝ B✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U Γ✝ e1✝ e2✝ A✝
⊢ IsDefEq env' U Γ✝ e1✝ e2✝ B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .beta ih1 ih2 | case beta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : IsDefEq env' U (A✝ :: Γ✝) e✝ e✝ B✝
ih2 : IsDefEq env' U Γ✝ e'✝ e'✝ A✝
⊢ IsDefEq env' U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : IsDefEq env' U (A✝ :: Γ✝) e✝ e✝ B✝
ih2 : IsDefEq env' U Γ✝ e'✝ e'✝ A✝
⊢ IsDefEq env' U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .eta ih | case eta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : IsDefEq env' U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
⊢ IsDefEq env' U Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : IsDefEq env' U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
⊢ IsDefEq env' U Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .proofIrrel ih1 ih2 ih3 | case proofIrrel
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
ih1 : IsDefEq env' U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
ih2 : IsDefEq env' U Γ✝ h✝ h✝ p✝
ih3 : IsDefEq env' U Γ✝ h'✝ h'✝ p✝
⊢ IsDefEq env' U Γ✝ h✝ h'✝ p✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
ih1 : IsDefEq env' U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
ih2 : IsDefEq env' U Γ✝ h✝ h✝ p✝
ih3 : IsDefEq env' U Γ✝ h'✝ h'✝ p✝
⊢ IsDefEq env' U Γ✝ h✝ h'✝ p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.mono | [375, 1] | [389, 55] | exact .extra (henv.2 _ h1) h2 h3 | case extra
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
⊢ IsDefEq env' U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
⊢ IsDefEq env' U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | cases h | case empty
env : VEnv
n : Name
ci : VConstant
h : ∅.constants n = some (some ci)
⊢ VConstant.WF ∅ ci | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
env : VEnv
n : Name
ci : VConstant
h : ∅.constants n = some (some ci)
⊢ VConstant.WF ∅ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | refine .mono (addConst_le h3) ?_ | case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env'✝ ci | case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env'✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | unfold addConst at h3 | case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci | case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 :
(match env✝.constants n✝ with
| some val => none
| none => some { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }) =
some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | split at h3 <;> cases h3 | case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 :
(match env✝.constants n✝ with
| some val => none
| none => some { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }) =
some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci | case const.h_2.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h :
{ constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }.constants n =
some (some ci)
⊢ VConstant.WF env✝ ci | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 :
(match env✝.constants n✝ with
| some val => none
| none => some { constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }) =
some env'✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : env'✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | simp at h | case const.h_2.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h :
{ constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }.constants n =
some (some ci)
⊢ VConstant.WF env✝ ci | case const.h_2.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h : (if n✝ = n then some oci✝ else env✝.constants n) = some (some ci)
⊢ VConstant.WF env✝ ci | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h :
{ constants := fun n => if n✝ = n then some oci✝ else env✝.constants n, defeqs := env✝.defeqs }.constants n =
some (some ci)
⊢ VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | split at h | case const.h_2.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h : (if n✝ = n then some oci✝ else env✝.constants n) = some (some ci)
⊢ VConstant.WF env✝ ci | case const.h_2.refl.inl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h✝ : n✝ = n
h : some oci✝ = some (some ci)
⊢ VConstant.WF env✝ ci
case const.h_2.refl.inr
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h✝ : ¬n✝ = n
h : env✝.constants n = some (some ci)
⊢ VConstant.WF env✝ ci | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h : (if n✝ = n then some oci✝ else env✝.constants n) = some (some ci)
⊢ VConstant.WF env✝ ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | cases h | case const.h_2.refl.inl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h✝ : n✝ = n
h : some oci✝ = some (some ci)
⊢ VConstant.WF env✝ ci | case const.h_2.refl.inl.refl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
n✝ : Name
a✝ : Ordered env✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h✝ : n✝ = n
h2 : ∀ (ci_1 : VConstant), some ci = some ci_1 → VConstant.WF env✝ ci_1
⊢ VConstant.WF env✝ ci | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl.inl
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝ : Ordered env✝
h2 : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
x✝ : Option (Option VConstant)
heq✝ : env✝.constants n✝ = none
h✝ : n✝ = n
h : some oci✝ = some (some ci)
⊢ VConstant.WF env✝ ci
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.