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.VEnv.Ordered.constWF | [408, 1] | [417, 51] | exact h2 _ rfl | 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 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | exact ih h | 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 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.constWF | [408, 1] | [417, 51] | exact .mono addDefEq_le (ih h) | case defeq
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : (addDefEq env✝ df✝).constants n = some (some ci)
⊢ VConstant.WF (addDefEq env✝ df✝) ci | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
n : Name
ci : VConstant
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.constants n = some (some ci) → VConstant.WF env✝ ci
h : (addDefEq env✝ df✝).constants n = some (some ci)
⊢ VConstant.WF (addDefEq env✝ df✝) ci
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | cases h | case empty
env : VEnv
df : VDefEq
h : ∅.defeqs df
⊢ VDefEq.WF ∅ df | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
env : VEnv
df : VDefEq
h : ∅.defeqs df
⊢ VDefEq.WF ∅ df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | refine .mono (addConst_le h3) (ih ?_) | case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ VDefEq.WF env'✝ df | case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ env✝.defeqs df | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ VDefEq.WF env'✝ df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | unfold addConst at h3 | case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ env✝.defeqs df | case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (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✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ env✝.defeqs df | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
h3 : addConst env✝ n✝ oci✝ = some env'✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ env✝.defeqs df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | split at h3 <;> cases h3 | case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (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✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ env✝.defeqs df | case const.h_2.refl
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.defeqs df → VDefEq.WF env✝ df
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 }.defeqs df
⊢ env✝.defeqs df | Please generate a tactic in lean4 to solve the state.
STATE:
case const
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
env'✝ : VEnv
a✝¹ : Ordered env✝
a✝ : ∀ (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✝.defeqs df → VDefEq.WF env✝ df
h : env'✝.defeqs df
⊢ env✝.defeqs df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | exact h | case const.h_2.refl
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.defeqs df → VDefEq.WF env✝ df
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 }.defeqs df
⊢ env✝.defeqs df | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case const.h_2.refl
env : VEnv
df : VDefEq
env✝ : VEnv
oci✝ : Option VConstant
n✝ : Name
a✝¹ : Ordered env✝
a✝ : ∀ (ci : VConstant), oci✝ = some ci → VConstant.WF env✝ ci
ih : env✝.defeqs df → VDefEq.WF env✝ df
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 }.defeqs df
⊢ env✝.defeqs df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | refine .mono addDefEq_le ?_ | case defeq
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : (addDefEq env✝ df✝).defeqs df
⊢ VDefEq.WF (addDefEq env✝ df✝) df | case defeq
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : (addDefEq env✝ df✝).defeqs df
⊢ VDefEq.WF env✝ df | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : (addDefEq env✝ df✝).defeqs df
⊢ VDefEq.WF (addDefEq env✝ df✝) df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | obtain rfl | h := h | case defeq
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : (addDefEq env✝ df✝).defeqs df
⊢ VDefEq.WF env✝ df | case defeq.inl
env : VEnv
df : VDefEq
env✝ : VEnv
a✝¹ : Ordered env✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
a✝ : VDefEq.WF env✝ df
⊢ VDefEq.WF env✝ df
case defeq.inr
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env✝.defeqs df
⊢ VDefEq.WF env✝ df | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : (addDefEq env✝ df✝).defeqs df
⊢ VDefEq.WF env✝ df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | assumption | case defeq.inl
env : VEnv
df : VDefEq
env✝ : VEnv
a✝¹ : Ordered env✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
a✝ : VDefEq.WF env✝ df
⊢ VDefEq.WF env✝ df | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq.inl
env : VEnv
df : VDefEq
env✝ : VEnv
a✝¹ : Ordered env✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
a✝ : VDefEq.WF env✝ df
⊢ VDefEq.WF env✝ df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.Ordered.defEqWF | [419, 1] | [429, 17] | exact ih h | case defeq.inr
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env✝.defeqs df
⊢ VDefEq.WF env✝ df | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeq.inr
env : VEnv
df : VDefEq
env✝ : VEnv
df✝ : VDefEq
a✝¹ : Ordered env✝
a✝ : VDefEq.WF env✝ df✝
ih : env✝.defeqs df → VDefEq.WF env✝ df
h : env✝.defeqs df
⊢ VDefEq.WF env✝ df
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | induction H with
| bvar h =>
refine ⟨⟨⟩, ⟨⟩, ?_⟩
induction h with
| zero => exact W.2.liftN
| succ _ ih => exact (ih W.1).liftN
| symm _ ih => let ⟨he, he', hA⟩ := ih W; exact ⟨he', he, hA⟩
| trans _ _ ih1 ih2 => let ⟨he1, _, hA⟩ := ih1 W; let ⟨_, he3, _⟩ := ih2 W; exact ⟨he1, he3, hA⟩
| sortDF h1 h2 => exact ⟨h1, h2, h1⟩
| constDF _ h2 h3 => exact ⟨h2, h3, .instL h2⟩
| appDF _ _ ih1 ih2 =>
let ⟨hf, hf', _, hB⟩ := ih1 W; let ⟨ha, ha', _⟩ := ih2 W
exact ⟨⟨hf, ha⟩, ⟨hf', ha'⟩, hB.inst ha⟩
| lamDF _ _ ih1 ih2 =>
let ⟨hA, hA', _⟩ := ih1 W; let ⟨hb, hb', hB⟩ := ih2 ⟨W, hA⟩
exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, hA, hB⟩
| forallEDF _ _ ih1 ih2 =>
let ⟨hA, hA', hu⟩ := ih1 W; let ⟨hb, hb', hv⟩ := ih2 ⟨W, hA⟩
exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, hu, hv⟩
| defeqDF _ _ ih1 ih2 => let ⟨_, hB, _⟩ := ih1 W; let ⟨he1, he2, _⟩ := ih2 W; exact ⟨he1, he2, hB⟩
| beta _ _ ih1 ih2 =>
let ⟨he', _, hA⟩ := ih2 W; let ⟨he, _, hB⟩ := ih1 ⟨W, hA⟩
exact ⟨⟨⟨hA, he⟩, he'⟩, he.inst he', hB.inst he'⟩
| eta _ ih => let ⟨he, _, hA, hB⟩ := ih W; exact ⟨⟨hA, he.liftN, ⟨⟩⟩, he, hA, hB⟩
| proofIrrel _ _ _ _ ih2 ih3 =>
let ⟨hh, _, hp⟩ := ih2 W; let ⟨hh', _, _⟩ := ih3 W
exact ⟨hh, hh', hp⟩
| extra _ h2 => exact ⟨.instL h2, .instL h2, .instL h2⟩ | env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
W : OnCtx Γ fun x A => LevelWF U A
⊢ LevelWF U e1 ∧ LevelWF U e2 ∧ LevelWF U A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
W : OnCtx Γ fun x A => LevelWF U A
⊢ LevelWF U e1 ∧ LevelWF U e2 ∧ LevelWF U A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | refine ⟨⟨⟩, ⟨⟩, ?_⟩ | case bvar
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.bvar i✝) ∧ LevelWF U (VExpr.bvar i✝) ∧ LevelWF U A✝ | case bvar
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.bvar i✝) ∧ LevelWF U (VExpr.bvar i✝) ∧ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | induction h with
| zero => exact W.2.liftN
| succ _ ih => exact (ih W.1).liftN | case bvar
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact W.2.liftN | case bvar.zero
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
i✝ : Nat
A✝ ty✝ : VExpr
Γ✝ : List VExpr
W : OnCtx (ty✝ :: Γ✝) fun x A => LevelWF U A
⊢ LevelWF U (lift ty✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
i✝ : Nat
A✝ ty✝ : VExpr
Γ✝ : List VExpr
W : OnCtx (ty✝ :: Γ✝) fun x A => LevelWF U A
⊢ LevelWF U (lift ty✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact (ih W.1).liftN | case bvar.succ
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
i✝ : Nat
A✝¹ : VExpr
Γ✝ : List VExpr
n✝ : Nat
ty✝ A✝ : VExpr
a✝ : Lookup Γ✝ n✝ ty✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U ty✝
W : OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A
⊢ LevelWF U (lift ty✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.succ
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝¹ : List VExpr
i✝ : Nat
A✝¹ : VExpr
Γ✝ : List VExpr
n✝ : Nat
ty✝ A✝ : VExpr
a✝ : Lookup Γ✝ n✝ ty✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U ty✝
W : OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A
⊢ LevelWF U (lift ty✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨he, he', hA⟩ := ih W | case symm
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U e'✝ ∧ LevelWF U e✝ ∧ LevelWF U A✝ | case symm
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he : LevelWF U e✝
he' : LevelWF U e'✝
hA : LevelWF U A✝
⊢ LevelWF U e'✝ ∧ LevelWF U e✝ ∧ LevelWF U A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U e'✝ ∧ LevelWF U e✝ ∧ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨he', he, hA⟩ | case symm
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he : LevelWF U e✝
he' : LevelWF U e'✝
hA : LevelWF U A✝
⊢ LevelWF U e'✝ ∧ LevelWF U e✝ ∧ LevelWF U A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he : LevelWF U e✝
he' : LevelWF U e'✝
hA : LevelWF U A✝
⊢ LevelWF U e'✝ ∧ LevelWF U e✝ ∧ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨he1, _, hA⟩ := ih1 W | case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝ | case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he1 : LevelWF U e₁✝
left✝ : LevelWF U e₂✝
hA : LevelWF U A✝
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨_, he3, _⟩ := ih2 W | case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he1 : LevelWF U e₁✝
left✝ : LevelWF U e₂✝
hA : LevelWF U A✝
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝ | case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he1 : LevelWF U e₁✝
left✝¹ : LevelWF U e₂✝
hA : LevelWF U A✝
left✝ : LevelWF U e₂✝
he3 : LevelWF U e₃✝
right✝ : LevelWF U A✝
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he1 : LevelWF U e₁✝
left✝ : LevelWF U e₂✝
hA : LevelWF U A✝
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨he1, he3, hA⟩ | case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he1 : LevelWF U e₁✝
left✝¹ : LevelWF U e₂✝
hA : LevelWF U A✝
left✝ : LevelWF U e₂✝
he3 : LevelWF U e₃✝
right✝ : LevelWF U A✝
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₁✝ ∧ LevelWF U e₂✝ ∧ LevelWF U A✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e₂✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he1 : LevelWF U e₁✝
left✝¹ : LevelWF U e₂✝
hA : LevelWF U A✝
left✝ : LevelWF U e₂✝
he3 : LevelWF U e₃✝
right✝ : LevelWF U A✝
⊢ LevelWF U e₁✝ ∧ LevelWF U e₃✝ ∧ LevelWF U A✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨h1, h2, h1⟩ | case sortDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.sort l✝) ∧ LevelWF U (VExpr.sort l'✝) ∧ LevelWF U (VExpr.sort (VLevel.succ l✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
a✝ : l✝ ≈ l'✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.sort l✝) ∧ LevelWF U (VExpr.sort l'✝) ∧ LevelWF U (VExpr.sort (VLevel.succ l✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨h2, h3, .instL h2⟩ | case constDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
a✝² : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (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'✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.const c✝ ls✝) ∧ LevelWF U (VExpr.const c✝ ls'✝) ∧ LevelWF U (instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
a✝² : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (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'✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.const c✝ ls✝) ∧ LevelWF U (VExpr.const c✝ ls'✝) ∧ LevelWF U (instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hf, hf', _, hB⟩ := ih1 W | case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²) | case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hf : LevelWF U f✝
hf' : LevelWF U f'✝
left✝ : LevelWF U A✝
hB : LevelWF U B✝
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨ha, ha', _⟩ := ih2 W | case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hf : LevelWF U f✝
hf' : LevelWF U f'✝
left✝ : LevelWF U A✝
hB : LevelWF U B✝
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²) | case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hf : LevelWF U f✝
hf' : LevelWF U f'✝
left✝ : LevelWF U A✝
hB : LevelWF U B✝
ha : LevelWF U a✝²
ha' : LevelWF U a'✝
right✝ : LevelWF U A✝
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²) | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hf : LevelWF U f✝
hf' : LevelWF U f'✝
left✝ : LevelWF U A✝
hB : LevelWF U B✝
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨⟨hf, ha⟩, ⟨hf', ha'⟩, hB.inst ha⟩ | case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hf : LevelWF U f✝
hf' : LevelWF U f'✝
left✝ : LevelWF U A✝
hB : LevelWF U B✝
ha : LevelWF U a✝²
ha' : LevelWF U a'✝
right✝ : LevelWF U A✝
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U f✝ ∧ LevelWF U f'✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U a✝² ∧ LevelWF U a'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hf : LevelWF U f✝
hf' : LevelWF U f'✝
left✝ : LevelWF U A✝
hB : LevelWF U B✝
ha : LevelWF U a✝²
ha' : LevelWF U a'✝
right✝ : LevelWF U A✝
⊢ LevelWF U (app f✝ a✝²) ∧ LevelWF U (app f'✝ a'✝) ∧ LevelWF U (inst B✝ a✝²)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hA, hA', _⟩ := ih1 W | case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝) | case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
right✝ : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hb, hb', hB⟩ := ih2 ⟨W, hA⟩ | case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
right✝ : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝) | case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
right✝ : LevelWF U (VExpr.sort u✝)
hb : LevelWF U body✝
hb' : LevelWF U body'✝
hB : LevelWF U B✝
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
right✝ : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, hA, hB⟩ | case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
right✝ : LevelWF U (VExpr.sort u✝)
hb : LevelWF U body✝
hb' : LevelWF U body'✝
hB : LevelWF U B✝
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U B✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
right✝ : LevelWF U (VExpr.sort u✝)
hb : LevelWF U body✝
hb' : LevelWF U body'✝
hB : LevelWF U B✝
⊢ LevelWF U (lam A✝ body✝) ∧ LevelWF U (lam A'✝ body'✝) ∧ LevelWF U (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hA, hA', hu⟩ := ih1 W | case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝)) | case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
hu : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hb, hb', hv⟩ := ih2 ⟨W, hA⟩ | case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
hu : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝)) | case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
hu : LevelWF U (VExpr.sort u✝)
hb : LevelWF U body✝
hb' : LevelWF U body'✝
hv : LevelWF U (VExpr.sort v✝)
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝)) | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
hu : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨⟨hA, hb⟩, ⟨hA', hb'⟩, hu, hv⟩ | case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
hu : LevelWF U (VExpr.sort u✝)
hb : LevelWF U body✝
hb' : LevelWF U body'✝
hv : LevelWF U (VExpr.sort v✝)
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U A'✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U body✝ ∧ LevelWF U body'✝ ∧ LevelWF U (VExpr.sort v✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
hA : LevelWF U A✝
hA' : LevelWF U A'✝
hu : LevelWF U (VExpr.sort u✝)
hb : LevelWF U body✝
hb' : LevelWF U body'✝
hv : LevelWF U (VExpr.sort v✝)
⊢ LevelWF U (VExpr.forallE A✝ body✝) ∧ LevelWF U (VExpr.forallE A'✝ body'✝) ∧ LevelWF U (VExpr.sort (VLevel.imax u✝ v✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨_, hB, _⟩ := ih1 W | case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝ | case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
left✝ : LevelWF U A✝
hB : LevelWF U B✝
right✝ : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨he1, he2, _⟩ := ih2 W | case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
left✝ : LevelWF U A✝
hB : LevelWF U B✝
right✝ : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝ | case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
left✝ : LevelWF U A✝
hB : LevelWF U B✝
right✝¹ : LevelWF U (VExpr.sort u✝)
he1 : LevelWF U e1✝
he2 : LevelWF U e2✝
right✝ : LevelWF U A✝
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
left✝ : LevelWF U A✝
hB : LevelWF U B✝
right✝ : LevelWF U (VExpr.sort u✝)
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨he1, he2, hB⟩ | case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
left✝ : LevelWF U A✝
hB : LevelWF U B✝
right✝¹ : LevelWF U (VExpr.sort u✝)
he1 : LevelWF U e1✝
he2 : LevelWF U e2✝
right✝ : LevelWF U A✝
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U A✝ ∧ LevelWF U B✝ ∧ LevelWF U (VExpr.sort u✝)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
left✝ : LevelWF U A✝
hB : LevelWF U B✝
right✝¹ : LevelWF U (VExpr.sort u✝)
he1 : LevelWF U e1✝
he2 : LevelWF U e2✝
right✝ : LevelWF U A✝
⊢ LevelWF U e1✝ ∧ LevelWF U e2✝ ∧ LevelWF U B✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨he', _, hA⟩ := ih2 W | case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝) | case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he' left✝ : LevelWF U e'✝
hA : LevelWF U A✝
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨he, _, hB⟩ := ih1 ⟨W, hA⟩ | case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he' left✝ : LevelWF U e'✝
hA : LevelWF U A✝
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝) | case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he' left✝¹ : LevelWF U e'✝
hA : LevelWF U A✝
he left✝ : LevelWF U e✝
hB : LevelWF U B✝
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he' left✝ : LevelWF U e'✝
hA : LevelWF U A✝
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨⟨⟨hA, he⟩, he'⟩, he.inst he', hB.inst he'⟩ | case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he' left✝¹ : LevelWF U e'✝
hA : LevelWF U A✝
he left✝ : LevelWF U e✝
hB : LevelWF U B✝
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
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 : (OnCtx (A✝ :: Γ✝) fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U B✝
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e'✝ ∧ LevelWF U e'✝ ∧ LevelWF U A✝
W : OnCtx Γ✝ fun x A => LevelWF U A
he' left✝¹ : LevelWF U e'✝
hA : LevelWF U A✝
he left✝ : LevelWF U e✝
hB : LevelWF U B✝
⊢ LevelWF U (app (lam A✝ e✝) e'✝) ∧ LevelWF U (inst e✝ e'✝) ∧ LevelWF U (inst B✝ e'✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨he, _, hA, hB⟩ := ih W | case eta
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (lam A✝ (app (lift e✝) (VExpr.bvar 0))) ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝) | case eta
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
he left✝ : LevelWF U e✝
hA : LevelWF U A✝
hB : LevelWF U B✝
⊢ LevelWF U (lam A✝ (app (lift e✝) (VExpr.bvar 0))) ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (lam A✝ (app (lift e✝) (VExpr.bvar 0))) ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨⟨hA, he.liftN, ⟨⟩⟩, he, hA, hB⟩ | case eta
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
he left✝ : LevelWF U e✝
hA : LevelWF U A✝
hB : LevelWF U B✝
⊢ LevelWF U (lam A✝ (app (lift e✝) (VExpr.bvar 0))) ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
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 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U e✝ ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
W : OnCtx Γ✝ fun x A => LevelWF U A
he left✝ : LevelWF U e✝
hA : LevelWF U A✝
hB : LevelWF U B✝
⊢ LevelWF U (lam A✝ (app (lift e✝) (VExpr.bvar 0))) ∧ LevelWF U e✝ ∧ LevelWF U (VExpr.forallE A✝ B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hh, _, hp⟩ := ih2 W | case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝ | case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hh left✝ : LevelWF U h✝
hp : LevelWF U p✝
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | let ⟨hh', _, _⟩ := ih3 W | case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hh left✝ : LevelWF U h✝
hp : LevelWF U p✝
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝ | case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hh left✝¹ : LevelWF U h✝
hp : LevelWF U p✝
hh' left✝ : LevelWF U h'✝
right✝ : LevelWF U p✝
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hh left✝ : LevelWF U h✝
hp : LevelWF U p✝
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨hh, hh', hp⟩ | case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hh left✝¹ : LevelWF U h✝
hp : LevelWF U p✝
hh' left✝ : LevelWF U h'✝
right✝ : LevelWF U p✝
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
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✝ : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U p✝ ∧ LevelWF U p✝ ∧ LevelWF U (VExpr.sort VLevel.zero)
ih2 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h✝ ∧ LevelWF U h✝ ∧ LevelWF U p✝
ih3 : (OnCtx Γ✝ fun x A => LevelWF U A) → LevelWF U h'✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
W : OnCtx Γ✝ fun x A => LevelWF U A
hh left✝¹ : LevelWF U h✝
hp : LevelWF U p✝
hh' left✝ : LevelWF U h'✝
right✝ : LevelWF U p✝
⊢ LevelWF U h✝ ∧ LevelWF U h'✝ ∧ LevelWF U p✝
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.levelWF | [438, 1] | [467, 58] | exact ⟨.instL h2, .instL h2, .instL h2⟩ | case extra
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
a✝¹ : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (instL ls✝ df✝.lhs) ∧ LevelWF U (instL ls✝ df✝.rhs) ∧ LevelWF U (instL ls✝ df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
a✝¹ : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
a✝ : List.length ls✝ = df✝.uvars
W : OnCtx Γ✝ fun x A => LevelWF U A
⊢ LevelWF U (instL ls✝ df✝.lhs) ∧ LevelWF U (instL ls✝ df✝.rhs) ∧ LevelWF U (instL ls✝ df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | induction H generalizing k Γ' with
| bvar h => refine .bvar (h.weakN W)
| symm _ ih => exact .symm (ih W)
| trans _ _ ih1 ih2 => exact .trans (ih1 W) (ih2 W)
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 =>
rw [(henv.closedC h1).instL.liftN_eq (Nat.zero_le _)]
exact .constDF h1 h2 h3 h4 h5
| appDF _ _ ih1 ih2 => exact liftN_inst_hi .. ▸ .appDF (ih1 W) (ih2 W)
| lamDF _ _ ih1 ih2 => exact .lamDF (ih1 W) (ih2 W.succ)
| forallEDF _ _ ih1 ih2 => exact .forallEDF (ih1 W) (ih2 W.succ)
| defeqDF _ _ ih1 ih2 => exact .defeqDF (ih1 W) (ih2 W)
| beta _ _ ih1 ih2 =>
exact VExpr.liftN_inst_hi .. ▸ VExpr.liftN_instN_hi .. ▸ .beta (ih1 W.succ) (ih2 W)
| eta _ ih =>
have := IsDefEq.eta (ih W)
simp [liftN]; rwa [← lift_liftN']
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel (ih1 W) (ih2 W) (ih3 W)
| extra h1 h2 h3 =>
have ⟨⟨hA1, _⟩, hA2, hA3⟩ := henv.closed.2 h1
rw [
hA1.instL.liftN_eq (Nat.zero_le _),
hA2.instL.liftN_eq (Nat.zero_le _),
hA3.instL.liftN_eq (Nat.zero_le _)]
exact .extra h1 h2 h3 | env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env U Γ' (liftN n e1 k) (liftN n e2 k) (liftN n A k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
n k : Nat
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.LiftN n k Γ Γ'
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env U Γ' (liftN n e1 k) (liftN n e2 k) (liftN n A k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | refine .bvar (h.weakN W) | case bvar
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.bvar i✝) k) (liftN n (VExpr.bvar i✝) k) (liftN n A✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.bvar i✝) k) (liftN n (VExpr.bvar i✝) k) (liftN n A✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .symm (ih W) | case symm
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e'✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n e'✝ k) (liftN n e✝ k) (liftN n A✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e'✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n e'✝ k) (liftN n e✝ k) (liftN n A✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .trans (ih1 W) (ih2 W) | case trans
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e₁✝ k) (liftN n e₂✝ k) (liftN n A✝ k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e₂✝ k) (liftN n e₃✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n e₁✝ k) (liftN n e₃✝ k) (liftN n A✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e₁✝ k) (liftN n e₂✝ k) (liftN n A✝ k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e₂✝ k) (liftN n e₃✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n e₁✝ k) (liftN n e₃✝ k) (liftN n A✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .sortDF h1 h2 h3 | case sortDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.sort l✝) k) (liftN n (VExpr.sort l'✝) k) (liftN n (VExpr.sort (VLevel.succ l✝)) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.sort l✝) k) (liftN n (VExpr.sort l'✝) k) (liftN n (VExpr.sort (VLevel.succ l✝)) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | rw [(henv.closedC h1).instL.liftN_eq (Nat.zero_le _)] | case constDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls'✝) k) (liftN n (instL ls✝ ci✝.type) k) | case constDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls'✝) k) (instL ls✝ ci✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls'✝) k) (liftN n (instL ls✝ ci✝.type) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .constDF h1 h2 h3 h4 h5 | case constDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls'✝) k) (instL ls✝ ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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'✝
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.const c✝ ls✝) k) (liftN n (VExpr.const c✝ ls'✝) k) (instL ls✝ ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact liftN_inst_hi .. ▸ .appDF (ih1 W) (ih2 W) | case appDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n f✝ k) (liftN n f'✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n a✝² k) (liftN n a'✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (app f✝ a✝²) k) (liftN n (app f'✝ a'✝) k) (liftN n (inst B✝ a✝²) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n f✝ k) (liftN n f'✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n a✝² k) (liftN n a'✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (app f✝ a✝²) k) (liftN n (app f'✝ a'✝) k) (liftN n (inst B✝ a✝²) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .lamDF (ih1 W) (ih2 W.succ) | case lamDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n A✝ k) (liftN n A'✝ k) (liftN n (VExpr.sort u✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k (A✝ :: Γ✝) Γ' → IsDefEq env U Γ' (liftN n body✝ k) (liftN n body'✝ k) (liftN n B✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (lam A✝ body✝) k) (liftN n (lam A'✝ body'✝) k) (liftN n (VExpr.forallE A✝ B✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n A✝ k) (liftN n A'✝ k) (liftN n (VExpr.sort u✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k (A✝ :: Γ✝) Γ' → IsDefEq env U Γ' (liftN n body✝ k) (liftN n body'✝ k) (liftN n B✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (lam A✝ body✝) k) (liftN n (lam A'✝ body'✝) k) (liftN n (VExpr.forallE A✝ B✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .forallEDF (ih1 W) (ih2 W.succ) | case forallEDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n A✝ k) (liftN n A'✝ k) (liftN n (VExpr.sort u✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k (A✝ :: Γ✝) Γ' → IsDefEq env U Γ' (liftN n body✝ k) (liftN n body'✝ k) (liftN n (VExpr.sort v✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.forallE A✝ body✝) k) (liftN n (VExpr.forallE A'✝ body'✝) k)
(liftN n (VExpr.sort (VLevel.imax u✝ v✝)) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n A✝ k) (liftN n A'✝ k) (liftN n (VExpr.sort u✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k (A✝ :: Γ✝) Γ' → IsDefEq env U Γ' (liftN n body✝ k) (liftN n body'✝ k) (liftN n (VExpr.sort v✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (VExpr.forallE A✝ body✝) k) (liftN n (VExpr.forallE A'✝ body'✝) k)
(liftN n (VExpr.sort (VLevel.imax u✝ v✝)) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .defeqDF (ih1 W) (ih2 W) | case defeqDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n A✝ k) (liftN n B✝ k) (liftN n (VExpr.sort u✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e1✝ k) (liftN n e2✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n e1✝ k) (liftN n e2✝ k) (liftN n B✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n A✝ k) (liftN n B✝ k) (liftN n (VExpr.sort u✝) k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e1✝ k) (liftN n e2✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n e1✝ k) (liftN n e2✝ k) (liftN n B✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact VExpr.liftN_inst_hi .. ▸ VExpr.liftN_instN_hi .. ▸ .beta (ih1 W.succ) (ih2 W) | case beta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k (A✝ :: Γ✝) Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n B✝ k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e'✝ k) (liftN n e'✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (app (lam A✝ e✝) e'✝) k) (liftN n (inst e✝ e'✝) k) (liftN n (inst B✝ e'✝) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k (A✝ :: Γ✝) Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n B✝ k)
ih2 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e'✝ k) (liftN n e'✝ k) (liftN n A✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (app (lam A✝ e✝) e'✝) k) (liftN n (inst e✝ e'✝) k) (liftN n (inst B✝ e'✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | have := IsDefEq.eta (ih W) | case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (lam A✝ (app (lift e✝) (VExpr.bvar 0))) k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k) | case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
this :
IsDefEq env U Γ' (lam (liftN n A✝ k) (app (lift (liftN n e✝ k)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
⊢ IsDefEq env U Γ' (liftN n (lam A✝ (app (lift e✝) (VExpr.bvar 0))) k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (lam A✝ (app (lift e✝) (VExpr.bvar 0))) k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | simp [liftN] | case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
this :
IsDefEq env U Γ' (lam (liftN n A✝ k) (app (lift (liftN n e✝ k)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
⊢ IsDefEq env U Γ' (liftN n (lam A✝ (app (lift e✝) (VExpr.bvar 0))) k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k) | case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
this :
IsDefEq env U Γ' (lam (liftN n A✝ k) (app (lift (liftN n e✝ k)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
⊢ IsDefEq env U Γ' (lam (liftN n A✝ k) (app (liftN n (lift e✝) (k + 1)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
this :
IsDefEq env U Γ' (lam (liftN n A✝ k) (app (lift (liftN n e✝ k)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
⊢ IsDefEq env U Γ' (liftN n (lam A✝ (app (lift e✝) (VExpr.bvar 0))) k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | rwa [← lift_liftN'] | case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
this :
IsDefEq env U Γ' (lam (liftN n A✝ k) (app (lift (liftN n e✝ k)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
⊢ IsDefEq env U Γ' (lam (liftN n A✝ k) (app (liftN n (lift e✝) (k + 1)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n e✝ k) (liftN n e✝ k) (liftN n (VExpr.forallE A✝ B✝) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
this :
IsDefEq env U Γ' (lam (liftN n A✝ k) (app (lift (liftN n e✝ k)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
⊢ IsDefEq env U Γ' (lam (liftN n A✝ k) (app (liftN n (lift e✝) (k + 1)) (VExpr.bvar 0))) (liftN n e✝ k)
(VExpr.forallE (liftN n A✝ k) (liftN n B✝ (k + 1)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .proofIrrel (ih1 W) (ih2 W) (ih3 W) | case proofIrrel
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n p✝ k) (liftN n p✝ k) (liftN n (VExpr.sort VLevel.zero) k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n h✝ k) (liftN n h✝ k) (liftN n p✝ k)
ih3 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n h'✝ k) (liftN n h'✝ k) (liftN n p✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n h✝ k) (liftN n h'✝ k) (liftN n p✝ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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 :
∀ {k : Nat} {Γ' : List VExpr},
Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n p✝ k) (liftN n p✝ k) (liftN n (VExpr.sort VLevel.zero) k)
ih2 : ∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n h✝ k) (liftN n h✝ k) (liftN n p✝ k)
ih3 :
∀ {k : Nat} {Γ' : List VExpr}, Ctx.LiftN n k Γ✝ Γ' → IsDefEq env U Γ' (liftN n h'✝ k) (liftN n h'✝ k) (liftN n p✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n h✝ k) (liftN n h'✝ k) (liftN n p✝ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | have ⟨⟨hA1, _⟩, hA2, hA3⟩ := henv.closed.2 h1 | case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (instL ls✝ df✝.lhs) k) (liftN n (instL ls✝ df✝.rhs) k) (liftN n (instL ls✝ df✝.type) k) | case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ' (liftN n (instL ls✝ df✝.lhs) k) (liftN n (instL ls✝ df✝.rhs) k) (liftN n (instL ls✝ df✝.type) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEq env U Γ' (liftN n (instL ls✝ df✝.lhs) k) (liftN n (instL ls✝ df✝.rhs) k) (liftN n (instL ls✝ df✝.type) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | rw [
hA1.instL.liftN_eq (Nat.zero_le _),
hA2.instL.liftN_eq (Nat.zero_le _),
hA3.instL.liftN_eq (Nat.zero_le _)] | case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ' (liftN n (instL ls✝ df✝.lhs) k) (liftN n (instL ls✝ df✝.rhs) k) (liftN n (instL ls✝ df✝.type) k) | case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ' (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ IsDefEq env U Γ' (liftN n (instL ls✝ df✝.lhs) k) (liftN n (instL ls✝ df✝.rhs) k) (liftN n (instL ls✝ df✝.type) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakN | [470, 1] | [496, 26] | exact .extra h1 h2 h3 | case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ 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 : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
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
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
hA1 : ClosedN df✝.lhs
right✝ : ClosedN df✝.type
hA2 : ClosedN df✝.rhs
hA3 : ClosedN df✝.type
⊢ 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.IsDefEq.weakR | [511, 1] | [514, 82] | have ⟨h1, h2, h3⟩ := H.closedN' henv.closed hΓ | env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
hΓ : CtxClosed Γ
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
⊢ IsDefEq env U (Γ ++ Γ') e1 e2 A | env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
hΓ : CtxClosed Γ
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
h1 : ClosedN e1 (List.length Γ)
h2 : ClosedN e2 (List.length Γ)
h3 : ClosedN A (List.length Γ)
⊢ IsDefEq env U (Γ ++ Γ') e1 e2 A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
hΓ : CtxClosed Γ
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
⊢ IsDefEq env U (Γ ++ Γ') e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weakR | [511, 1] | [514, 82] | simpa [h1.liftN_eq, h2.liftN_eq, h3.liftN_eq] using H.weakN henv (.right hΓ Γ') | env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
hΓ : CtxClosed Γ
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
h1 : ClosedN e1 (List.length Γ)
h2 : ClosedN e2 (List.length Γ)
h3 : ClosedN A (List.length Γ)
⊢ IsDefEq env U (Γ ++ Γ') e1 e2 A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
hΓ : CtxClosed Γ
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
h1 : ClosedN e1 (List.length Γ)
h2 : ClosedN e2 (List.length Γ)
h3 : ClosedN A (List.length Γ)
⊢ IsDefEq env U (Γ ++ Γ') e1 e2 A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | generalize e : l.depth = n | env : VEnv
henv : Ordered env
l : Lift
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l) | env : VEnv
henv : Ordered env
l : Lift
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
H : IsDefEq env U Γ e1 e2 A
n : Nat
e : Lift.depth l = n
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l) | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
l : Lift
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | induction n generalizing l Γ' with
| zero => simpa [lift'_depth_zero e, W.depth_zero e] using H
| succ n ih =>
obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e
have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip
simp only [Lift.consN_skip_eq, lift'_comp, lift'_consN_skipN]
exact (ih W1 Lift.depth_consN).weakN henv W2 | env : VEnv
henv : Ordered env
l : Lift
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
H : IsDefEq env U Γ e1 e2 A
n : Nat
e : Lift.depth l = n
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
henv : Ordered env
l : Lift
Γ Γ' : List VExpr
U : Nat
e1 e2 A : VExpr
W : Ctx.Lift' l Γ Γ'
H : IsDefEq env U Γ e1 e2 A
n : Nat
e : Lift.depth l = n
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | simpa [lift'_depth_zero e, W.depth_zero e] using H | case zero
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.zero
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | obtain ⟨l, k, rfl, rfl⟩ := Lift.depth_succ e | case succ
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
n : Nat
ih :
∀ {l : Lift} {Γ' : List VExpr},
Ctx.Lift' l Γ Γ' → Lift.depth l = n → IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l)
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l) | case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEq env U Γ' (lift' e1 (Lift.consN (Lift.skip l) k)) (lift' e2 (Lift.consN (Lift.skip l) k))
(lift' A (Lift.consN (Lift.skip l) k)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
n : Nat
ih :
∀ {l : Lift} {Γ' : List VExpr},
Ctx.Lift' l Γ Γ' → Lift.depth l = n → IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l)
l : Lift
Γ' : List VExpr
W : Ctx.Lift' l Γ Γ'
e : Lift.depth l = Nat.succ n
⊢ IsDefEq env U Γ' (lift' e1 l) (lift' e2 l) (lift' A l)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | have ⟨Γ₁, W1, W2⟩ := W.of_cons_skip | case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEq env U Γ' (lift' e1 (Lift.consN (Lift.skip l) k)) (lift' e2 (Lift.consN (Lift.skip l) k))
(lift' A (Lift.consN (Lift.skip l) k)) | case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (lift' e1 (Lift.consN (Lift.skip l) k)) (lift' e2 (Lift.consN (Lift.skip l) k))
(lift' A (Lift.consN (Lift.skip l) k)) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
⊢ IsDefEq env U Γ' (lift' e1 (Lift.consN (Lift.skip l) k)) (lift' e2 (Lift.consN (Lift.skip l) k))
(lift' A (Lift.consN (Lift.skip l) k))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | simp only [Lift.consN_skip_eq, lift'_comp, lift'_consN_skipN] | case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (lift' e1 (Lift.consN (Lift.skip l) k)) (lift' e2 (Lift.consN (Lift.skip l) k))
(lift' A (Lift.consN (Lift.skip l) k)) | case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (liftN 1 (lift' e1 (Lift.consN l k)) k) (liftN 1 (lift' e2 (Lift.consN l k)) k)
(liftN 1 (lift' A (Lift.consN l k)) k) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (lift' e1 (Lift.consN (Lift.skip l) k)) (lift' e2 (Lift.consN (Lift.skip l) k))
(lift' A (Lift.consN (Lift.skip l) k))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.weak' | [524, 1] | [533, 49] | exact (ih W1 Lift.depth_consN).weakN henv W2 | case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (liftN 1 (lift' e1 (Lift.consN l k)) k) (liftN 1 (lift' e2 (Lift.consN l k)) k)
(liftN 1 (lift' A (Lift.consN l k)) k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro.intro.intro
env : VEnv
henv : Ordered env
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
Γ' : List VExpr
l : Lift
k : Nat
ih :
∀ {l_1 : Lift} {Γ' : List VExpr},
Ctx.Lift' l_1 Γ Γ' → Lift.depth l_1 = Lift.depth l → IsDefEq env U Γ' (lift' e1 l_1) (lift' e2 l_1) (lift' A l_1)
W : Ctx.Lift' (Lift.consN (Lift.skip l) k) Γ Γ'
e : Lift.depth (Lift.consN (Lift.skip l) k) = Nat.succ (Lift.depth l)
Γ₁ : List VExpr
W1 : Ctx.Lift' (Lift.consN l k) Γ Γ₁
W2 : Ctx.LiftN 1 k Γ₁ Γ'
⊢ IsDefEq env U Γ' (liftN 1 (lift' e1 (Lift.consN l k)) k) (liftN 1 (lift' e2 (Lift.consN l k)) k)
(liftN 1 (lift' A (Lift.consN l k)) k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | induction H with
| bvar h => refine .bvar h.instL
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| sortDF _ _ h3 =>
exact .sortDF (VLevel.WF.inst hls) (VLevel.WF.inst hls) (VLevel.inst_congr_l h3)
| @constDF _ _ ls₁ ls₂ _ h1 h2 h3 h4 h5 =>
simp [VExpr.instL, VExpr.instL_instL]
exact .constDF h1 (by simp [h2, VLevel.WF.inst hls]) (by simp [h3, VLevel.WF.inst hls])
(by simp [h4]) (by simpa using h5.imp fun _ _ => VLevel.inst_congr_l)
| appDF _ _ ih1 ih2 => exact VExpr.instL_instN ▸ .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 => simpa using .beta ih1 ih2
| eta _ ih => simpa [VExpr.instL] using .eta ih
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 =>
simp [VExpr.instL, VExpr.instL_instL]
exact .extra h1 (by simp [h2, VLevel.WF.inst hls]) (by simp [h3]) | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ) (VExpr.instL ls e1) (VExpr.instL ls e2) (VExpr.instL ls A) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ) (VExpr.instL ls e1) (VExpr.instL ls e2) (VExpr.instL ls A)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | refine .bvar h.instL | case bvar
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.bvar i✝)) (VExpr.instL ls (VExpr.bvar i✝))
(VExpr.instL ls A✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.bvar i✝)) (VExpr.instL ls (VExpr.bvar i✝))
(VExpr.instL ls A✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .symm ih | case symm
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e✝) (VExpr.instL ls e'✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e'✝) (VExpr.instL ls e✝) (VExpr.instL ls A✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case symm
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e✝) (VExpr.instL ls e'✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e'✝) (VExpr.instL ls e✝) (VExpr.instL ls A✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .trans ih1 ih2 | case trans
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e₁✝) (VExpr.instL ls e₂✝) (VExpr.instL ls A✝)
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e₂✝) (VExpr.instL ls e₃✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e₁✝) (VExpr.instL ls e₃✝) (VExpr.instL ls A✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case trans
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e₁✝) (VExpr.instL ls e₂✝) (VExpr.instL ls A✝)
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e₂✝) (VExpr.instL ls e₃✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e₁✝) (VExpr.instL ls e₃✝) (VExpr.instL ls A✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .sortDF (VLevel.WF.inst hls) (VLevel.WF.inst hls) (VLevel.inst_congr_l h3) | case sortDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
a✝¹ : VLevel.WF U l✝
a✝ : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.sort l✝)) (VExpr.instL ls (VExpr.sort l'✝))
(VExpr.instL ls (VExpr.sort (VLevel.succ l✝))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case sortDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
a✝¹ : VLevel.WF U l✝
a✝ : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.sort l✝)) (VExpr.instL ls (VExpr.sort l'✝))
(VExpr.instL ls (VExpr.sort (VLevel.succ l✝)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [VExpr.instL, VExpr.instL_instL] | case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.const c✝ ls₁))
(VExpr.instL ls (VExpr.const c✝ ls₂)) (VExpr.instL ls (VExpr.instL ls₁ ci✝.type)) | case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.const c✝ (List.map (VLevel.inst ls) ls₁))
(VExpr.const c✝ (List.map (VLevel.inst ls) ls₂)) (VExpr.instL (List.map (VLevel.inst ls) ls₁) ci✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.const c✝ ls₁))
(VExpr.instL ls (VExpr.const c✝ ls₂)) (VExpr.instL ls (VExpr.instL ls₁ ci✝.type))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .constDF h1 (by simp [h2, VLevel.WF.inst hls]) (by simp [h3, VLevel.WF.inst hls])
(by simp [h4]) (by simpa using h5.imp fun _ _ => VLevel.inst_congr_l) | case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.const c✝ (List.map (VLevel.inst ls) ls₁))
(VExpr.const c✝ (List.map (VLevel.inst ls) ls₂)) (VExpr.instL (List.map (VLevel.inst ls) ls₁) ci✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case constDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.const c✝ (List.map (VLevel.inst ls) ls₁))
(VExpr.const c✝ (List.map (VLevel.inst ls) ls₂)) (VExpr.instL (List.map (VLevel.inst ls) ls₁) ci✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [h2, VLevel.WF.inst hls] | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ ∀ (l : VLevel), l ∈ List.map (VLevel.inst ls) ls₁ → VLevel.WF U' l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ ∀ (l : VLevel), l ∈ List.map (VLevel.inst ls) ls₁ → VLevel.WF U' l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [h3, VLevel.WF.inst hls] | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ ∀ (l : VLevel), l ∈ List.map (VLevel.inst ls) ls₂ → VLevel.WF U' l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ ∀ (l : VLevel), l ∈ List.map (VLevel.inst ls) ls₂ → VLevel.WF U' l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [h4] | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ List.length (List.map (VLevel.inst ls) ls₁) = ci✝.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ List.length (List.map (VLevel.inst ls) ls₁) = ci✝.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simpa using h5.imp fun _ _ => VLevel.inst_congr_l | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ List.Forall₂ (fun x x_1 => x ≈ x_1) (List.map (VLevel.inst ls) ls₁) (List.map (VLevel.inst ls) ls₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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₂
⊢ List.Forall₂ (fun x x_1 => x ≈ x_1) (List.map (VLevel.inst ls) ls₁) (List.map (VLevel.inst ls) ls₂)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact VExpr.instL_instN ▸ .appDF ih1 ih2 | case appDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls f✝) (VExpr.instL ls f'✝)
(VExpr.instL ls (VExpr.forallE A✝ B✝))
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls a✝²) (VExpr.instL ls a'✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (app f✝ a✝²)) (VExpr.instL ls (app f'✝ a'✝))
(VExpr.instL ls (inst B✝ a✝²)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case appDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls f✝) (VExpr.instL ls f'✝)
(VExpr.instL ls (VExpr.forallE A✝ B✝))
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls a✝²) (VExpr.instL ls a'✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (app f✝ a✝²)) (VExpr.instL ls (app f'✝ a'✝))
(VExpr.instL ls (inst B✝ a✝²))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .lamDF ih1 ih2 | case lamDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls A✝) (VExpr.instL ls A'✝)
(VExpr.instL ls (VExpr.sort u✝))
ih2 :
IsDefEq env U' (List.map (VExpr.instL ls) (A✝ :: Γ✝)) (VExpr.instL ls body✝) (VExpr.instL ls body'✝)
(VExpr.instL ls B✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (lam A✝ body✝)) (VExpr.instL ls (lam A'✝ body'✝))
(VExpr.instL ls (VExpr.forallE A✝ B✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case lamDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls A✝) (VExpr.instL ls A'✝)
(VExpr.instL ls (VExpr.sort u✝))
ih2 :
IsDefEq env U' (List.map (VExpr.instL ls) (A✝ :: Γ✝)) (VExpr.instL ls body✝) (VExpr.instL ls body'✝)
(VExpr.instL ls B✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (lam A✝ body✝)) (VExpr.instL ls (lam A'✝ body'✝))
(VExpr.instL ls (VExpr.forallE A✝ B✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .forallEDF ih1 ih2 | case forallEDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls A✝) (VExpr.instL ls A'✝)
(VExpr.instL ls (VExpr.sort u✝))
ih2 :
IsDefEq env U' (List.map (VExpr.instL ls) (A✝ :: Γ✝)) (VExpr.instL ls body✝) (VExpr.instL ls body'✝)
(VExpr.instL ls (VExpr.sort v✝))
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.forallE A✝ body✝))
(VExpr.instL ls (VExpr.forallE A'✝ body'✝)) (VExpr.instL ls (VExpr.sort (VLevel.imax u✝ v✝))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case forallEDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls A✝) (VExpr.instL ls A'✝)
(VExpr.instL ls (VExpr.sort u✝))
ih2 :
IsDefEq env U' (List.map (VExpr.instL ls) (A✝ :: Γ✝)) (VExpr.instL ls body✝) (VExpr.instL ls body'✝)
(VExpr.instL ls (VExpr.sort v✝))
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.forallE A✝ body✝))
(VExpr.instL ls (VExpr.forallE A'✝ body'✝)) (VExpr.instL ls (VExpr.sort (VLevel.imax u✝ v✝)))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .defeqDF ih1 ih2 | case defeqDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls A✝) (VExpr.instL ls B✝) (VExpr.instL ls (VExpr.sort u✝))
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e1✝) (VExpr.instL ls e2✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e1✝) (VExpr.instL ls e2✝) (VExpr.instL ls B✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case defeqDF
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls A✝) (VExpr.instL ls B✝) (VExpr.instL ls (VExpr.sort u✝))
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e1✝) (VExpr.instL ls e2✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e1✝) (VExpr.instL ls e2✝) (VExpr.instL ls B✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simpa using .beta ih1 ih2 | case beta
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) (A✝ :: Γ✝)) (VExpr.instL ls e✝) (VExpr.instL ls e✝) (VExpr.instL ls B✝)
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e'✝) (VExpr.instL ls e'✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (app (lam A✝ e✝) e'✝)) (VExpr.instL ls (inst e✝ e'✝))
(VExpr.instL ls (inst B✝ e'✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case beta
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) (A✝ :: Γ✝)) (VExpr.instL ls e✝) (VExpr.instL ls e✝) (VExpr.instL ls B✝)
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e'✝) (VExpr.instL ls e'✝) (VExpr.instL ls A✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (app (lam A✝ e✝) e'✝)) (VExpr.instL ls (inst e✝ e'✝))
(VExpr.instL ls (inst B✝ e'✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simpa [VExpr.instL] using .eta ih | case eta
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e✝) (VExpr.instL ls e✝)
(VExpr.instL ls (VExpr.forallE A✝ B✝))
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (lam A✝ (app (lift e✝) (VExpr.bvar 0))))
(VExpr.instL ls e✝) (VExpr.instL ls (VExpr.forallE A✝ B✝)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case eta
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls e✝) (VExpr.instL ls e✝)
(VExpr.instL ls (VExpr.forallE A✝ B✝))
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (lam A✝ (app (lift e✝) (VExpr.bvar 0))))
(VExpr.instL ls e✝) (VExpr.instL ls (VExpr.forallE A✝ B✝))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .proofIrrel ih1 ih2 ih3 | case proofIrrel
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls p✝) (VExpr.instL ls p✝)
(VExpr.instL ls (VExpr.sort VLevel.zero))
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls h✝) (VExpr.instL ls h✝) (VExpr.instL ls p✝)
ih3 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls h'✝) (VExpr.instL ls h'✝) (VExpr.instL ls p✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls h✝) (VExpr.instL ls h'✝) (VExpr.instL ls p✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case proofIrrel
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls p✝) (VExpr.instL ls p✝)
(VExpr.instL ls (VExpr.sort VLevel.zero))
ih2 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls h✝) (VExpr.instL ls h✝) (VExpr.instL ls p✝)
ih3 : IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls h'✝) (VExpr.instL ls h'✝) (VExpr.instL ls p✝)
⊢ IsDefEq env U' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls h✝) (VExpr.instL ls h'✝) (VExpr.instL ls p✝)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [VExpr.instL, VExpr.instL_instL] | case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.instL ls✝ df✝.lhs))
(VExpr.instL ls (VExpr.instL ls✝ df✝.rhs)) (VExpr.instL ls (VExpr.instL ls✝ df✝.type)) | case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.lhs)
(VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.rhs) (VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.type) | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL ls (VExpr.instL ls✝ df✝.lhs))
(VExpr.instL ls (VExpr.instL ls✝ df✝.rhs)) (VExpr.instL ls (VExpr.instL ls✝ df✝.type))
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | exact .extra h1 (by simp [h2, VLevel.WF.inst hls]) (by simp [h3]) | case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.lhs)
(VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.rhs) (VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.type) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case extra
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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' (List.map (VExpr.instL ls) Γ✝) (VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.lhs)
(VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.rhs) (VExpr.instL (List.map (VLevel.inst ls) ls✝) df✝.type)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [h2, VLevel.WF.inst hls] | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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
⊢ ∀ (l : VLevel), l ∈ List.map (VLevel.inst ls) ls✝ → VLevel.WF U' l | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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
⊢ ∀ (l : VLevel), l ∈ List.map (VLevel.inst ls) ls✝ → VLevel.WF U' l
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instL | [539, 1] | [560, 70] | simp [h3] | U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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
⊢ List.length (List.map (VLevel.inst ls) ls✝) = df✝.uvars | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
U' : Nat
env : VEnv
ls : List VLevel
hls : ∀ (l : VLevel), l ∈ ls → VLevel.WF U' l
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
⊢ List.length (List.map (VLevel.inst ls) ls✝) = df✝.uvars
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | induction H generalizing Γ k with
| @bvar _ i ty h =>
dsimp [inst]
induction W generalizing i ty with
| zero =>
cases h with simp [inst_lift]
| zero => exact h₀
| succ h => exact .bvar h
| succ _ ih =>
cases h with (simp; rw [Nat.add_comm, ← VExpr.liftN_instN_lo (hj := Nat.zero_le _)])
| zero => exact .bvar .zero
| succ h => exact (ih h).weak henv
| symm _ ih => exact .symm (ih W)
| trans _ _ ih1 ih2 => exact .trans (ih1 W) (ih2 W)
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 =>
rw [(henv.closedC h1).instL.instN_eq (Nat.zero_le _)]
exact .constDF h1 h2 h3 h4 h5
| appDF _ _ ih1 ih2 => exact VExpr.inst_inst_hi .. ▸ .appDF (ih1 W) (ih2 W)
| lamDF _ _ ih1 ih2 => exact .lamDF (ih1 W) (ih2 W.succ)
| forallEDF _ _ ih1 ih2 => exact .forallEDF (ih1 W) (ih2 W.succ)
| defeqDF _ _ ih1 ih2 => exact .defeqDF (ih1 W) (ih2 W)
| beta _ _ ih1 ih2 =>
exact VExpr.inst_inst_hi .. ▸ VExpr.inst_inst_hi .. ▸ .beta (ih1 W.succ) (ih2 W)
| eta _ ih =>
have := IsDefEq.eta (ih W)
rw [lift, VExpr.liftN_instN_lo (hj := Nat.zero_le _), Nat.add_comm] at this
simpa [inst]
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel (ih1 W) (ih2 W) (ih3 W)
| extra h1 h2 h3 =>
have ⟨⟨hA1, _⟩, hA2, hA3⟩ := henv.closed.2 h1
rw [
hA1.instL.instN_eq (Nat.zero_le _),
hA2.instL.instN_eq (Nat.zero_le _),
hA3.instL.instN_eq (Nat.zero_le _)]
exact .extra h1 h2 h3 | env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
k : Nat
Γ₁ Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ₁ Γ
H : IsDefEq env U Γ₁ e1 e2 A
⊢ IsDefEq env U Γ (inst e1 e₀ k) (inst e2 e₀ k) (inst A e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
k : Nat
Γ₁ Γ : List VExpr
e1 e2 A : VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ₁ Γ
H : IsDefEq env U Γ₁ e1 e2 A
⊢ IsDefEq env U Γ (inst e1 e₀ k) (inst e2 e₀ k) (inst A e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | dsimp [inst] | case bvar
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i : Nat
ty : VExpr
h : Lookup Γ✝ i ty
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.bvar i) e₀ k) (inst (VExpr.bvar i) e₀ k) (inst ty e₀ k) | case bvar
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i : Nat
ty : VExpr
h : Lookup Γ✝ i ty
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (instVar i e₀ k) (instVar i e₀ k) (inst ty e₀ k) | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i : Nat
ty : VExpr
h : Lookup Γ✝ i ty
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (inst (VExpr.bvar i) e₀ k) (inst (VExpr.bvar i) e₀ k) (inst ty e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | induction W generalizing i ty with
| zero =>
cases h with simp [inst_lift]
| zero => exact h₀
| succ h => exact .bvar h
| succ _ ih =>
cases h with (simp; rw [Nat.add_comm, ← VExpr.liftN_instN_lo (hj := Nat.zero_le _)])
| zero => exact .bvar .zero
| succ h => exact (ih h).weak henv | case bvar
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i : Nat
ty : VExpr
h : Lookup Γ✝ i ty
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (instVar i e₀ k) (instVar i e₀ k) (inst ty e₀ k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i : Nat
ty : VExpr
h : Lookup Γ✝ i ty
k : Nat
Γ : List VExpr
W : Ctx.InstN Γ₀ e₀ A₀ k Γ✝ Γ
⊢ IsDefEq env U Γ (instVar i e₀ k) (instVar i e₀ k) (inst ty e₀ k)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | cases h with simp [inst_lift]
| zero => exact h₀
| succ h => exact .bvar h | case bvar.zero
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
i : Nat
ty : VExpr
h : Lookup (A₀ :: Γ₀) i ty
⊢ IsDefEq env U Γ₀ (instVar i e₀) (instVar i e₀) (inst ty e₀) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
i : Nat
ty : VExpr
h : Lookup (A₀ :: Γ₀) i ty
⊢ IsDefEq env U Γ₀ (instVar i e₀) (instVar i e₀) (inst ty e₀)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/Lemmas.lean | Lean4Lean.VEnv.IsDefEq.instN | [569, 1] | [606, 26] | exact h₀ | case bvar.zero.zero
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
⊢ IsDefEq env U Γ₀ e₀ e₀ A₀ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case bvar.zero.zero
env : VEnv
U : Nat
Γ₀ : List VExpr
e₀ A₀ : VExpr
henv : Ordered env
h₀ : HasType env U Γ₀ e₀ A₀
Γ₁ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
k : Nat
Γ : List VExpr
⊢ IsDefEq env U Γ₀ e₀ e₀ A₀
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.