internlm/Lean-Github huggingface dataset:
Theorem: Lean4Lean.VEnv.IsDefEqStrong.weakN
Proof state before:
case eta.refine_2
env : VEnv
henv : Ordered env
n : Nat
Γ✝ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ : List VExpr
a : VExpr
u : VLevel
B : VExpr
v : VLevel
e : VExpr
h1 : VLevel.WF U u
h2 : VLevel.WF U v
a✝⁴ : IsDefEqStrong env U Γ a a (sort u)
a✝³ : IsDefEqStrong env U (a :: Γ) B B (sort v)
a✝² : IsDefEqStrong env U (lift a :: a :: Γ) (liftN 1 B 1) (liftN 1 B 1) (sort v)
a✝¹ : IsDefEqStrong env U Γ e e (forallE a B)
a✝ : IsDefEqStrong env U (a :: Γ) (lift e) (lift e) (forallE (lift a) (liftN 1 B 1))
ih1 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ Γ' → IsDefEqStrong env U Γ' (liftN n a k) (liftN n a k) (liftN n (sort u) k)
ih2 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k (a :: Γ) Γ' → IsDefEqStrong env U Γ' (liftN n B k) (liftN n B k) (liftN n (sort v) k)
ih3 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k (lift a :: a :: Γ) Γ' →
      IsDefEqStrong env U Γ' (liftN n (liftN 1 B 1) k) (liftN n (liftN 1 B 1) k) (liftN n (sort v) k)
ih4 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ Γ' → IsDefEqStrong env U Γ' (liftN n e k) (liftN n e k) (liftN n (forallE a B) k)
ih5✝ :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k (a :: Γ) Γ' →
      IsDefEqStrong env U Γ' (liftN n (lift e) k) (liftN n (lift e) k) (liftN n (forallE (lift a) (liftN 1 B 1)) k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ Γ'
ih5 :
  IsDefEqStrong env U (liftN n a k :: Γ') (liftN n (lift e) (k + 1)) (liftN n (lift e) (k + 1))
    (liftN n (lift (forallE a B)) (k + 1))
⊢ IsDefEqStrong env U (liftN n a k :: Γ') (lift (liftN n e k)) (lift (liftN n e k))
    (forallE (lift (liftN n a k)) (liftN 1 (liftN n B (k + 1)) 1))
Tactic:
rwa [← lift_liftN', ← lift_liftN'] at ih5
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.weakN
Proof state before:
case proofIrrel
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEqStrong env U Γ✝ p✝ p✝ (sort VLevel.zero)
a✝¹ : IsDefEqStrong env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEqStrong env U Γ✝ h'✝ h'✝ p✝
ih1 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ✝ Γ' → IsDefEqStrong env U Γ' (liftN n p✝ k) (liftN n p✝ k) (liftN n (sort VLevel.zero) k)
ih2 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ✝ Γ' → IsDefEqStrong env U Γ' (liftN n h✝ k) (liftN n h✝ k) (liftN n p✝ k)
ih3 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ✝ Γ' → IsDefEqStrong env U Γ' (liftN n h'✝ k) (liftN n h'✝ k) (liftN n p✝ k)
k : Nat
Γ' : List VExpr
W : Ctx.LiftN n k Γ✝ Γ'
⊢ IsDefEqStrong env U Γ' (liftN n h✝ k) (liftN n h'✝ k) (liftN n p✝ k)
Tactic:
exact .proofIrrel (ih1 W) (ih2 W) (ih3 W)
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.weakN
Proof state before:
case extra
env : VEnv
henv : Ordered env
n : Nat
Γ : List VExpr
U : Nat
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
h4 : VLevel.WF U u✝
h5 : IsDefEqStrong env U [] (instL ls✝ df✝.type) (instL ls✝ df✝.type) (sort u✝)
h6 : IsDefEqStrong env U [] (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
h7 : IsDefEqStrong env U [] (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
a✝¹ : IsDefEqStrong env U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
a✝ : IsDefEqStrong env U Γ✝ (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
a_ih✝² :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k [] Γ' →
      IsDefEqStrong env U Γ' (liftN n (instL ls✝ df✝.type) k) (liftN n (instL ls✝ df✝.type) k) (liftN n (sort u✝) k)
a_ih✝¹ :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k [] Γ' →
      IsDefEqStrong env U Γ' (liftN n (instL ls✝ df✝.lhs) k) (liftN n (instL ls✝ df✝.lhs) k)
        (liftN n (instL ls✝ df✝.type) k)
a_ih✝ :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k [] Γ' →
      IsDefEqStrong env U Γ' (liftN n (instL ls✝ df✝.rhs) k) (liftN n (instL ls✝ df✝.rhs) k)
        (liftN n (instL ls✝ df✝.type) k)
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
ih4 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ✝ Γ' → IsDefEqStrong env U Γ' (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
ih5 :
  ∀ {k : Nat} {Γ' : List VExpr},
    Ctx.LiftN n k Γ✝ Γ' → IsDefEqStrong env U Γ' (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
⊢ IsDefEqStrong env U Γ' (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
Tactic:
exact IsDefEqStrong.extra h1 h2 h3 h4 h5 h6 h7 (ih4 W) (ih5 W)
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Γ e1 e2 A
⊢ IsDefEq env U Γ e1 e2 A
Tactic:
induction H with
| bvar h => exact .bvar h
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 => exact .constDF h1 h2 h3 h4 h5
| 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 h1 h2 h3
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case bvar
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
u✝ : VLevel
h : Lookup Γ✝ i✝ A✝
a✝¹ : VLevel.WF U u✝
a✝ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a_ih✝ : IsDefEq env U Γ✝ A✝ A✝ (sort u✝)
⊢ IsDefEq env U Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝) A✝
Tactic:
exact .bvar h
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case symm
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e✝ e'✝ A✝ : VExpr
a✝ : IsDefEqStrong env U Γ✝ e✝ e'✝ A✝
ih : IsDefEq env U Γ✝ e✝ e'✝ A✝
⊢ IsDefEq env U Γ✝ e'✝ e✝ A✝
Tactic:
exact .symm ih
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case trans
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
e₁✝ e₂✝ A✝ e₃✝ : VExpr
a✝¹ : IsDefEqStrong env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEqStrong 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
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
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'✝
h3 : l✝ ≈ l'✝
⊢ IsDefEq env U Γ✝ (sort l✝) (sort l'✝) (sort (VLevel.succ l✝))
Tactic:
exact .sortDF h1 h2 h3
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case constDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
c✝ : Name
ci✝ : VConstant
ls✝ ls'✝ : List VLevel
u✝ : 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'✝
a✝⁴ : VLevel.WF U u✝
a✝³ : IsDefEqStrong env U [] (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
a✝² : IsDefEqStrong env U [] (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
a✝¹ : IsDefEqStrong env U Γ✝ (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
a✝ : IsDefEqStrong env U Γ✝ (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
a_ih✝³ : IsDefEq env U [] (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
a_ih✝² : IsDefEq env U [] (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
a_ih✝¹ : IsDefEq env U Γ✝ (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
a_ih✝ : IsDefEq env U Γ✝ (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
⊢ IsDefEq env U Γ✝ (const c✝ ls✝) (const c✝ ls'✝) (instL ls✝ ci✝.type)
Tactic:
exact .constDF h1 h2 h3 h4 h5
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case appDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁷ a'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁷ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (sort v✝)
a_ih✝² : IsDefEq env U Γ✝ A✝ A✝ (sort u✝)
a_ih✝¹ : IsDefEq env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
ih1 : IsDefEq env U Γ✝ f✝ f'✝ (forallE A✝ B✝)
ih2 : IsDefEq env U Γ✝ a✝⁷ a'✝ A✝
a_ih✝ : IsDefEq env U Γ✝ (inst B✝ a✝⁷) (inst B✝ a'✝) (sort v✝)
⊢ IsDefEq env U Γ✝ (app f✝ a✝⁷) (app f'✝ a'✝) (inst B✝ a✝⁷)
Tactic:
exact .appDF ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case lamDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ A'✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ih1 : IsDefEq env U Γ✝ A✝ A'✝ (sort u✝)
a_ih✝² : IsDefEq env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a_ih✝¹ : IsDefEq env U (A'✝ :: Γ✝) B✝ B✝ (sort v✝)
ih2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ B✝
a_ih✝ : IsDefEq env U (A'✝ :: Γ✝) body✝ body'✝ B✝
⊢ IsDefEq env U Γ✝ (lam A✝ body✝) (lam A'✝ body'✝) (forallE A✝ B✝)
Tactic:
exact .lamDF ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
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✝⁴ : VLevel.WF U u✝
a✝³ : VLevel.WF U v✝
a✝² : IsDefEqStrong env U Γ✝ A✝ A'✝ (sort u✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ (sort v✝)
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ (sort v✝)
ih1 : IsDefEq env U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEq env U (A✝ :: Γ✝) body✝ body'✝ (sort v✝)
a_ih✝ : IsDefEq env U (A'✝ :: Γ✝) body✝ body'✝ (sort v✝)
⊢ IsDefEq env U Γ✝ (forallE A✝ body✝) (forallE A'✝ body'✝) (sort (VLevel.imax u✝ v✝))
Tactic:
exact .forallEDF ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case defeqDF
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ B✝ : VExpr
u✝ : VLevel
e1✝ e2✝ : VExpr
a✝² : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 : IsDefEq env U Γ✝ A✝ B✝ (sort u✝)
ih2 : IsDefEq env U Γ✝ e1✝ e2✝ A✝
⊢ IsDefEq env U Γ✝ e1✝ e2✝ B✝
Tactic:
exact .defeqDF ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case beta
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ e'✝ : VExpr
a✝⁷ : VLevel.WF U u✝
a✝⁶ : VLevel.WF U v✝
a✝⁵ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a✝⁴ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝² : IsDefEqStrong env U Γ✝ e'✝ e'✝ A✝
a✝¹ : IsDefEqStrong env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (sort v✝)
a✝ : IsDefEqStrong env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
a_ih✝³ : IsDefEq env U Γ✝ A✝ A✝ (sort u✝)
a_ih✝² : IsDefEq env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
ih1 : IsDefEq env U (A✝ :: Γ✝) e✝ e✝ B✝
ih2 : IsDefEq env U Γ✝ e'✝ e'✝ A✝
a_ih✝¹ : IsDefEq env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (sort v✝)
a_ih✝ : IsDefEq env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
⊢ IsDefEq env U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
Tactic:
exact .beta ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case eta
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
a✝⁶ : VLevel.WF U u✝
a✝⁵ : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (forallE (lift A✝) (liftN 1 B✝ 1))
a_ih✝³ : IsDefEq env U Γ✝ A✝ A✝ (sort u✝)
a_ih✝² : IsDefEq env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a_ih✝¹ : IsDefEq env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (sort v✝)
ih : IsDefEq env U Γ✝ e✝ e✝ (forallE A✝ B✝)
a_ih✝ : IsDefEq env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (forallE (lift A✝) (liftN 1 B✝ 1))
⊢ IsDefEq env U Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (forallE A✝ B✝)
Tactic:
exact .eta ih
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case proofIrrel
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
p✝ h✝ h'✝ : VExpr
a✝² : IsDefEqStrong env U Γ✝ p✝ p✝ (sort VLevel.zero)
a✝¹ : IsDefEqStrong env U Γ✝ h✝ h✝ p✝
a✝ : IsDefEqStrong env U Γ✝ h'✝ h'✝ p✝
ih1 : IsDefEq env U Γ✝ p✝ p✝ (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
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.defeq
Proof state before:
case extra
env : VEnv
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
df✝ : VDefEq
ls✝ : List VLevel
u✝ : VLevel
Γ✝ : List VExpr
h1 : env.defeqs df✝
h2 : ∀ (l : VLevel), l ∈ ls✝ → VLevel.WF U l
h3 : List.length ls✝ = df✝.uvars
a✝⁵ : VLevel.WF U u✝
a✝⁴ : IsDefEqStrong env U [] (instL ls✝ df✝.type) (instL ls✝ df✝.type) (sort u✝)
a✝³ : IsDefEqStrong env U [] (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
a✝² : IsDefEqStrong env U [] (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
a✝¹ : IsDefEqStrong env U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
a✝ : IsDefEqStrong env U Γ✝ (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
a_ih✝⁴ : IsDefEq env U [] (instL ls✝ df✝.type) (instL ls✝ df✝.type) (sort u✝)
a_ih✝³ : IsDefEq env U [] (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
a_ih✝² : IsDefEq env U [] (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
a_ih✝¹ : IsDefEq env U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.lhs) (instL ls✝ df✝.type)
a_ih✝ : IsDefEq env U Γ✝ (instL ls✝ df✝.rhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
⊢ IsDefEq env U Γ✝ (instL ls✝ df✝.lhs) (instL ls✝ df✝.rhs) (instL ls✝ df✝.type)
Tactic:
exact .extra h1 h2 h3
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof state before:
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
H : IsDefEqStrong env U Γ e1 e2 A
⊢ IsDefEqStrong env' U Γ e1 e2 A
Tactic:
induction H with
| bvar h1 h2 _ ih => exact .bvar h1 h2 ih
| symm _ ih => exact .symm ih
| trans _ _ ih1 ih2 => exact .trans ih1 ih2
| sortDF h1 h2 h3 => exact .sortDF h1 h2 h3
| constDF h1 h2 h3 h4 h5 h6 _ _ _ _ ih1 ih2 ih3 ih4 =>
  exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5 h6 ih1 ih2 ih3 ih4
| appDF h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 => exact .appDF h1 h2 ih1 ih2 ih3 ih4 ih5
| lamDF h1 h2  _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 => exact .lamDF h1 h2 ih1 ih2 ih3 ih4 ih5
| forallEDF h1 h2 _ _ _ ih1 ih2 ih3 => exact .forallEDF h1 h2 ih1 ih2 ih3
| defeqDF h1 _ _ ih1 ih2 => exact .defeqDF h1 ih1 ih2
| beta h1 h2 _ _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 ih6 => exact .beta h1 h2 ih1 ih2 ih3 ih4 ih5 ih6
| eta h1 h2 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 => exact .eta h1 h2 ih1 ih2 ih3 ih4 ih5
| proofIrrel _ _ _ ih1 ih2 ih3 => exact .proofIrrel ih1 ih2 ih3
| extra h1 h2 h3 h4 _ _ _ _ _ ih1 ih2 ih3 ih4 ih5 =>
  exact .extra (henv.2 _ h1) h2 h3 h4 ih1 ih2 ih3 ih4 ih5
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof state before:
case bvar
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
i✝ : Nat
A✝ : VExpr
u✝ : VLevel
h1 : Lookup Γ✝ i✝ A✝
h2 : VLevel.WF U u✝
a✝ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
ih : IsDefEqStrong env' U Γ✝ A✝ A✝ (sort u✝)
⊢ IsDefEqStrong env' U Γ✝ (VExpr.bvar i✝) (VExpr.bvar i✝) A✝
Tactic:
exact .bvar h1 h2 ih
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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✝ : IsDefEqStrong env U Γ✝ e✝ e'✝ A✝
ih : IsDefEqStrong env' U Γ✝ e✝ e'✝ A✝
⊢ IsDefEqStrong env' U Γ✝ e'✝ e✝ A✝
Tactic:
exact .symm ih
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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✝¹ : IsDefEqStrong env U Γ✝ e₁✝ e₂✝ A✝
a✝ : IsDefEqStrong env U Γ✝ e₂✝ e₃✝ A✝
ih1 : IsDefEqStrong env' U Γ✝ e₁✝ e₂✝ A✝
ih2 : IsDefEqStrong env' U Γ✝ e₂✝ e₃✝ A✝
⊢ IsDefEqStrong env' U Γ✝ e₁✝ e₃✝ A✝
Tactic:
exact .trans ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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'✝
⊢ IsDefEqStrong env' U Γ✝ (sort l✝) (sort l'✝) (sort (VLevel.succ l✝))
Tactic:
exact .sortDF h1 h2 h3
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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
u✝ : 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'✝
h6 : VLevel.WF U u✝
a✝³ : IsDefEqStrong env U [] (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
a✝² : IsDefEqStrong env U [] (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
a✝¹ : IsDefEqStrong env U Γ✝ (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
a✝ : IsDefEqStrong env U Γ✝ (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
ih1 : IsDefEqStrong env' U [] (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
ih2 : IsDefEqStrong env' U [] (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
ih3 : IsDefEqStrong env' U Γ✝ (instL ls✝ ci✝.type) (instL ls✝ ci✝.type) (sort u✝)
ih4 : IsDefEqStrong env' U Γ✝ (instL ls'✝ ci✝.type) (instL ls'✝ ci✝.type) (sort u✝)
⊢ IsDefEqStrong env' U Γ✝ (const c✝ ls✝) (const c✝ ls'✝) (instL ls✝ ci✝.type)
Tactic:
exact .constDF (henv.1 _ _ h1) h2 h3 h4 h5 h6 ih1 ih2 ih3 ih4
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof state before:
case appDF
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
f✝ f'✝ a✝⁵ a'✝ : VExpr
h1 : VLevel.WF U u✝
h2 : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝² : IsDefEqStrong env U Γ✝ f✝ f'✝ (forallE A✝ B✝)
a✝¹ : IsDefEqStrong env U Γ✝ a✝⁵ a'✝ A✝
a✝ : IsDefEqStrong env U Γ✝ (inst B✝ a✝⁵) (inst B✝ a'✝) (sort v✝)
ih1 : IsDefEqStrong env' U Γ✝ A✝ A✝ (sort u✝)
ih2 : IsDefEqStrong env' U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
ih3 : IsDefEqStrong env' U Γ✝ f✝ f'✝ (forallE A✝ B✝)
ih4 : IsDefEqStrong env' U Γ✝ a✝⁵ a'✝ A✝
ih5 : IsDefEqStrong env' U Γ✝ (inst B✝ a✝⁵) (inst B✝ a'✝) (sort v✝)
⊢ IsDefEqStrong env' U Γ✝ (app f✝ a✝⁵) (app f'✝ a'✝) (inst B✝ a✝⁵)
Tactic:
exact .appDF h1 h2 ih1 ih2 ih3 ih4 ih5
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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
B✝ : VExpr
v✝ : VLevel
body✝ body'✝ : VExpr
h1 : VLevel.WF U u✝
h2 : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A'✝ (sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝² : IsDefEqStrong env U (A'✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ B✝
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ B✝
ih1 : IsDefEqStrong env' U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEqStrong env' U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
ih3 : IsDefEqStrong env' U (A'✝ :: Γ✝) B✝ B✝ (sort v✝)
ih4 : IsDefEqStrong env' U (A✝ :: Γ✝) body✝ body'✝ B✝
ih5 : IsDefEqStrong env' U (A'✝ :: Γ✝) body✝ body'✝ B✝
⊢ IsDefEqStrong env' U Γ✝ (lam A✝ body✝) (lam A'✝ body'✝) (forallE A✝ B✝)
Tactic:
exact .lamDF h1 h2 ih1 ih2 ih3 ih4 ih5
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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
h1 : VLevel.WF U u✝
h2 : VLevel.WF U v✝
a✝² : IsDefEqStrong env U Γ✝ A✝ A'✝ (sort u✝)
a✝¹ : IsDefEqStrong env U (A✝ :: Γ✝) body✝ body'✝ (sort v✝)
a✝ : IsDefEqStrong env U (A'✝ :: Γ✝) body✝ body'✝ (sort v✝)
ih1 : IsDefEqStrong env' U Γ✝ A✝ A'✝ (sort u✝)
ih2 : IsDefEqStrong env' U (A✝ :: Γ✝) body✝ body'✝ (sort v✝)
ih3 : IsDefEqStrong env' U (A'✝ :: Γ✝) body✝ body'✝ (sort v✝)
⊢ IsDefEqStrong env' U Γ✝ (forallE A✝ body✝) (forallE A'✝ body'✝) (sort (VLevel.imax u✝ v✝))
Tactic:
exact .forallEDF h1 h2 ih1 ih2 ih3
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof 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
h1 : VLevel.WF U u✝
a✝¹ : IsDefEqStrong env U Γ✝ A✝ B✝ (sort u✝)
a✝ : IsDefEqStrong env U Γ✝ e1✝ e2✝ A✝
ih1 : IsDefEqStrong env' U Γ✝ A✝ B✝ (sort u✝)
ih2 : IsDefEqStrong env' U Γ✝ e1✝ e2✝ A✝
⊢ IsDefEqStrong env' U Γ✝ e1✝ e2✝ B✝
Tactic:
exact .defeqDF h1 ih1 ih2
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof state before:
case beta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ e'✝ : VExpr
h1 : VLevel.WF U u✝
h2 : VLevel.WF U v✝
a✝⁵ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a✝⁴ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) e✝ e✝ B✝
a✝² : IsDefEqStrong env U Γ✝ e'✝ e'✝ A✝
a✝¹ : IsDefEqStrong env U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (sort v✝)
a✝ : IsDefEqStrong env U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
ih1 : IsDefEqStrong env' U Γ✝ A✝ A✝ (sort u✝)
ih2 : IsDefEqStrong env' U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
ih3 : IsDefEqStrong env' U (A✝ :: Γ✝) e✝ e✝ B✝
ih4 : IsDefEqStrong env' U Γ✝ e'✝ e'✝ A✝
ih5 : IsDefEqStrong env' U Γ✝ (inst B✝ e'✝) (inst B✝ e'✝) (sort v✝)
ih6 : IsDefEqStrong env' U Γ✝ (inst e✝ e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
⊢ IsDefEqStrong env' U Γ✝ (app (lam A✝ e✝) e'✝) (inst e✝ e'✝) (inst B✝ e'✝)
Tactic:
exact .beta h1 h2 ih1 ih2 ih3 ih4 ih5 ih6
Proof state after:
no goals
Theorem: Lean4Lean.VEnv.IsDefEqStrong.mono
Proof state before:
case eta
env env' : VEnv
henv : env ≤ env'
U : Nat
Γ : List VExpr
e1 e2 A : VExpr
Γ✝ : List VExpr
A✝ : VExpr
u✝ : VLevel
B✝ : VExpr
v✝ : VLevel
e✝ : VExpr
h1 : VLevel.WF U u✝
h2 : VLevel.WF U v✝
a✝⁴ : IsDefEqStrong env U Γ✝ A✝ A✝ (sort u✝)
a✝³ : IsDefEqStrong env U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
a✝² : IsDefEqStrong env U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (sort v✝)
a✝¹ : IsDefEqStrong env U Γ✝ e✝ e✝ (forallE A✝ B✝)
a✝ : IsDefEqStrong env U (A✝ :: Γ✝) (lift e✝) (lift e✝) (forallE (lift A✝) (liftN 1 B✝ 1))
ih1 : IsDefEqStrong env' U Γ✝ A✝ A✝ (sort u✝)
ih2 : IsDefEqStrong env' U (A✝ :: Γ✝) B✝ B✝ (sort v✝)
ih3 : IsDefEqStrong env' U (lift A✝ :: A✝ :: Γ✝) (liftN 1 B✝ 1) (liftN 1 B✝ 1) (sort v✝)
ih4 : IsDefEqStrong env' U Γ✝ e✝ e✝ (forallE A✝ B✝)
ih5 : IsDefEqStrong env' U (A✝ :: Γ✝) (lift e✝) (lift e✝) (forallE (lift A✝) (liftN 1 B✝ 1))
⊢ IsDefEqStrong env' U Γ✝ (lam A✝ (app (lift e✝) (VExpr.bvar 0))) e✝ (forallE A✝ B✝)
Tactic:
exact .eta h1 h2 ih1 ih2 ih3 ih4 ih5
Proof state after:
no goals