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)
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close {n m : Nat} (σ : Fin m → Model) (t : Tm n m) : Model :=
⟨eraseWith (fun i => (σ i).val) t,
eraseWith_lcAt _ t (fun i => (σ i).property)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Erasure.lean:140
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
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
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
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
def close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
def close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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
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)
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
def app (f a : Model) : Model :=
⟨.app f.val a.val, by
simpa only [Term.LcAt, Bool.and_eq_true] using
And.intro f.property a.property⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:36
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
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
def close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.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 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)
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
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
abbrev BetaEq (f g : Model) : Prop :=
Relation.EqvGen Term.FullBeta f.val g.val
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:30
def app (f a : Model) : Model :=
⟨.app f.val a.val, by
simpa only [Term.LcAt, Bool.and_eq_true] using
And.intro f.property a.property⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:36
def close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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
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
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
def close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.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
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
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.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
Uses 11 · Used by 1
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.