Higher-kinded relational interpretation of Fω types
Relational interpretation of Fω
DefinitionKind algebra of beta-invariant relations#✓fully proved
The generic kind algebra instantiated with the banked relation substrate.
def relationalAlgebra : KindAlgebra SystemF.Rel where
arr := SystemF.Rel.arrow
all := fun {_} => SystemF.Rel.universal
structure KindAlgebra (α : Type u) where
arr : α → α → α
all : {κ : Kind} → (Kind.Sem α κ → α) → α
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:41
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 arrow (A B : Rel) : Rel where
holds f g := ∀ x y, A.holds x y → B.holds (Model.app f x) (Model.app g y)
congr hff' hgg' := ⟨
fun h x y hxy => (B.congr (hff'.appFun x) (hgg'.appFun y)).mp (h x y hxy),
fun h x y hxy => (B.congr (hff'.appFun x) (hgg'.appFun y)).mpr (h x y hxy)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:45
def universal {ι : Sort u} (family : ι → Rel) : Rel where
holds f g := ∀ i, (family i).holds f g
congr hff' hgg' := ⟨
fun h i => ((family i).congr hff' hgg').mp (h i),
fun h i => ((family i).congr hff' hgg').mpr (h i)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:54
Uses 6 · Used by 7
DefinitionRelational interpretation of Fω types#✓fully proved
A kinded type denotes a relation or an appropriately kinded function.
def Ty.interpret {Δ : List Kind} {κ : Kind} (t : Ty Δ κ)
(ρ : KEnv SystemF.Rel Δ) : Kind.Sem SystemF.Rel κ :=
t.eval relationalAlgebra ρ
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
def Kind.Sem (α : Type u) : Kind → Type u
| .star => α
| .arrow κ μ => Kind.Sem α κ → Kind.Sem α μ
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:26
def relationalAlgebra : KindAlgebra SystemF.Rel where
arr := SystemF.Rel.arrow
all := fun {_} => SystemF.Rel.universal
CSLibExt/Languages/LambdaCalculus/FOmega/RelationalTypes.lean:34
Uses 7 · Used by 12
Substitution and type-beta conversion
TheoremRelational interpretation of a substituted Fω type#✓fully proved
Relational substitution at every kind, with arbitrary higher-kind values.
theorem interpret_subst (t : Ty Δ κ) (σ : Ty.Sub Δ Ε)
(ρ : KEnv SystemF.Rel Ε) :
(t.subst σ).interpret ρ =
t.interpret (fun {_} x => (σ x).interpret ρ)
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
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
Uses 11
TheoremType-beta conversion preserves the relational interpretation#✓fully proved
Proved type-beta conversion is sound for the higher-kinded relations.
theorem Conv.interpret {a b : Ty Δ κ} (h : Conv a b)
(ρ : KEnv SystemF.Rel Δ) : a.interpret ρ = b.interpret ρ
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
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
Uses 9 · Used by 1
TheoremRelational interpretation of a renamed Fω type#✓fully proved
Type renaming transports an arbitrary higher-kinded relation environment.
theorem interpret_rename (t : Ty Δ κ) (η : KRen Δ Ε)
(ρ : KEnv SystemF.Rel Ε) :
(t.rename η).interpret ρ = t.interpret (fun {_} x => ρ (η x))
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
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
Uses 11 · Used by 1
TheoremRelational interpretation of an instantiated Fω type#✓fully proved
A kinded type argument is interpreted before its universal is discharged.
theorem interpret_instantiate (b : Ty (μ :: Δ) κ) (a : Ty Δ μ)
(ρ : KEnv SystemF.Rel Δ) :
(b.instantiate a).interpret ρ =
b.interpret (KEnv.extend ρ (a.interpret ρ))
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
def KEnv.extend {α : Type u} {Δ : List Kind} {κ : Kind}
(ρ : KEnv α Δ) (a : Kind.Sem α κ) : KEnv α (κ :: Δ)
| _, .zero => a
| _, .succ x => ρ x
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:35
Uses 10 · Used by 1
TheoremRelational interpretation of an Fω universal type#✓fully proved
A universal quantifies every semantic value of its bound kind.
@[simp] theorem interpret_all {b : Ty (κ :: Δ) .star}
(ρ : KEnv SystemF.Rel Δ) (f g : SystemF.Model) :
((Ty.all b).interpret ρ).holds f g ↔
∀ R : Kind.Sem SystemF.Rel κ,
(b.interpret (KEnv.extend ρ R)).holds f g
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
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
def Kind.Sem (α : Type u) : Kind → Type u
| .star => α
| .arrow κ μ => Kind.Sem α κ → Kind.Sem α μ
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:26
def KEnv.extend {α : Type u} {Δ : List Kind} {κ : Kind}
(ρ : KEnv α Δ) (a : Kind.Sem α κ) : KEnv α (κ :: Δ)
| _, .zero => a
| _, .succ x => ρ x
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:35
Uses 8
TheoremRelational interpretation of an Fω function type#✓fully proved
An arrow relates every related pair of inputs at its codomain.
@[simp] theorem interpret_arr (a b : Ty Δ .star)
(ρ : KEnv SystemF.Rel Δ) (f g : SystemF.Model) :
((Ty.arr a b).interpret ρ).holds f g ↔
∀ x y, (a.interpret ρ).holds x y →
(b.interpret ρ).holds (SystemF.Model.app f x) (SystemF.Model.app g y)
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
abbrev Model : Type := {t : Term Nat // t.LcAt 0}
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:27
def app (f a : Model) : Model :=
⟨.app f.val a.val, by
simpa only [Term.LcAt, Bool.and_eq_true] using
And.intro f.property a.property⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:36
TheoremRelational interpretation of a weakened Fω type#✓fully proved
Weakening ignores the arbitrary new semantic value, at every binder kind.
@[simp] theorem interpret_weaken (t : Ty Δ κ) (ρ : KEnv SystemF.Rel Δ)
(R : Kind.Sem SystemF.Rel μ) :
(t.rename KVar.succ).interpret (KEnv.extend ρ R) = t.interpret ρ
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
def Kind.Sem (α : Type u) : Kind → Type u
| .star => α
| .arrow κ μ => Kind.Sem α κ → Kind.Sem α μ
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:26
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 KEnv.extend {α : Type u} {Δ : List Kind} {κ : Kind}
(ρ : KEnv α Δ) (a : Kind.Sem α κ) : KEnv α (κ :: Δ)
| _, .zero => a
| _, .succ x => ρ x
CSLibExt/Languages/LambdaCalculus/FOmega/KindSemantics.lean:35
Uses 10 · Used by 2
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.