The star/forall System F fragment inside pure Fω
Type translation
DefinitionLifting System F type-variable images under a star binder#✓fully proved
Extend images of System F type variables under a star-kinded binder.
def liftTypes {n : Nat} {Δ : List Kind} (φ : Fin n → Ty Δ .star) :
Fin (n + 1) → Ty (.star :: Δ) .star :=
Fin.cases (.var .zero) (fun i => (φ i).rename KVar.succ)
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 KVar : List Kind → Kind → Type where
| zero {Δ : List Kind} {κ : Kind} : KVar (κ :: Δ) κ
| succ {Δ : List Kind} {κ μ : Kind} : KVar Δ κ → KVar (μ :: Δ) κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:43
Uses 4 · Used by 18
DefinitionTranslation of System F types into Fω#✓fully proved
Translate System F types with arbitrary kind-star variable images.
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) 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 Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def liftTypes {n : Nat} {Δ : List Kind} (φ : Fin n → Ty Δ .star) :
Fin (n + 1) → Ty (.star :: Δ) .star :=
Fin.cases (.var .zero) (fun i => (φ i).rename KVar.succ)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:25
Uses 4 · Used by 18
Properties of the type translation
TheoremType translation depends only on variable images#✓fully proved
The translation depends only on the images of free type variables.
theorem fromSystemF_congr {φ ψ : Fin n → Ty Δ .star}
(h : ∀ i, φ i = ψ i) (t : SystemF.Ty n) :
fromSystemF φ t = fromSystemF ψ 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 Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 4 · Used by 5
TheoremType translation commutes with target renaming#✓fully proved
Target kind-preserving renaming commutes with the System F translation.
theorem fromSystemF_target_rename (φ : Fin n → Ty Δ .star)
(ρ : KRen Δ Ε) (t : SystemF.Ty n) :
(fromSystemF φ t).rename ρ =
fromSystemF (fun i => (φ i).rename ρ) 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
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 12 · Used by 3
TheoremType translation commutes with target substitution#✓fully proved
Target type substitution commutes with the System F translation.
theorem fromSystemF_target_subst (φ : Fin n → Ty Δ .star)
(σ : Sub Δ Ε) (t : SystemF.Ty n) :
(fromSystemF φ t).subst σ =
fromSystemF (fun i => (φ i).subst σ) 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
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 10 · Used by 2
TheoremType translation of a source renaming#✓fully proved
Source type renaming is precomposition of the translated variable images.
theorem fromSystemF_source_rename (φ : Fin k → Ty Δ .star)
(ρ : Fin n → Fin k) (t : SystemF.Ty n) :
fromSystemF φ (t.rename ρ) = fromSystemF (fun i => φ (ρ i)) 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 Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 8 · Used by 3
TheoremType translation of a source substitution#✓fully proved
Source type substitution translates to simultaneous operator images.
theorem fromSystemF_source_subst (φ : Fin k → Ty Δ .star)
(σ : Fin n → SystemF.Ty k) (t : SystemF.Ty n) :
fromSystemF φ (t.subst σ) =
fromSystemF (fun i => fromSystemF φ (σ i)) 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 Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 12 · Used by 2
TheoremType translation commutes with type-binder instantiation#✓fully proved
The System F translation commutes with type-binder instantiation.
theorem fromSystemF_instantiate (φ : Fin n → Ty Δ .star)
(B : SystemF.Ty (n + 1)) (A : SystemF.Ty n) :
fromSystemF φ (B.instantiate A) =
(fromSystemF (liftTypes φ) B).instantiate (fromSystemF φ 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 Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
def liftTypes {n : Nat} {Δ : List Kind} (φ : Fin n → Ty Δ .star) :
Fin (n + 1) → Ty (.star :: Δ) .star :=
Fin.cases (.var .zero) (fun i => (φ i).rename KVar.succ)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:25
Uses 15 · Used by 1
Term translation
DefinitionTranslation of System F terms into Fω#✓fully proved
Translate all five System F term constructors, retaining type binders.
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
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 : 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
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 Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
def liftTypes {n : Nat} {Δ : List Kind} (φ : Fin n → Ty Δ .star) :
Fin (n + 1) → Ty (.star :: Δ) .star :=
Fin.cases (.var .zero) (fun i => (φ i).rename KVar.succ)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:25
Uses 7 · Used by 13
TheoremTerm translation preserves System F typing#✓fully proved
Every System F typing derivation is preserved by the star translation.
theorem Tm.fromSystemF_typing {n m : Nat} {Δ : List Kind}
{Γ : SystemF.Ctx n m} {t : SystemF.Tm n m} {A : SystemF.Ty n}
(h : SystemF.Typing Γ t A) (φ : Fin n → Ty Δ .star) :
Typing (fun i => Ty.fromSystemF φ (Γ i)) (fromSystemF φ t)
(Ty.fromSystemF φ A)
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Ctx (n m : Nat) := Fin m → Ty n
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:92
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
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
inductive Typing : {n m : Nat} → Ctx n m → Tm n m → Ty n → Prop where
| var {n m : Nat} {Γ : Ctx n m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {n m : Nat} {Γ : Ctx n m} {A B : Ty n} {b : Tm n (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {n m : Nat} {Γ : Ctx n m} {A B : Ty n} {f a : Tm n m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {n m : Nat} {Γ : Ctx n m} {b : Tm (n + 1) m} {C : Ty (n + 1)} :
Typing (fun i => (Γ i).rename Fin.succ) b C →
Typing Γ (.tabs b) (.all C)
| tapp {n m : Nat} {Γ : Ctx n m} {f : Tm n m} {A : Ty n}
{C : Ty (n + 1)} :
⋯
CSLibExt/Languages/LambdaCalculus/SystemF/Typing.lean:25
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
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 20 · Used by 1
DefinitionStar-kinded variable of an all-star telescope#✓fully proved
The corresponding star-kinded variable in an n-star telescope.
def KVar.ofFin : {n : Nat} → Fin n → KVar (List.replicate n .star) .star
| 0, i => nomatch i
| _n + 1, i => Fin.cases .zero (fun j => .succ (ofFin j)) i
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
Uses 2 · Used by 6
DefinitionCanonical embedding of System F types into Fω#✓fully proved
The canonical variable-for-variable embedding of System F types.
def Ty.embed {n : Nat} (t : SystemF.Ty n) : Ty (List.replicate n .star) .star :=
fromSystemF (fun i => .var (KVar.ofFin i)) t
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
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 Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
def KVar.ofFin : {n : Nat} → Fin n → KVar (List.replicate n .star) .star
| 0, i => nomatch i
| _n + 1, i => Fin.cases .zero (fun j => .succ (ofFin j)) i
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:170
Uses 6 · Used by 2
DefinitionCanonical embedding of System F terms into Fω#✓fully proved
The canonical scoped embedding of System F terms into pure Fω.
def Tm.embed {n m : Nat} (t : SystemF.Tm n m) : Tm (List.replicate n .star) m :=
fromSystemF (fun i => .var (KVar.ofFin i)) t
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
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 Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
def KVar.ofFin : {n : Nat} → Fin n → KVar (List.replicate n .star) .star
| 0, i => nomatch i
| _n + 1, i => Fin.cases .zero (fun j => .succ (ofFin j)) i
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:170
TheoremCanonical embedding preserves System F typing#✓fully proved
Canonical embedding preserves every System F typing derivation.
theorem Tm.embed_typing {n m : Nat} {Γ : SystemF.Ctx n m}
{t : SystemF.Tm n m} {A : SystemF.Ty n} (h : SystemF.Typing Γ t A) :
Typing (fun i => Ty.embed (Γ i)) (Tm.embed t) (Ty.embed A)
abbrev Ctx (n m : Nat) := Fin m → Ty n
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:92
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
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
inductive Typing : {n m : Nat} → Ctx n m → Tm n m → Ty n → Prop where
| var {n m : Nat} {Γ : Ctx n m} (i : Fin m) :
Typing Γ (.var i) (Γ i)
| lam {n m : Nat} {Γ : Ctx n m} {A B : Ty n} {b : Tm n (m + 1)} :
Typing (Fin.cases A Γ) b B → Typing Γ (.lam A b) (.arr A B)
| app {n m : Nat} {Γ : Ctx n m} {A B : Ty n} {f a : Tm n m} :
Typing Γ f (.arr A B) → Typing Γ a A → Typing Γ (.app f a) B
| tabs {n m : Nat} {Γ : Ctx n m} {b : Tm (n + 1) m} {C : Ty (n + 1)} :
Typing (fun i => (Γ i).rename Fin.succ) b C →
Typing Γ (.tabs b) (.all C)
| tapp {n m : Nat} {Γ : Ctx n m} {f : Tm n m} {A : Ty n}
{C : Ty (n + 1)} :
⋯
CSLibExt/Languages/LambdaCalculus/SystemF/Typing.lean:25
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
def Ty.embed {n : Nat} (t : SystemF.Ty n) : Ty (List.replicate n .star) .star :=
fromSystemF (fun i => .var (KVar.ofFin i)) t
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:175
def Tm.embed {n m : Nat} (t : SystemF.Tm n m) : Tm (List.replicate n .star) m :=
fromSystemF (fun i => .var (KVar.ofFin i)) t
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:179
Uses 12
TheoremTerm translation depends only on type-variable images#✓fully proved
Term translation depends only on the images of its free type variables.
theorem Tm.fromSystemF_congr {n m : Nat} {Δ : List Kind}
{φ ψ : Fin n → Ty Δ .star} (h : ∀ i, φ i = ψ i) (t : SystemF.Tm n m) :
fromSystemF φ t = fromSystemF ψ 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 : 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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 5 · Used by 3
TheoremTerm translation commutes with target type substitution#✓fully proved
Operator substitution commutes with translating System F terms.
theorem Tm.fromSystemF_target_tySubst {n m : Nat} {Δ Ε : List Kind}
(φ : Fin n → Ty Δ .star) (σ : Ty.Sub Δ Ε) (t : SystemF.Tm n m) :
(fromSystemF φ t).tySubst σ =
fromSystemF (fun i => (φ i).subst σ) 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
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 15 · Used by 2
TheoremTerm translation of a source type substitution#✓fully proved
Source type substitution commutes with the pure-term translation.
theorem Tm.fromSystemF_source_tySubst {n k m : Nat} {Δ : List Kind}
(φ : Fin k → Ty Δ .star) (σ : Fin n → SystemF.Ty k)
(t : SystemF.Tm n m) :
fromSystemF φ (t.tySubst σ) =
fromSystemF (fun i => Ty.fromSystemF φ (σ i)) 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 Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 17 · Used by 2
TheoremTerm translation commutes with weakening under a type binder#✓fully proved
Weakening beneath a type binder agrees in both calculus presentations.
theorem Tm.fromSystemF_tyRename_succ {n m : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (t : SystemF.Tm n m) :
fromSystemF (liftTypes φ) (t.tyRename Fin.succ) =
(fromSystemF φ t).tyRename KVar.succ
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 : 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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
def liftTypes {n : Nat} {Δ : List Kind} (φ : Fin n → Ty Δ .star) :
Fin (n + 1) → Ty (.star :: Δ) .star :=
Fin.cases (.var .zero) (fun i => (φ i).rename KVar.succ)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.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
Uses 16 · Used by 1
TheoremTerm translation commutes with term-variable renaming#✓fully proved
Term-variable renaming commutes with the System F translation.
theorem Tm.fromSystemF_rename {n m k : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (ρ : Fin m → Fin k) (t : SystemF.Tm n m) :
fromSystemF φ (t.rename ρ) = (fromSystemF φ t).rename ρ
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 : 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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 11 · Used by 1
TheoremTerm translation commutes with term substitution#✓fully proved
Simultaneous term substitution commutes with the System F translation.
theorem Tm.fromSystemF_subst {n m k : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (σ : Fin m → SystemF.Tm n k)
(t : SystemF.Tm n m) :
fromSystemF φ (t.subst σ) =
(fromSystemF φ t).subst (fun i => fromSystemF φ (σ i))
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 : 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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 17 · Used by 1
TheoremTerm translation commutes with term-binder instantiation#✓fully proved
Term-binder instantiation commutes with the System F translation.
theorem Tm.fromSystemF_instantiate {n m : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (b : SystemF.Tm n (m + 1))
(a : SystemF.Tm n m) :
fromSystemF φ (b.instantiate a) =
(fromSystemF φ b).instantiate (fromSystemF φ a)
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 : 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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
TheoremTerm translation commutes with type-binder instantiation#✓fully proved
Type-binder discharge agrees for translated System F terms.
theorem Tm.fromSystemF_tyInstantiate {n m : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (b : SystemF.Tm (n + 1) m)
(A : SystemF.Ty n) :
fromSystemF φ (b.tySubst (Fin.cases A SystemF.Ty.var)) =
(fromSystemF (liftTypes φ) b).tySubst (Ty.single (Ty.fromSystemF φ A))
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 : 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
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
def liftTypes {n : Nat} {Δ : List Kind} (φ : Fin n → Ty Δ .star) :
Fin (n + 1) → Ty (.star :: Δ) .star :=
Fin.cases (.var .zero) (fun i => (φ i).rename KVar.succ)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:25
def single {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Sub (κ :: Δ) Δ
| _, .zero => a
| _, .succ x => .var x
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:100
def Ty.fromSystemF : {n : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Ty n → Ty Δ .star
| _, _, φ, .var i => φ i
| _, _, φ, .arr A B => .arr (fromSystemF φ A) (fromSystemF φ B)
| _, _, φ, .all B => .all (fromSystemF (liftTypes φ) B)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:30
Uses 19 · Used by 1
TheoremTerm translation preserves weak call-by-value values#✓fully proved
The System F translation preserves both weak-CBV value forms.
theorem Tm.fromSystemF_value {n m : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) {t : SystemF.Tm n m} (h : SystemF.Value t) :
Value (fromSystemF φ 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 : 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
inductive Value : {n m : Nat} → Tm n m → Prop where
| lam {n m : Nat} {A : Ty n} {b : Tm n (m + 1)} : Value (.lam A b)
| tabs {n m : Nat} {b : Tm (n + 1) m} : Value (.tabs b)
CSLibExt/Languages/LambdaCalculus/SystemF/Semantics.lean:24
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 Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 10 · Used by 1
TheoremTerm translation simulates each weak call-by-value step#✓fully proved
Every System F weak-CBV step is simulated by one Fω weak-CBV step.
theorem Tm.fromSystemF_step {n m : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) {t t' : SystemF.Tm n m}
(h : SystemF.Step t t') : Step (fromSystemF φ t) (fromSystemF φ 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 : 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
inductive Step : {n m : Nat} → Tm n m → Tm n m → Prop where
| appFun {n m : Nat} {f f' a : Tm n m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {n m : Nat} {f a a' : Tm n m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| beta {n m : Nat} {A : Ty n} {b : Tm n (m + 1)} {a : Tm n m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tappFun {n m : Nat} {f f' : Tm n m} {A : Ty n} :
Step f f' → Step (.tapp f A) (.tapp f' A)
| tyBeta {n m : Nat} {b : Tm (n + 1) m} {A : Ty n} :
Step (.tapp (.tabs b) A) (b.tySubst (Fin.cases A Ty.var))
CSLibExt/Languages/LambdaCalculus/SystemF/Semantics.lean:29
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
def Tm.fromSystemF : {n m : Nat} → {Δ : List Kind} →
(Fin n → Ty Δ .star) → SystemF.Tm n m → Tm Δ m
| _, _, _, _, .var i => .var i
| _, _, _, φ, .lam A b => .lam (Ty.fromSystemF φ A) (fromSystemF φ b)
| _, _, _, φ, .app f a => .app (fromSystemF φ f) (fromSystemF φ a)
| _, _, _, φ, .tabs b => .tabs (fromSystemF (liftTypes φ) b)
| _, _, _, φ, .tapp f A => .tapp (fromSystemF φ f) (Ty.fromSystemF φ A)
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:139
Uses 20 · Used by 1
TheoremCanonical embedding preserves single evaluation steps#✓fully proved
The canonical embedding preserves individual System F evaluation steps.
theorem Tm.embed_step {n m : Nat} {t t' : SystemF.Tm n m}
(h : SystemF.Step t t') : Step (Tm.embed t) (Tm.embed t')
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
inductive Step : {n m : Nat} → Tm n m → Tm n m → Prop where
| appFun {n m : Nat} {f f' a : Tm n m} :
Step f f' → Step (.app f a) (.app f' a)
| appArg {n m : Nat} {f a a' : Tm n m} :
Value f → Step a a' → Step (.app f a) (.app f a')
| beta {n m : Nat} {A : Ty n} {b : Tm n (m + 1)} {a : Tm n m} :
Value a → Step (.app (.lam A b) a) (b.instantiate a)
| tappFun {n m : Nat} {f f' : Tm n m} {A : Ty n} :
Step f f' → Step (.tapp f A) (.tapp f' A)
| tyBeta {n m : Nat} {b : Tm (n + 1) m} {A : Ty n} :
Step (.tapp (.tabs b) A) (b.tySubst (Fin.cases A Ty.var))
CSLibExt/Languages/LambdaCalculus/SystemF/Semantics.lean:29
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
def Tm.embed {n m : Nat} (t : SystemF.Tm n m) : Tm (List.replicate n .star) m :=
fromSystemF (fun i => .var (KVar.ofFin i)) t
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:179
Uses 9 · Used by 1
TheoremCanonical embedding preserves multistep evaluation#✓fully proved
The canonical embedding preserves finite System F evaluation sequences.
theorem Tm.embed_steps {n m : Nat} {t t' : SystemF.Tm n m}
(h : SystemF.Steps t t') :
Relation.ReflTransGen Step (Tm.embed t) (Tm.embed t')
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
abbrev Steps {n m : Nat} : Tm n m → Tm n m → Prop :=
Relation.ReflTransGen Step
CSLibExt/Languages/LambdaCalculus/SystemF/Semantics.lean:42
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
def Tm.embed {n m : Nat} (t : SystemF.Tm n m) : Tm (List.replicate n .star) m :=
fromSystemF (fun i => .var (KVar.ofFin i)) t
CSLibExt/Languages/LambdaCalculus/FOmega/Embedding.lean:179
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.