Scoped pure System F
System F
InductiveScoped types of pure System F#✓fully proved
Pure System F types with n available type variables.
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
Used by 89
DefinitionLifting a scoped renaming under a binder#✓fully proved
Extend a scoped renaming, preserving the newly bound variable.
def liftRen {n k : Nat} (ρ : Fin n → Fin k) :
Fin (n + 1) → Fin (k + 1) :=
Fin.cases 0 (fun i => (ρ i).succ)
Used by 18
TheoremLifted renaming fixes the newly bound variable#✓fully proved
The new variable is unaffected by a lifted renaming.
@[simp] theorem liftRen_zero {n k : Nat} (ρ : Fin n → Fin k) :
liftRen ρ 0 = 0
def liftRen {n k : Nat} (ρ : Fin n → Fin k) :
Fin (n + 1) → Fin (k + 1) :=
Fin.cases 0 (fun i => (ρ i).succ)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:38
Uses 1
TheoremLifted renaming shifts each renamed old variable#✓fully proved
A lifted renaming shifts every renamed old variable.
@[simp] theorem liftRen_succ {n k : Nat} (ρ : Fin n → Fin k)
(i : Fin n) : liftRen ρ i.succ = (ρ i).succ
def liftRen {n k : Nat} (ρ : Fin n → Fin k) :
Fin (n + 1) → Fin (k + 1) :=
Fin.cases 0 (fun i => (ρ i).succ)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:38
Uses 1
Type renaming and substitution
DefinitionType-variable renaming in System F types#✓fully proved
Capture-avoiding renaming of type variables.
@[simp] def rename {n k : Nat} (ρ : Fin n → Fin k) : Ty n → Ty k
| .var i => .var (ρ i)
| .arr A B => .arr (rename ρ A) (rename ρ B)
| .all B => .all (rename (liftRen ρ) B)
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 liftRen {n k : Nat} (ρ : Fin n → Fin k) :
Fin (n + 1) → Fin (k + 1) :=
Fin.cases 0 (fun i => (ρ i).succ)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:38
Uses 2 · Used by 26
DefinitionLifting a type substitution under a type binder#✓fully proved
Lift a type substitution under one type binder.
def liftSub {n k : Nat} (σ : Fin n → Ty k) : Fin (n + 1) → Ty (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ 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
@[simp] def rename {n k : Nat} (ρ : Fin n → Fin k) : Ty n → Ty k
| .var i => .var (ρ i)
| .arr A B => .arr (rename ρ A) (rename ρ B)
| .all B => .all (rename (liftRen ρ) B)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:53
Uses 2 · Used by 16
DefinitionSimultaneous type substitution in System F types#✓fully proved
Simultaneous, capture-avoiding type substitution.
@[simp] def subst {n k : Nat} (σ : Fin n → Ty k) : Ty n → Ty k
| .var i => σ i
| .arr A B => .arr (subst σ A) (subst σ B)
| .all B => .all (subst (liftSub σ) B)
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 liftSub {n k : Nat} (σ : Fin n → Ty k) : Fin (n + 1) → Ty (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ i))
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:59
Uses 2 · Used by 18
DefinitionInstantiating the newest type binder of a type#✓fully proved
Discharge the newest type binder by an arbitrary type.
def instantiate {n : Nat} (B : Ty (n + 1)) (A : Ty n) : Ty n :=
subst (Fin.cases A Ty.var) B
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
@[simp] def subst {n k : Nat} (σ : Fin n → Ty k) : Ty n → Ty k
| .var i => σ i
| .arr A B => .arr (subst σ A) (subst σ B)
| .all B => .all (subst (liftSub σ) B)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:63
Uses 2 · Used by 15
TheoremLifted type substitution fixes the fresh variable#✓fully proved
The fresh type variable is fixed by a lifted substitution.
@[simp] theorem liftSub_zero {n k : Nat} (σ : Fin n → Ty k) :
liftSub σ 0 = .var 0
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 liftSub {n k : Nat} (σ : Fin n → Ty k) : Fin (n + 1) → Ty (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ i))
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:59
Uses 2
TheoremLifted type substitution weakens old images#✓fully proved
Old type-substitution images are weakened under a binder.
@[simp] theorem liftSub_succ {n k : Nat} (σ : Fin n → Ty k)
(i : Fin n) : liftSub σ i.succ = rename Fin.succ (σ 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
def liftSub {n k : Nat} (σ : Fin n → Ty k) : Fin (n + 1) → Ty (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ i))
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:59
@[simp] def rename {n k : Nat} (ρ : Fin n → Fin k) : Ty n → Ty k
| .var i => .var (ρ i)
| .arr A B => .arr (rename ρ A) (rename ρ B)
| .all B => .all (rename (liftRen ρ) B)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:53
System F
InductiveScoped terms of pure System F#✓fully proved
Pure terms with n type variables and m term variables.
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
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
Uses 1 · Used by 76
AbbreviationTerm variable contexts of System F#✓fully proved
An ordered, unrestricted term context over n type variables.
abbrev Ctx (n m : Nat) := Fin m → Ty n
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
Uses 1 · Used by 18
Term renaming and substitution
DefinitionType substitution in System F terms#✓fully proved
Substitute type variables in annotations, arguments, and type binders.
@[simp] def tySubst {n k m : Nat} (σ : Fin n → Ty k) : Tm n m → Tm k m
| .var i => .var i
| .lam A b => .lam (A.subst σ) (tySubst σ b)
| .app f a => .app (tySubst σ f) (tySubst σ a)
| .tabs b => .tabs (tySubst (Ty.liftSub σ) b)
| .tapp f A => .tapp (tySubst σ f) (A.subst σ)
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 liftSub {n k : Nat} (σ : Fin n → Ty k) : Fin (n + 1) → Ty (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ i))
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:59
Uses 4 · Used by 14
DefinitionTerm-variable renaming in System F terms#✓fully proved
Rename term variables, lifting only at term binders.
@[simp] def rename {n m k : Nat} (ρ : Fin m → Fin k) : Tm n m → Tm n k
| .var i => .var (ρ i)
| .lam A b => .lam A (rename (liftRen ρ) b)
| .app f a => .app (rename ρ f) (rename ρ a)
| .tabs b => .tabs (rename ρ b)
| .tapp f A => .tapp (rename ρ f) A
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 liftRen {n k : Nat} (ρ : Fin n → Fin k) :
Fin (n + 1) → Fin (k + 1) :=
Fin.cases 0 (fun i => (ρ i).succ)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:38
Uses 3 · Used by 7
DefinitionType-variable renaming in System F terms#✓fully proved
Rename type variables without changing term variables.
def tyRename {n k m : Nat} (ρ : Fin n → Fin k) (t : Tm n m) : Tm k m :=
tySubst (fun i => .var (ρ 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
@[simp] def tySubst {n k m : Nat} (σ : Fin n → Ty k) : Tm n m → Tm k m
| .var i => .var i
| .lam A b => .lam (A.subst σ) (tySubst σ b)
| .app f a => .app (tySubst σ f) (tySubst σ a)
| .tabs b => .tabs (tySubst (Ty.liftSub σ) b)
| .tapp f A => .tapp (tySubst σ f) (A.subst σ)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:97
Uses 3 · Used by 5
DefinitionLifting a term substitution under a term lambda#✓fully proved
Lift a simultaneous term substitution beneath a term lambda.
def liftSub {n m k : Nat} (σ : Fin m → Tm n k) :
Fin (m + 1) → Tm n (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ i))
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
@[simp] def rename {n m k : Nat} (ρ : Fin m → Fin k) : Tm n m → Tm n k
| .var i => .var (ρ i)
| .lam A b => .lam A (rename (liftRen ρ) b)
| .app f a => .app (rename ρ f) (rename ρ a)
| .tabs b => .tabs (rename ρ b)
| .tapp f A => .tapp (rename ρ f) A
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:105
Uses 2 · Used by 5
DefinitionSimultaneous term substitution in System F terms#✓fully proved
Simultaneous term substitution, avoiding both sorts of capture.
@[simp] def subst {n m k : Nat} (σ : Fin m → Tm n k) : Tm n m → Tm n k
| .var i => σ i
| .lam A b => .lam A (subst (liftSub σ) b)
| .app f a => .app (subst σ f) (subst σ a)
| .tabs b => .tabs (subst (fun i => tyRename Fin.succ (σ i)) b)
| .tapp f A => .tapp (subst σ f) A
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 liftSub {n m k : Nat} (σ : Fin m → Tm n k) :
Fin (m + 1) → Tm n (k + 1) :=
Fin.cases (.var 0) (fun i => rename Fin.succ (σ i))
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:117
def tyRename {n k m : Nat} (ρ : Fin n → Fin k) (t : Tm n m) : Tm k m :=
tySubst (fun i => .var (ρ i)) t
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:113
Uses 4 · Used by 9
DefinitionInstantiating the newest term binder of a term#✓fully proved
Replace the newest term variable and discharge its binder.
def instantiate {n m : Nat} (b : Tm n (m + 1)) (a : Tm n m) : Tm n m :=
subst (Fin.cases a Tm.var) b
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
@[simp] def subst {n m k : Nat} (σ : Fin m → Tm n k) : Tm n m → Tm n k
| .var i => σ i
| .lam A b => .lam A (subst (liftSub σ) b)
| .app f a => .app (subst σ f) (subst σ a)
| .tabs b => .tabs (subst (fun i => tyRename Fin.succ (σ i)) b)
| .tapp f A => .tapp (subst σ f) A
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:122
Uses 2 · Used by 10
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.