Higher-kinded relational parametricity of pure Fω
TheoremFundamental theorem of higher-kinded parametricity for Fω#✓fully proved
The full binary higher-kinded fundamental theorem of pure Fω.
theorem fundamental {Δ : List Kind} {m : Nat} {Γ : Ctx Δ m}
{t : Tm Δ m} {A : Ty Δ .star} (ht : Typing Γ t A)
(ρ : KEnv SystemF.Rel Δ) (σ τ : Fin m → SystemF.Model)
(hστ : ∀ i, ((Γ i).interpret ρ).holds (σ i) (τ i)) :
(A.interpret ρ).holds (Tm.close σ t) (Tm.close τ t)
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.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 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
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 close (σ : Fin m → SystemF.Model) (t : Tm Δ m) : SystemF.Model :=
SystemF.Tm.close σ (eraseSyntax t)
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:26
Uses 24 · Used by 1
TheoremClosed typed Fω terms are related to themselves#✓fully proved
Every closed-term typed expression is related to itself at every kind environment.
theorem fundamental_closed {Δ : List Kind} {Γ : Ctx Δ 0}
{t : Tm Δ 0} {A : Ty Δ .star} (ht : Typing Γ t A)
(ρ : KEnv SystemF.Rel Δ) :
(A.interpret ρ).holds (Tm.eraseModel t) (Tm.eraseModel t)
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.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 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
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 eraseModel (t : Tm Δ 0) : SystemF.Model := close Fin.elim0 t
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:30
Uses 11 · Used by 4
DefinitionHigher-kinded identity type#✓fully proved
A genuine higher-kind identity type: ∀ F : * → *, ∀ X : *, F X → F X.
def higherIdType {Δ : List Kind} : Ty Δ .star :=
.all (κ := .arrow .star .star) (.all (κ := .star)
(.arr (.app (.var (.succ .zero)) (.var .zero))
(.app (.var (.succ .zero)) (.var .zero))))
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
Uses 3 · Used by 3
DefinitionHigher-kinded polymorphic identity term#✓fully proved
The pure higher-kinded polymorphic identity term.
def higherId {Δ : List Kind} {m : Nat} : Tm Δ m :=
.tabs (κ := .arrow .star .star) (.tabs (κ := .star)
(.lam (.app (.var (.succ .zero)) (.var .zero)) (.var 0)))
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
Uses 4 · Used by 1
TheoremTyping of the higher-kinded identity#✓fully proved
The higher-kinded identity is typed in every existing term context.
theorem higherId_typed {Δ : List Kind} {m : Nat} (Γ : Ctx Δ m) :
Typing Γ higherId higherIdType
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
abbrev Ctx (Δ : List Kind) (m : Nat) := Fin m → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Terms.lean:37
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 higherId {Δ : List Kind} {m : Nat} : Tm Δ m :=
.tabs (κ := .arrow .star .star) (.tabs (κ := .star)
(.lam (.app (.var (.succ .zero)) (.var .zero)) (.var 0)))
CSLibExt/Languages/LambdaCalculus/FOmega/Parametricity.lean:77
def higherIdType {Δ : List Kind} : Ty Δ .star :=
.all (κ := .arrow .star .star) (.all (κ := .star)
(.arr (.app (.var (.succ .zero)) (.var .zero))
(.app (.var (.succ .zero)) (.var .zero))))
CSLibExt/Languages/LambdaCalculus/FOmega/Parametricity.lean:71
TheoremClosed inhabitants of the higher-kinded identity type are identities#✓fully proved
Every closed-term inhabitant is beta-identity at every kind-correct instantiation.
The inhabitant is arbitrary, not the manually defined higherId. The input
is any locally closed model term; no CBV termination or normalization is claimed.
theorem higher_kinded_identity {Δ : List Kind} {t : Tm Δ 0}
(ht : Typing Fin.elim0 t higherIdType)
(F : Ty Δ (.arrow .star .star)) (A : Ty Δ .star) (x : SystemF.Model) :
SystemF.BetaEq
(SystemF.Model.app (Tm.eraseModel (.tapp (.tapp t F) A)) x) x
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 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 higherIdType {Δ : List Kind} : Ty Δ .star :=
.all (κ := .arrow .star .star) (.all (κ := .star)
(.arr (.app (.var (.succ .zero)) (.var .zero))
(.app (.var (.succ .zero)) (.var .zero))))
CSLibExt/Languages/LambdaCalculus/FOmega/Parametricity.lean:71
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
abbrev BetaEq (f g : Model) : Prop :=
Relation.EqvGen Term.FullBeta f.val g.val
CSLibExt/Languages/LambdaCalculus/SystemF/Model.lean:30
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
def eraseModel (t : Tm Δ 0) : SystemF.Model := close Fin.elim0 t
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:30
Uses 21
TheoremHigher-kinded identity inhabitants preserve admissible relations#✓fully proved
Different higher-kind type instantiations preserve every admissible binary relation.
theorem higher_kinded_related {Δ : List Kind} {t : Tm Δ 0}
(ht : Typing Fin.elim0 t higherIdType)
(F G : Ty Δ (.arrow .star .star)) (A B : Ty Δ .star)
(Φ : SystemF.Rel → SystemF.Rel) (R : SystemF.Rel)
{x y : SystemF.Model} (hxy : (Φ R).holds x y) :
(Φ R).holds
(SystemF.Model.app (Tm.eraseModel (.tapp (.tapp t F) A)) x)
(SystemF.Model.app (Tm.eraseModel (.tapp (.tapp t G) B)) y)
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 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 higherIdType {Δ : List Kind} : Ty Δ .star :=
.all (κ := .arrow .star .star) (.all (κ := .star)
(.arr (.app (.var (.succ .zero)) (.var .zero))
(.app (.var (.succ .zero)) (.var .zero))))
CSLibExt/Languages/LambdaCalculus/FOmega/Parametricity.lean:71
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
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
def eraseModel (t : Tm Δ 0) : SystemF.Model := close Fin.elim0 t
CSLibExt/Languages/LambdaCalculus/FOmega/Closing.lean:30
Uses 14
TheoremNo closed Fω term inhabits \(\forall X, X\)#✓fully proved
The empty relation excludes all closed-term inhabitants of ∀ X : *, X.
theorem forall_var_uninhabited {Δ : List Kind} (t : Tm Δ 0) :
¬ Typing Fin.elim0 t (.all (κ := .star) (.var .zero))
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 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
TheoremNo closed Fω term inhabits \(\forall F, \forall X, F\,X\)#✓fully proved
A constant empty operator excludes ∀ F : * → *, ∀ X : *, F X.
theorem higher_result_uninhabited {Δ : List Kind} (t : Tm Δ 0) :
¬ Typing Fin.elim0 t (.all (κ := .arrow .star .star)
(.all (κ := .star) (.app (.var (.succ .zero)) (.var .zero))))
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 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
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.