Proved type-beta conversion for pure Fω
InductiveType-beta conversion in Fω#✓fully proved
Type-beta conversion at a fixed context and kind.
Cslib.Languages.LambdaCalculus.FOmega.Ty.Conv · 18 lines
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}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Conv f g → Conv a b → Conv (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Conv a a' → Conv b b' → Conv (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Conv b c → Conv (.all b) (.all c)
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
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
Uses 3 · Used by 24
TheoremSoundness of type-beta conversion in kind algebras#✓fully proved
Every type-beta conversion is sound in every semantic kind algebra.
theorem Conv.sound {α : Type*} (h : Conv a b) (M : KindAlgebra α)
(η : KEnv α Δ) : eval M η a = eval M η b
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
structure KindAlgebra (α : Type u) where
arr : α → α → α
all : {κ : Kind} → (Kind.Sem α κ → α) → α
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:41
abbrev KEnv (α : Type u) (Δ : List Kind) :=
∀ {κ}, KVar Δ κ → Kind.Sem α κ
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:31
def eval (M : KindAlgebra α) : {Δ : List Kind} → KEnv α Δ →
{κ : Kind} → Ty Δ κ → Kind.Sem α κ
| _, ρ, _, .var x => ρ x
| _, ρ, _, .lam b => fun a => eval M (KEnv.extend ρ a) b
| _, ρ, _, .app f a => eval M ρ f (eval M ρ a)
| _, ρ, _, .arr a b => M.arr (eval M ρ a) (eval M ρ b)
| _, ρ, _, .all b => M.all (fun a => eval M (KEnv.extend ρ a) b)
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:50
Uses 10 · Used by 2
TheoremType-beta conversion is stable under renaming#✓fully proved
Kind-preserving renaming respects proved type-beta conversion.
theorem Conv.rename (h : Conv a b) (ρ : KRen Δ Ε) :
Conv (Ty.rename ρ a) (Ty.rename ρ b)
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
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
Uses 8 · Used by 1
TheoremType-beta conversion is stable under substitution#✓fully proved
Kind-preserving substitution respects proved type-beta conversion.
theorem Conv.subst (h : Conv a b) (σ : Sub Δ Ε) :
Conv (Ty.subst σ a) (Ty.subst σ b)
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
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
def subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
Uses 8 · Used by 2
TheoremPointwise convertible substitutions give convertible results#✓fully proved
Pointwise convertible substitution images give convertible results.
theorem Conv.subst_congr {σ τ : Sub Δ Ε}
(h : ∀ {ν} (x : KVar Δ ν), Conv (σ x) (τ x)) (t : Ty Δ κ) :
Conv (Ty.subst σ t) (Ty.subst τ t)
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
TheoremFunction types are not convertible to quantified types#✓fully proved
Term-function arrows cannot convert to quantified types, at any kind.
theorem not_conv_arr_all {a b : Ty Δ .star} {body : Ty (μ :: Δ) .star} :
¬ Conv (.arr a b) (.all body)
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 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 2
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.