internlm/Lean-Github huggingface dataset:
Theorem: AlphaEquivPreservesType'
Proof state before:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' : Λ V 𝕍
ih₀ :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M₀' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M₀' : σ)
ih₁ :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M₁' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M₁' : σ)
M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Tactic:
specialize ih₀ alpha_equiv.1 ctxt_equiv h₀
Proof state after:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' : Λ V 𝕍
ih₁ :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M₁' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M₁' : σ)
M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
ih₀ : Γ' ⊢ M₀' : τ →' σ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' : Λ V 𝕍
ih₁ :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M₁' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M₁' : σ)
M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
ih₀ : Γ' ⊢ M₀' : τ →' σ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Tactic:
specialize ih₁ alpha_equiv.2 ctxt_equiv h₁
Proof state after:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
ih₀ : Γ' ⊢ M₀' : τ →' σ
ih₁ : Γ' ⊢ M₁' : τ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
ih₀ : Γ' ⊢ M₀' : τ →' σ
ih₁ : Γ' ⊢ M₁' : τ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Tactic:
simp at ih₀ ih₁
Proof state after:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
ih₀ : typeOf Γ' M₀' = some (τ →' σ)
ih₁ : typeOf Γ' M₁' = some τ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
case intro.intro
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
M₀' M₁' M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
M₀ M₁ : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map M₀ M₀' ∧ AlphaEquiv' var_map M₁ M₁'
τ : 𝕋 𝕍
h₀ : Γ ⊢ M₀ : τ →' σ
h₁ : Γ ⊢ M₁ : τ
ih₀ : typeOf Γ' M₀' = some (τ →' σ)
ih₁ : typeOf Γ' M₁' = some τ
⊢ Γ' ⊢ Λ.App M₀' M₁' : σ
Tactic:
simp [ih₀, ih₁]
Proof state after:
no goals
Theorem: AlphaEquivPreservesType'
Proof state before:
case Lam
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
⊢ ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M (λ' x' : τ', M') →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ λ' x' : τ', M' : σ)
Tactic:
introv
Proof state after:
case Lam
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
⊢ AlphaEquiv' var_map M (λ' x' : τ', M') →
    (∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
      (Γ ⊢ M : σ) → (Γ' ⊢ λ' x' : τ', M' : σ)
Theorem: AlphaEquivPreservesType'
Proof state before:
case Lam
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
⊢ AlphaEquiv' var_map M (λ' x' : τ', M') →
    (∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
      (Γ ⊢ M : σ) → (Γ' ⊢ λ' x' : τ', M' : σ)
Tactic:
intros alpha_equiv ctxt_equiv h
Proof state after:
case Lam
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
alpha_equiv : AlphaEquiv' var_map M (λ' x' : τ', M')
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
h : Γ ⊢ M : σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' var_map (λ' x : τ, M) (λ' x' : τ', M')
h : Γ ⊢ λ' x : τ, M : σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
simp at alpha_equiv
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
h : Γ ⊢ λ' x : τ, M : σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
h : Γ ⊢ λ' x : τ, M : σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
simp at h
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
h :
  (match typeOf (Γ;; x : τ) M with
    | some τ_1 => some (τ →' τ_1)
    | x => none) =
    some σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
h :
  (match typeOf (Γ;; x : τ) M with
    | some τ_1 => some (τ →' τ_1)
    | x => none) =
    some σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
generalize h' : typeOf (Γ;; x : τ) M = aux
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
h :
  (match typeOf (Γ;; x : τ) M with
    | some τ_1 => some (τ →' τ_1)
    | x => none) =
    some σ
aux : Option (𝕋 𝕍)
h' : typeOf (Γ;; x : τ) M = aux
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
h :
  (match typeOf (Γ;; x : τ) M with
    | some τ_1 => some (τ →' τ_1)
    | x => none) =
    some σ
aux : Option (𝕋 𝕍)
h' : typeOf (Γ;; x : τ) M = aux
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
rw [h'] at h
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
h :
  (match aux with
    | some τ_1 => some (τ →' τ_1)
    | x => none) =
    some σ
h' : typeOf (Γ;; x : τ) M = aux
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h :
  (match some σ' with
    | some τ_1 => some (τ →' τ_1)
    | x => none) =
    some σ
h' : typeOf (Γ;; x : τ) M = some σ'
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
simp at h
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ →' σ') = σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ →' σ') = σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
rw [alpha_equiv.2] at h
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
⊢ Γ' ⊢ λ' x' : τ', M' : σ
Tactic:
rw [←h]
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
⊢ Γ' ⊢ λ' x' : τ', M' : τ' →' σ'
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
⊢ Γ' ⊢ λ' x' : τ', M' : τ' →' σ'
Tactic:
simp
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
⊢ (match typeOf (Γ';; x' : τ') M' with
    | some τ => some (τ' →' τ)
    | x => none) =
    some (τ' →' σ')
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' : Λ V 𝕍
ih :
  ∀ {M : Λ V 𝕍} {Γ Γ' : TCtxt V 𝕍} {σ : 𝕋 𝕍} {var_map : V → Option V},
    AlphaEquiv' var_map M M' →
      (∀ (x : V),
          var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ') →
        (Γ ⊢ M : σ) → (Γ' ⊢ M' : σ)
M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
ctxt_equiv' :
  ∀ (y : V),
    (if y = x then some x' else var_map y) = none ∧ getType y (Γ;; x : τ) = getType y (Γ';; x' : τ') ∨
      ∃ z, (if y = x then some x' else var_map y) = some z ∧ getType y (Γ;; x : τ) = getType z (Γ';; x' : τ')
⊢ (match typeOf (Γ';; x' : τ') M' with
    | some τ => some (τ' →' τ)
    | x => none) =
    some (τ' →' σ')
Tactic:
specialize ih alpha_equiv.1 ctxt_equiv' h'
Proof state after:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
ctxt_equiv' :
  ∀ (y : V),
    (if y = x then some x' else var_map y) = none ∧ getType y (Γ;; x : τ) = getType y (Γ';; x' : τ') ∨
      ∃ z, (if y = x then some x' else var_map y) = some z ∧ getType y (Γ;; x : τ) = getType z (Γ';; x' : τ')
ih : (Γ';; x' : τ') ⊢ M' : σ'
⊢ (match typeOf (Γ';; x' : τ') M' with
    | some τ => some (τ' →' τ)
    | x => none) =
    some (τ' →' σ')
Theorem: AlphaEquivPreservesType'
Proof state before:
V 𝕍 : Type
inst✝¹ : DecidableEq V
inst✝ : DecidableEq 𝕍
x' : V
τ' : 𝕋 𝕍
M' M✝ : Λ V 𝕍
Γ Γ' : TCtxt V 𝕍
σ : 𝕋 𝕍
var_map : V → Option V
ctxt_equiv :
  ∀ (x : V), var_map x = none ∧ getType x Γ = getType x Γ' ∨ ∃ y, var_map x = some y ∧ getType x Γ = getType y Γ'
x : V
τ : 𝕋 𝕍
M : Λ V 𝕍
alpha_equiv : AlphaEquiv' (fun vn => if vn = x then some x' else var_map vn) M M' ∧ τ = τ'
aux : Option (𝕋 𝕍)
σ' : 𝕋 𝕍
h' : typeOf (Γ;; x : τ) M = some σ'
h : (τ' →' σ') = σ
ctxt_equiv' :
  ∀ (y : V),
    (if y = x then some x' else var_map y) = none ∧ getType y (Γ;; x : τ) = getType y (Γ';; x' : τ') ∨
      ∃ z, (if y = x then some x' else var_map y) = some z ∧ getType y (Γ;; x : τ) = getType z (Γ';; x' : τ')
ih : (Γ';; x' : τ') ⊢ M' : σ'
⊢ (match typeOf (Γ';; x' : τ') M' with
    | some τ => some (τ' →' τ)
    | x => none) =
    some (τ' →' σ')
Tactic:
rw [ih]
Proof state after:
no goals