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
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
inductive Tm : List Kind → Nat → Type where
| var {Δ : List Kind} {m : Nat} : Fin m → Tm Δ m
| lam {Δ : List Kind} {m : Nat} : Ty Δ .star → Tm Δ (m + 1) → Tm Δ m
| app {Δ : List Kind} {m : Nat} : Tm Δ m → Tm Δ m → Tm Δ m
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} : Tm (κ :: Δ) m → Tm Δ m
| tapp {Δ : List Kind} {m : Nat} {κ : Kind} : Tm Δ m → Ty Δ κ → Tm Δ m
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:29
inductive Tm : Nat → Nat → Type where
| var {n m : Nat} : Fin m → Tm n m
| lam {n m : Nat} : Ty n → Tm n (m + 1) → Tm n m
| app {n m : Nat} : Tm n m → Tm n m → Tm n m
| tabs {n m : Nat} : Tm (n + 1) m → Tm n m
| tapp {n m : Nat} : Tm n m → Ty n → Tm n m
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:83
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
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
inductive Tm : List Kind → Nat → Type where
| var {Δ : List Kind} {m : Nat} : Fin m → Tm Δ m
| lam {Δ : List Kind} {m : Nat} : Ty Δ .star → Tm Δ (m + 1) → Tm Δ m
| app {Δ : List Kind} {m : Nat} : Tm Δ m → Tm Δ m → Tm Δ m
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} : Tm (κ :: Δ) m → Tm Δ m
| tapp {Δ : List Kind} {m : Nat} {κ : Kind} : Tm Δ m → Ty Δ κ → Tm Δ m
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:29
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
CSLibExt/Languages/LambdaCalculus/FOmega/ErasureSyntax.lean:26
@[simp] def tySubst {Δ Ε : List Kind} {m : Nat} (σ : Ty.Sub Δ Ε) :
Tm Δ m → Tm Ε m
| .var i => .var i
| .lam A b => .lam (A.subst σ) (tySubst σ b)
| .app f a => .app (tySubst σ f) (tySubst σ a)
| .tabs b => .tabs (tySubst (Ty.liftSub σ) b)
| .tapp f A => .tapp (tySubst σ f) (A.subst σ)
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:42
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)
inductive Tm : List Kind → Nat → Type where
| var {Δ : List Kind} {m : Nat} : Fin m → Tm Δ m
| lam {Δ : List Kind} {m : Nat} : Ty Δ .star → Tm Δ (m + 1) → Tm Δ m
| app {Δ : List Kind} {m : Nat} : Tm Δ m → Tm Δ m → Tm Δ m
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} : Tm (κ :: Δ) m → Tm Δ m
| tapp {Δ : List Kind} {m : Nat} {κ : Kind} : Tm Δ m → Ty Δ κ → Tm Δ m
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:29
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
CSLibExt/Languages/LambdaCalculus/FOmega/ErasureSyntax.lean:26
@[simp] def rename {Δ : List Kind} {m k : Nat} (ρ : Fin m → Fin k) :
Tm Δ m → Tm Δ k
| .var i => .var (ρ i)
| .lam A b => .lam A (rename (SystemF.liftRen ρ) b)
| .app f a => .app (rename ρ f) (rename ρ a)
| .tabs b => .tabs (rename ρ b)
| .tapp f A => .tapp (rename ρ f) A
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:55
@[simp] def rename {n m k : Nat} (ρ : Fin m → Fin k) : Tm n m → Tm n k
| .var i => .var (ρ i)
| .lam A b => .lam A (rename (liftRen ρ) b)
| .app f a => .app (rename ρ f) (rename ρ a)
| .tabs b => .tabs (rename ρ b)
| .tapp f A => .tapp (rename ρ f) A
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:105
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)
inductive Tm : List Kind → Nat → Type where
| var {Δ : List Kind} {m : Nat} : Fin m → Tm Δ m
| lam {Δ : List Kind} {m : Nat} : Ty Δ .star → Tm Δ (m + 1) → Tm Δ m
| app {Δ : List Kind} {m : Nat} : Tm Δ m → Tm Δ m → Tm Δ m
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} : Tm (κ :: Δ) m → Tm Δ m
| tapp {Δ : List Kind} {m : Nat} {κ : Kind} : Tm Δ m → Ty Δ κ → Tm Δ m
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:29
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
CSLibExt/Languages/LambdaCalculus/FOmega/ErasureSyntax.lean:26
@[simp] def subst {Δ : List Kind} {m k : Nat} (σ : Fin m → Tm Δ k) :
Tm Δ m → Tm Δ k
| .var i => σ i
| .lam A b => .lam A (subst (liftSub σ) b)
| .app f a => .app (subst σ f) (subst σ a)
| .tabs b => .tabs (subst (fun i => tyRename KVar.succ (σ i)) b)
| .tapp f A => .tapp (subst σ f) A
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:69
@[simp] def subst {n m k : Nat} (σ : Fin m → Tm n k) : Tm n m → Tm n k
| .var i => σ i
| .lam A b => .lam A (subst (liftSub σ) b)
| .app f a => .app (subst σ f) (subst σ a)
| .tabs b => .tabs (subst (fun i => tyRename Fin.succ (σ i)) b)
| .tapp f A => .tapp (subst σ f) A
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:122
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)
inductive Tm : List Kind → Nat → Type where
| var {Δ : List Kind} {m : Nat} : Fin m → Tm Δ m
| lam {Δ : List Kind} {m : Nat} : Ty Δ .star → Tm Δ (m + 1) → Tm Δ m
| app {Δ : List Kind} {m : Nat} : Tm Δ m → Tm Δ m → Tm Δ m
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} : Tm (κ :: Δ) m → Tm Δ m
| tapp {Δ : List Kind} {m : Nat} {κ : Kind} : Tm Δ m → Ty Δ κ → Tm Δ m
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:29
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
CSLibExt/Languages/LambdaCalculus/FOmega/ErasureSyntax.lean:26
def instantiate {Δ : List Kind} {m : Nat} (b : Tm Δ (m + 1))
(a : Tm Δ m) : Tm Δ m := subst (Fin.cases a Tm.var) b
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:78
def instantiate {n m : Nat} (b : Tm n (m + 1)) (a : Tm n m) : Tm n m :=
subst (Fin.cases a Tm.var) b
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:130
Uses 8 · Used by 1
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.