Erasure adapter to the existing System F scoped syntax

DefinitionErasure of Fω terms to System F syntax#✓fully proved

Erase types using the already banked System F scoped term carrier.

def eraseSyntax : {Δ : List Kind} → {m : Nat} → Tm Δ m → SystemF.Tm 0 m
  | _, _, .var i => .var i
  | _, _, .lam _ b => .lam (.all (.var 0)) (eraseSyntax b)
  | _, _, .app f a => .app (eraseSyntax f) (eraseSyntax a)
  | _, _, .tabs b => eraseSyntax b
  | _, _, .tapp f _ => eraseSyntax f
Uses 5 · Used by 10

TheoremFω erasure ignores type substitution#✓fully proved

Erasure ignores all kind-correct type substitutions.

@[simp] theorem eraseSyntax_tySubst (σ : Ty.Sub Δ Ε) (t : Tm Δ m) :
    eraseSyntax (tySubst σ t) = eraseSyntax t
Uses 10 · Used by 2

TheoremFω erasure commutes with term-variable renaming#✓fully proved

Erasure commutes with scoped term-variable renaming.

@[simp] theorem eraseSyntax_rename (ρ : Fin m → Fin k) (t : Tm Δ m) :
    eraseSyntax (rename ρ t) = SystemF.Tm.rename ρ (eraseSyntax t)
Uses 9 · Used by 1

TheoremFω erasure commutes with term substitution#✓fully proved

Erasure commutes with simultaneous substitution of scoped terms.

@[simp] theorem eraseSyntax_subst (σ : Fin m → Tm Δ k) (t : Tm Δ m) :
    eraseSyntax (subst σ t) =
      SystemF.Tm.subst (fun i => eraseSyntax (σ i)) (eraseSyntax t)
Uses 15 · Used by 2

TheoremFω erasure commutes with term-binder instantiation#✓fully proved

Erasure commutes with discharging a term binder.

@[simp] theorem eraseSyntax_instantiate (b : Tm Δ (m + 1)) (a : Tm Δ m) :
    eraseSyntax (instantiate b a) =
      SystemF.Tm.instantiate (eraseSyntax b) (eraseSyntax a)
Uses 8 · Used by 1
5 fully proved

The dependency explorer needs JavaScript and its graph data.

Download the complete graph data.