Theorem: Lean4Lean.VEnv.IsDefEq.mono (Lean4Lean/Theory/Typing/Lemmas.lean)

State before:
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEq env U Γ e1 e2 A
⊢ IsDefEq env' U Γ e1 e2 A
Tactic:
induction H with
| bvar h => exact .bvar h
| constDF h1 h2 h3 h4 h5 => exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| appDF _ _ ih1 ih2 => exact .appDF ih1 ih2
| lamDF _ _ ih1 ih2 => exact .lamDF ih1 ih2
| forallEDF _ _ ih1 ih2 => exact .forallEDF ih1 ih2
| defeqDF _ _ ih1 ih2 => exact .defeqDF ih1 ih2
| beta _ _ ih1 ih2 => exact .beta ih1 ih2
| eta _ ih => exact .eta ih
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 => exact .extra (henv.2 _ h1) h2 h3
State after:
no goals

State before:
case bvar
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
h : Lookup Γ✝ i✝ A✝
⊢ IsDefEq env' U Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝) A✝
Tactic:
exact .bvar h
State after:
no goals

State before:
case constDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
Γ✝ : List VExpr
h1 : env.constants c✝ = some (some ci✝)
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : ∀ (l : VLevel), l ∈ ls'✝ → VLevel.WF U l
h4 : List.length ls✝ = ci✝.uvars
h5 : List.Forall₂ (fun x x_1 => x ≈ x_1) ls✝ ls'✝
⊢ IsDefEq env' U Γ✝ (VExpr.const c✝ ls✝) (VExpr.const c✝ ls'✝) (instL ls✝ ci✝.type)
Tactic:
exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5
State after:
no goals

State before:
case sortDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
l✝ l'✝ : VLevel
Γ✝ : List VExpr
h1 : VLevel.WF U l✝
h2 : VLevel.WF U l'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env' U Γ✝ (VExpr.sort l✝) (VExpr.sort l'✝) (VExpr.sort (VLevel.succ l✝))
Tactic:
exact .sortDF h1 h2 h3
State after:
no goals

State before:
case symm
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e'✝ A✝
ih : IsDefEq env' U Γ✝ e✝ e'✝ A✝
⊢ IsDefEq env' U Γ✝ e'✝ e✝ A✝
Tactic:
exact .symm ih
State after:
no goals

State before:
case trans
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEq env U Γ✝ e₂✝ e₃✝ A✝
ih1 : IsDefEq env' U Γ✝ e₁✝ e₂✝ A✝
ih2 : IsDefEq env' U Γ✝ e₂✝ e₃✝ A✝
⊢ IsDefEq env' U Γ✝ e₁✝ e₃✝ A✝
Tactic:
exact .trans ih1 ih2
State after:
no goals

State before:
case appDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
f✝ f'✝ A✝ B✝ a✝² a'✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
a✝ : IsDefEq env U Γ✝ a✝² a'✝ A✝
ih1 : IsDefEq env' U Γ✝ f✝ f'✝ (VExpr.forallE A✝ B✝)
ih2 : IsDefEq env' U Γ✝ a✝² a'✝ A✝
⊢ IsDefEq env' U Γ✝ (app f✝ a✝²) (app f'✝ a'✝) (inst B✝ a✝²)
Tactic:
exact .appDF ih1 ih2
State after:
no goals

State before:
case lamDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ B✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
ih1 : IsDefEq env' U Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U (A✝ :: Γ✝) body✝ body'✝ B✝
⊢ IsDefEq env' U Γ✝ (lam A✝ body✝) (lam A'✝ body'✝) (VExpr.forallE A✝ B✝)
Tactic:
exact .lamDF ih1 ih2
State after:
no goals

State before:
case forallEDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
body✝ body'✝ : VExpr
v✝ : VLevel
a✝¹ : IsDefEq env U Γ✝ A✝ A'✝ (VExpr.sort u✝)
a✝ : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
ih1 : IsDefEq env' U Γ✝ A✝ A'✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U (A✝ :: Γ✝) body✝ body'✝ (VExpr.sort v✝)
⊢ IsDefEq env' U Γ✝ (VExpr.forallE A✝ body✝) (VExpr.forallE A'✝ body'✝) (VExpr.sort (VLevel.imax u✝ v✝))
Tactic:
exact .forallEDF ih1 ih2
State after:
no goals

State before:
case defeqDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝¹ : IsDefEq env U Γ✝ A✝ B✝ (VExpr.sort u✝)
a✝ : IsDefEq env U Γ✝ e1✝ e2✝ A✝
ih1 : IsDefEq env' U Γ✝ A✝ B✝ (VExpr.sort u✝)
ih2 : IsDefEq env' U Γ✝ e1✝ e2✝ A✝
⊢ IsDefEq env' U Γ✝ e1✝ e2✝ B✝
Tactic:
exact .defeqDF ih1 ih2
State after:
no goals

State before:
case beta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A A✝ : VExpr
Γ✝ : List VExpr
e✝ B✝ e'✝ : VExpr
a✝¹ : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝ : IsDefEq env U Γ✝ e'✝ e'✝ A✝
ih1 : IsDefEq env' U (A✝ :: Γ✝) e✝ e✝ B✝
ih2 : IsDefEq env' U Γ✝ e'✝ e'✝ A✝
⊢ IsDefEq env' U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
Tactic:
exact .beta ih1 ih2
State after:
no goals

State before:
case eta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ A✝ B✝ : VExpr
a✝ : IsDefEq env U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
ih : IsDefEq env' U Γ✝ e✝ e✝ (VExpr.forallE A✝ B✝)
⊢ IsDefEq env' U Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (VExpr.forallE A✝ B✝)
Tactic:
exact .eta ih
State after:
no goals

State before:
case proofIrrel
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEq env U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
a✝¹ : IsDefEq env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEq env U Γ✝ h'✝ h'✝ p✝
ih1 : IsDefEq env' U Γ✝ p✝ p✝ (VExpr.sort VLevel.zero)
ih2 : IsDefEq env' U Γ✝ h✝ h✝ p✝
ih3 : IsDefEq env' U Γ✝ h'✝ h'✝ p✝
⊢ IsDefEq env' U Γ✝ h✝ h'✝ p✝
Tactic:
exact .proofIrrel ih1 ih2 ih3
State after:
no goals

State before:
case extra
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
⊢ IsDefEq env' U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
Tactic:
exact .extra (henv.2 _ h1) h2 h3
State after:
no goals