Capture-avoiding binding laws for kinded type operators
TheoremRenaming of type operators depends only on variable images#✓fully proved
Renaming depends only on its action on kinded variables.
theorem rename_congr {ρ τ : KRen Δ Ε}
(h : ∀ {ν} (x : KVar Δ ν), ρ x = τ x) (t : Ty Δ κ) :
rename ρ t = rename τ t
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
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
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 rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
Uses 5 · Used by 4
TheoremIdentity renaming fixes type operators#✓fully proved
The identity renaming fixes every type operator.
@[simp] theorem rename_id (t : Ty Δ κ) :
rename (fun {_} x => x) t = 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
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
TheoremComposition of kind-preserving renamings#✓fully proved
Successive kind-preserving renamings fuse, including beneath binders.
theorem rename_rename (ρ : KRen Δ Ε) (τ : KRen Ε Ζ) (t : Ty Δ κ) :
rename τ (rename ρ t) = rename (fun {_} x => τ (ρ x)) t
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
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 rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
Uses 7 · Used by 2
TheoremSubstitution of type operators depends only on variable images#✓fully proved
Substitution depends only on the images of kinded variables.
theorem subst_congr {σ τ : Sub Δ Ε}
(h : ∀ {ν} (x : KVar Δ ν), σ x = τ x) (t : Ty Δ κ) :
subst σ t = subst τ t
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
Uses 5 · Used by 7
TheoremIdentity substitution fixes type operators#✓fully proved
Substituting each variable by itself fixes every type operator.
@[simp] theorem subst_id (t : Ty Δ κ) : subst Ty.var t = 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
def subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
TheoremSubstitution after renaming of type operators#✓fully proved
Substitution after renaming is precomposition on the variable images.
theorem subst_rename (ρ : KRen Δ Ε) (σ : Sub Ε Ζ) (t : Ty Δ κ) :
subst σ (rename ρ t) = subst (fun {_} x => σ (ρ x)) t
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
Uses 10 · Used by 4
TheoremRenaming after substitution of type operators#✓fully proved
Renaming after substitution renames each substituted type operator.
theorem rename_subst (σ : Sub Δ Ε) (ρ : KRen Ε Ζ) (t : Ty Δ κ) :
rename ρ (subst σ t) =
subst (fun {_} x => rename ρ (σ x)) t
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
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 rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
def subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
Uses 12 · Used by 3
TheoremComposition of simultaneous type-operator substitutions#✓fully proved
Capture-avoiding simultaneous substitutions compose.
theorem subst_subst (σ : Sub Δ Ε) (τ : Sub Ε Ζ) (t : Ty Δ κ) :
subst τ (subst σ t) =
subst (fun {_} x => subst τ (σ x)) t
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
Uses 10 · Used by 1
TheoremInstantiating a weakened type operator leaves it unchanged#✓fully proved
Discharging a fresh binder leaves a weakened operator unchanged.
@[simp] theorem instantiate_rename_succ (t : Ty Δ κ) (a : Ty Δ μ) :
instantiate (rename KVar.succ t) a = 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
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
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 9 · Used by 4
TheoremSubstitution commutes with type-binder instantiation#✓fully proved
Simultaneous substitution commutes with discharging a type binder.
theorem subst_instantiate (σ : Sub Δ Ε)
(b : Ty (μ :: Δ) κ) (a : Ty Δ μ) :
subst σ (instantiate b a) =
instantiate (subst (liftSub σ) b) (subst σ a)
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
def liftSub {Δ Ε : List Kind} {μ : Kind} (σ : Sub Δ Ε) :
Sub (μ :: Δ) (μ :: Ε)
| _, .zero => .var .zero
| _, .succ x => rename KVar.succ (σ x)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:85
Uses 12 · Used by 3
TheoremRenaming commutes with type-binder instantiation#✓fully proved
Renaming commutes with discharging a type binder.
theorem rename_instantiate (ρ : KRen Δ Ε)
(b : Ty (μ :: Δ) κ) (a : Ty Δ μ) :
rename ρ (instantiate b a) =
instantiate (rename (KRen.lift ρ) b) (rename ρ a)
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
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 rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
def lift {Δ Ε : List Kind} {μ : Kind} (ρ : KRen Δ Ε) :
KRen (μ :: Δ) (μ :: Ε)
| _, .zero => .zero
| _, .succ x => .succ (ρ x)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:53
Uses 12 · Used by 2
TheoremRenaming as substitution by variables#✓fully proved
Renaming is substitution by the corresponding variable constructors.
theorem subst_var_rename (ρ : KRen Δ Ε) (t : Ty Δ κ) :
subst (fun {_} x => .var (ρ x)) t = rename ρ t
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
Uses 9 · Used by 2
TheoremLifted substitution commutes with weakening#✓fully proved
Lifted type substitution commutes with weakening past the new binder.
theorem subst_lift_rename (σ : Sub Δ Ε) (t : Ty Δ κ) :
subst (liftSub (μ := μ) σ) (rename KVar.succ t) =
rename KVar.succ (subst σ t)
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
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 subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
def liftSub {Δ Ε : List Kind} {μ : Kind} (σ : Sub Δ Ε) :
Sub (μ :: Δ) (μ :: Ε)
| _, .zero => .var .zero
| _, .succ x => rename KVar.succ (σ x)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:85
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
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 9 · Used by 3
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.