Conversion-aware weak call-by-value safety for pure Fω
InductiveWeak call-by-value values of Fω#✓fully proved
Weak-CBV values: neither form of lambda evaluates beneath its binder.
inductive Value : {Δ : List Kind} → {m : Nat} → Tm Δ m → Prop where
| lam {Δ : List Kind} {m : Nat} (A : Ty Δ .star) (b : Tm Δ (m + 1)) :
Value (.lam A b)
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} (b : Tm (κ :: Δ) m) :
Value (.tabs b)
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
Uses 3 · Used by 9
InductiveWeak call-by-value reduction of Fω#✓fully proved
Ordinary left-to-right weak call-by-value reduction.
inductive Step : {Δ : List Kind} → {m : Nat} → Tm Δ m → Tm Δ m → Prop where
| beta {Δ : List Kind} {m : Nat} {A : Ty Δ .star}
{b : Tm Δ (m + 1)} {a : Tm Δ m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tybeta {Δ : List Kind} {m : Nat} {κ : Kind}
(b : Tm (κ :: Δ) m) (a : Ty Δ κ) :
Step (.tapp (.tabs b) a) (b.tySubst (Ty.single a))
| appFun {Δ : List Kind} {m : Nat} {f f' a : Tm Δ m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {Δ : List Kind} {m : Nat} {f a a' : Tm Δ m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| tapp {Δ : List Kind} {m : Nat} {κ : Kind}
{f f' : Tm Δ m} {a : Ty Δ κ} :
Step f f' → Step (.tapp f a) (.tapp f' 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 Value : {Δ : List Kind} → {m : Nat} → Tm Δ m → Prop where
| lam {Δ : List Kind} {m : Nat} (A : Ty Δ .star) (b : Tm Δ (m + 1)) :
Value (.lam A b)
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} (b : Tm (κ :: Δ) m) :
Value (.tabs b)
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:24
def single {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Sub (κ :: Δ) Δ
| _, .zero => a
| _, .succ x => .var x
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:100
Uses 7 · Used by 9
TheoremInversion of Fω lambda typing up to conversion#✓fully proved
Lambda typing inversion retains the annotation and a proved conversion.
theorem Typing.lam_inv {A T : Ty Δ .star} {b : Tm Δ (m + 1)}
(h : Typing Γ (.lam A b) T) :
∃ B, Typing (Fin.cases A Γ) b B ∧ Ty.Conv (.arr A B) T
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
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 9 · Used by 2
TheoremInversion of Fω type-lambda typing up to conversion#✓fully proved
Type-lambda inversion retains its binder kind and body conversion.
theorem Typing.tabs_inv {κ : Kind} {T : Ty Δ .star}
{b : Tm (κ :: Δ) m} (h : Typing Γ (.tabs b) T) :
∃ B : Ty (κ :: Δ) .star,
Typing (fun i => (Γ i).rename KVar.succ) b B ∧
Ty.Conv (.all B) T
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
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
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 9 · Used by 3
TheoremType preservation for Fω weak call-by-value reduction#✓fully proved
Weak-CBV reduction preserves typing in unrestricted open contexts.
theorem Typing.preservation {A : Ty Δ .star} {t t' : Tm Δ m}
(h : Typing Γ t A) (hs : Step t t') : Typing Γ t' A
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
inductive Step : {Δ : List Kind} → {m : Nat} → Tm Δ m → Tm Δ m → Prop where
| beta {Δ : List Kind} {m : Nat} {A : Ty Δ .star}
{b : Tm Δ (m + 1)} {a : Tm Δ m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tybeta {Δ : List Kind} {m : Nat} {κ : Kind}
(b : Tm (κ :: Δ) m) (a : Ty Δ κ) :
Step (.tapp (.tabs b) a) (b.tySubst (Ty.single a))
| appFun {Δ : List Kind} {m : Nat} {f f' a : Tm Δ m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {Δ : List Kind} {m : Nat} {f a a' : Tm Δ m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| tapp {Δ : List Kind} {m : Nat} {κ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:31
Uses 21 · Used by 1
TheoremCanonical forms for Fω values of function type#✓fully proved
A value typed at an arrow, despite conversion, is a term lambda.
theorem Value.arrow {A B : Ty Δ .star} {t : Tm Δ m}
(hv : Value t) (h : Typing Γ t (.arr A B)) :
∃ C b, t = .lam C 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 Value : {Δ : List Kind} → {m : Nat} → Tm Δ m → Prop where
| lam {Δ : List Kind} {m : Nat} (A : Ty Δ .star) (b : Tm Δ (m + 1)) :
Value (.lam A b)
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} (b : Tm (κ :: Δ) m) :
Value (.tabs b)
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:24
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
TheoremCanonical forms for Fω values of quantified type#✓fully proved
A value at a quantified type is a type lambda of the same binder kind.
theorem Value.all {κ : Kind} {C : Ty (κ :: Δ) .star} {t : Tm Δ m}
(hv : Value t) (h : Typing Γ t (.all C)) :
∃ b : Tm (κ :: Δ) m, t = .tabs b
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
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 Value : {Δ : List Kind} → {m : Nat} → Tm Δ m → Prop where
| lam {Δ : List Kind} {m : Nat} (A : Ty Δ .star) (b : Tm Δ (m + 1)) :
Value (.lam A b)
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} (b : Tm (κ :: Δ) m) :
Value (.tabs b)
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:24
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 13 · Used by 1
TheoremProgress for closed Fω terms#✓fully proved
Closed-term progress, allowing an arbitrary open kinded-type telescope.
theorem Typing.progress {Γ : Ctx Δ 0} {A : Ty Δ .star} {t : Tm Δ 0}
(h : Typing Γ t A) : Value t ∨ ∃ t', Step t t'
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:37
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
inductive Value : {Δ : List Kind} → {m : Nat} → Tm Δ m → Prop where
| lam {Δ : List Kind} {m : Nat} (A : Ty Δ .star) (b : Tm Δ (m + 1)) :
Value (.lam A b)
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} (b : Tm (κ :: Δ) m) :
Value (.tabs b)
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:24
inductive Step : {Δ : List Kind} → {m : Nat} → Tm Δ m → Tm Δ m → Prop where
| beta {Δ : List Kind} {m : Nat} {A : Ty Δ .star}
{b : Tm Δ (m + 1)} {a : Tm Δ m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tybeta {Δ : List Kind} {m : Nat} {κ : Kind}
(b : Tm (κ :: Δ) m) (a : Ty Δ κ) :
Step (.tapp (.tabs b) a) (b.tySubst (Ty.single a))
| appFun {Δ : List Kind} {m : Nat} {f f' a : Tm Δ m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {Δ : List Kind} {m : Nat} {f a a' : Tm Δ m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| tapp {Δ : List Kind} {m : Nat} {κ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:31
Uses 16 · Used by 1
TheoremType preservation along multistep Fω reduction#✓fully proved
Every finite weak-CBV reduction sequence preserves typing.
theorem Typing.preservation_steps {A : Ty Δ .star} {t t' : Tm Δ m}
(h : Typing Γ t A) (hs : Relation.ReflTransGen Step t t') :
Typing Γ t' A
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
inductive Step : {Δ : List Kind} → {m : Nat} → Tm Δ m → Tm Δ m → Prop where
| beta {Δ : List Kind} {m : Nat} {A : Ty Δ .star}
{b : Tm Δ (m + 1)} {a : Tm Δ m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tybeta {Δ : List Kind} {m : Nat} {κ : Kind}
(b : Tm (κ :: Δ) m) (a : Ty Δ κ) :
Step (.tapp (.tabs b) a) (b.tySubst (Ty.single a))
| appFun {Δ : List Kind} {m : Nat} {f f' a : Tm Δ m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {Δ : List Kind} {m : Nat} {f a a' : Tm Δ m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| tapp {Δ : List Kind} {m : Nat} {κ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:31
Uses 7 · Used by 1
TheoremType safety of Fω weak call-by-value reduction#✓fully proved
No reachable closed well-typed term is stuck, with type variables allowed.
theorem Typing.safety {Γ : Ctx Δ 0} {A : Ty Δ .star} {t t' : Tm Δ 0}
(h : Typing Γ t A) (hs : Relation.ReflTransGen Step t t') :
Value t' ∨ ∃ u, Step t' u
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:37
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
inductive Step : {Δ : List Kind} → {m : Nat} → Tm Δ m → Tm Δ m → Prop where
| beta {Δ : List Kind} {m : Nat} {A : Ty Δ .star}
{b : Tm Δ (m + 1)} {a : Tm Δ m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tybeta {Δ : List Kind} {m : Nat} {κ : Kind}
(b : Tm (κ :: Δ) m) (a : Ty Δ κ) :
Step (.tapp (.tabs b) a) (b.tySubst (Ty.single a))
| appFun {Δ : List Kind} {m : Nat} {f f' a : Tm Δ m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {Δ : List Kind} {m : Nat} {f a a' : Tm Δ m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| tapp {Δ : List Kind} {m : Nat} {κ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:31
inductive Value : {Δ : List Kind} → {m : Nat} → Tm Δ m → Prop where
| lam {Δ : List Kind} {m : Nat} (A : Ty Δ .star) (b : Tm Δ (m + 1)) :
Value (.lam A b)
| tabs {Δ : List Kind} {m : Nat} {κ : Kind} (b : Tm (κ :: Δ) m) :
Value (.tabs b)
CSLibExt/Languages/LambdaCalculus/FOmega/Safety.lean:24
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.