System F embedding agreement with the single term/relation model
TheoremTranslated System F terms have the same closing instances#✓fully proved
Translated System F terms have exactly the same model closing instances.
theorem Tm.close_fromSystemF {n m : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (σ : Fin m → SystemF.Model) (t : SystemF.Tm n m) :
close σ (fromSystemF φ t) = SystemF.Tm.close σ 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 Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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 close {n m : Nat} (σ : Fin m → Model) (t : Tm n m) : Model :=
⟨eraseWith (fun i => (σ i).val) t,
eraseWith_lcAt _ t (fun i => (σ i).property)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Erasure.lean:140
Uses 14 · Used by 1
TheoremCanonical embedding preserves closing instances#✓fully proved
Canonical embedding preserves arbitrary model closing instances exactly.
theorem Tm.close_embed {n m : Nat} (σ : Fin m → SystemF.Model)
(t : SystemF.Tm n m) : close σ (Tm.embed t) = SystemF.Tm.close σ t
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
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
def close {n m : Nat} (σ : Fin m → Model) (t : Tm n m) : Model :=
⟨eraseWith (fun i => (σ i).val) t,
eraseWith_lcAt _ t (fun i => (σ i).property)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Erasure.lean:140
Uses 10 · Used by 1
TheoremCanonical embedding preserves model erasure#✓fully proved
A System F term and its Fω embedding have identical model erasures.
theorem Tm.eraseModel_embed {n : Nat} (t : SystemF.Tm n 0) :
eraseModel (Tm.embed t) = SystemF.Tm.eraseModel 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
def eraseModel (t : Tm Δ 0) : SystemF.Model := close Fin.elim0 t
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:30
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
def eraseModel {n : Nat} (t : Tm n 0) : Model := close Fin.elim0 t
CSLibExt/Languages/LambdaCalculus/SystemF/Erasure.lean:145
TheoremType translation preserves the relational interpretation#✓fully proved
The star/forall translation preserves the same binary type interpretation.
theorem Ty.interpret_fromSystemF {n : Nat} {Δ : List Kind}
(φ : Fin n → Ty Δ .star) (ρ : KEnv SystemF.Rel Δ) (A : SystemF.Ty n) :
(fromSystemF φ A).interpret ρ =
A.interpret (fun i => (φ i).interpret ρ)
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 KEnv (α : Type u) (Δ : List Kind) :=
∀ {κ}, KVar Δ κ → Kind.Sem α κ
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
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 14 · Used by 1
TheoremRelational interpretation of canonically embedded types#✓fully proved
Canonical embedding interprets each source variable by its matching kinded lookup.
theorem Ty.interpret_embed {n : Nat} (A : SystemF.Ty n)
(ρ : KEnv SystemF.Rel (List.replicate n .star)) :
(Ty.embed A).interpret ρ = A.interpret (fun i => ρ (KVar.ofFin i))
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
abbrev KEnv (α : Type u) (Δ : List Kind) :=
∀ {κ}, KVar Δ κ → Kind.Sem α κ
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
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 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 12
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.