Pure Fω typing with proved type-beta conversion
Typing rules
InductiveTyping rules of pure Fω#✓fully proved
The five pure term rules and the type-beta conversion rule of Fω.
Cslib.Languages.LambdaCalculus.FOmega.Typing · 20 lines
inductive Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
Typing (fun i => (Γ i).rename KVar.succ) b C →
Typing Γ (.tabs b) (.all C)
| tapp {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{f : Tm Δ m} {A : Ty Δ κ} {C : Ty (κ :: Δ) .star} :
Typing Γ f (.all C) → Typing Γ (.tapp f A) (C.instantiate A)
| conv {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{t : Tm Δ m} {A B : Ty Δ .star} :
Typing Γ t A → Ty.Conv A B → Typing Γ t B
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.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 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 KVar : List Kind → Kind → Type where
| zero {Δ : List Kind} {κ : Kind} : KVar (κ :: Δ) κ
| succ {Δ : List Kind} {κ μ : Kind} : KVar Δ κ → KVar (μ :: Δ) κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:43
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
Uses 8 · Used by 23
Typing
TheoremType substitution preserves Fω typing#✓fully proved
Kind-correct type substitution preserves typing in arbitrary contexts.
theorem tySubst {Ε : List Kind} (h : Typing Γ t A) (σ : Ty.Sub Δ Ε) :
Typing (fun i => (Γ i).subst σ) (t.tySubst σ) (A.subst σ)
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
inductive Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Typing.lean:25
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
Uses 16 · Used by 2
TheoremType renaming preserves Fω typing#✓fully proved
Kind-preserving type renaming preserves typing.
theorem tyRename {Ε : List Kind} (h : Typing Γ t A) (ρ : KRen Δ Ε) :
Typing (fun i => (Γ i).rename ρ) (t.tyRename ρ) (A.rename ρ)
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
inductive Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Typing.lean:25
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
Uses 13 · Used by 1
TheoremTerm renaming preserves Fω typing#✓fully proved
A context-respecting term-variable renaming preserves the result type.
theorem rename {k : Nat} {Ξ : Ctx Δ k} (h : Typing Γ t A)
(ρ : Fin m → Fin k) (hρ : ∀ i, Ξ (ρ i) = Γ i) :
Typing Ξ (t.rename ρ) A
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:37
inductive Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Typing.lean:25
Uses 11 · Used by 1
TheoremTerm substitution preserves Fω typing#✓fully proved
Arbitrary correctly typed term substitution preserves typing.
theorem subst {k : Nat} {Ξ : Ctx Δ k} (h : Typing Γ t A)
(σ : Fin m → Tm Δ k) (hσ : ∀ i, Typing Ξ (σ i) (Γ i)) :
Typing Ξ (t.subst σ) A
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:37
inductive Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Typing.lean:25
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 14 · Used by 1
TheoremTerm-binder instantiation preserves Fω typing#✓fully proved
Discharging a typed term binder retains the body result type.
theorem instantiate {B : Ty Δ .star} {b : Tm Δ (m + 1)} {a : Tm Δ m}
(hb : Typing (Fin.cases A Γ) b B) (ha : Typing Γ a A) :
Typing Γ (b.instantiate a) B
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
inductive Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Typing.lean:25
Uses 7 · Used by 1
TheoremType-binder instantiation preserves Fω typing#✓fully proved
Discharging a type binder substitutes its result and restores context.
theorem tyInstantiate {κ : Kind} {b : Tm (κ :: Δ) m}
{C : Ty (κ :: Δ) .star}
(hb : Typing (fun i => (Γ i).rename KVar.succ) b C) (a : Ty Δ κ) :
Typing Γ (b.tySubst (Ty.single a)) (C.instantiate a)
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 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 Typing : {Δ : List Kind} → {m : Nat} →
Ctx Δ m → Tm Δ m → Ty Δ .star → Prop where
| var {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {b : Tm Δ (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{A B : Ty Δ .star} {f a : Tm Δ m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} {Γ : Ctx Δ m}
{b : Tm (κ :: Δ) m} {C : Ty (κ :: Δ) .star} :
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Typing.lean:25
inductive KVar : List Kind → Kind → Type where
| zero {Δ : List Kind} {κ : Kind} : KVar (κ :: Δ) κ
| succ {Δ : List Kind} {κ μ : Kind} : KVar Δ κ → KVar (μ :: Δ) κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:43
def single {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Sub (κ :: Δ) Δ
| _, .zero => a
| _, .succ x => .var x
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:100
Uses 13 · Used by 1
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.