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
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
Uses 6

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
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
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
Uses 6 · Used by 1

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
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
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
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
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)
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)
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
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)
Uses 9 · Used by 3
13 fully proved

The dependency explorer needs JavaScript and its graph data.

Download the complete graph data.