Fω closing instances in the single existing term model

DefinitionClosing Fω terms in the System F term model#✓fully proved

Close scoped Fω variables in exactly the existing System F term model.

def close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
  SystemF.Tm.close σ (eraseSyntax t)
Uses 5 · Used by 14

DefinitionErasure of closed Fω terms to the term model#✓fully proved

Erase a closed-term Fω expression, with an arbitrary type telescope.

def eraseModel (t : Tm Δ 0) : SystemF.Model := close Fin.elim0 t
Uses 4 · Used by 4

TheoremClosing an Fω variable#✓fully proved

Closing a variable returns its actual model environment image.

@[simp] theorem close_var (σ : Fin m → SystemF.Model) (i : Fin m) :
    close σ (.var i : Tm Δ m) = σ i
Uses 4

TheoremClosing an Fω application#✓fully proved

Closing preserves the existing model application constructor.

@[simp] theorem close_app (σ : Fin m → SystemF.Model) (f a : Tm Δ m) :
    close σ (.app f a) = SystemF.Model.app (close σ f) (close σ a)
Uses 5 · Used by 1

TheoremClosing erases type abstraction#✓fully proved

Type abstraction adds no binder to an erased closing instance.

@[simp] theorem close_tabs {κ : Kind} (σ : Fin m → SystemF.Model)
    (b : Tm (κ :: Δ) m) : close σ (.tabs b) = close σ b
Uses 4 · Used by 1

TheoremClosing erases type application#✓fully proved

Type application adds no application to an erased closing instance.

@[simp] theorem close_tapp {κ : Kind} (σ : Fin m → SystemF.Model)
    (f : Tm Δ m) (A : Ty Δ κ) : close σ (.tapp f A) = close σ f
Uses 5 · Used by 1

TheoremClosing is invariant under type substitution#✓fully proved

Any kind-correct type substitution leaves closing instances unchanged.

@[simp] theorem close_tySubst (σ : Ty.Sub Δ Ε) (η : Fin m → SystemF.Model)
    (t : Tm Δ m) : close η (tySubst σ t) = close η t
Uses 10 · Used by 1

TheoremBeta conversion of a closed Fω lambda application#✓fully proved

Applying an erased Fω lambda beta-converts to its extended body instance.

theorem close_beta (σ : Fin m → SystemF.Model) (A : Ty Δ .star)
    (b : Tm Δ (m + 1)) (a : SystemF.Model) :
    SystemF.BetaEq (SystemF.Model.app (close σ (.lam A b)) a)
      (close (Fin.cases a σ) b)
Uses 10 · Used by 2

TheoremClosing commutes with Fω term substitution#✓fully proved

Closing composes actual Fω term substitutions with model environments.

theorem close_subst (σ : Fin m → Tm Δ k) (η : Fin k → SystemF.Model)
    (t : Tm Δ m) :
    close η (subst σ t) = close (fun i => close η (σ i)) t
Uses 11

TheoremClosing an instantiated Fω term binder#✓fully proved

Actual term-binder discharge extends the same model closing environment.

theorem close_instantiate (η : Fin m → SystemF.Model)
    (b : Tm Δ (m + 1)) (a : Tm Δ m) :
    close η (instantiate b a) = close (Fin.cases (close η a) η) b
Uses 11 · Used by 1
10 fully proved

The dependency explorer needs JavaScript and its graph data.

Download the complete graph data.