-- Capless/Type/Basic.lean

import Capless.Type.Core

import Capless.Type.Renaming

namespace Capless

end

end

end

end

end

end

end

-- Repository definitions used:
content: inductive SType : Nat -> Nat -> Nat -> Type where
| top : SType n m k
| tvar : Fin m -> SType n m k
| forall : CType n m k -> EType (n+1) m k -> SType n m k
| tforall : SType n m k -> EType n (m+1) k -> SType n m k
| cforall : CBound n k -> EType n m (k+1) -> SType n m k
| box : CType n m k -> SType n m k
| label : SType n m k -> SType n m k

content: def SType.trename : SType n m k -> FinFun m m' -> SType n m' k
| SType.top, _ => SType.top
| SType.tvar X, f => SType.tvar (f X)
| SType.forall E1 E2, f => SType.forall (E1.trename f) (E2.trename f)
| SType.tforall S E, f => SType.tforall (S.trename f) (E.trename f.ext)
| SType.cforall B E, f => SType.cforall B (E.trename f)
| SType.box T, f => SType.box (T.trename f)
| SType.label S, f => SType.label (S.trename f)

content: def CType.trename : CType n m k -> FinFun m m' -> CType n m' k
| CType.capt C S, f => CType.capt C (S.trename f)

content: inductive CType : Nat -> Nat -> Nat -> Type where
| capt : CaptureSet n k -> SType n m k -> CType n m k

content: def FinFun (n n' : Nat) : Type :=
  Fin n -> Fin n'

content: def EType.trename : EType n m k -> FinFun m m' -> EType n m' k
| EType.ex T, f => EType.ex (T.trename f)
| EType.type T, f => EType.type (T.trename f)

content: inductive EType : Nat -> Nat -> Nat -> Type where
| ex : CType n m (k+1) -> EType n m k
| type : CType n m k -> EType n m k

content: def FinFun.ext (f : FinFun n n') : FinFun (n+1) (n'+1) :=

content: def FinFun.id : FinFun n n :=
  fun i => i

content: notation "⊤" => SType.top

content: notation:50 "∀(x:" T ")" U => SType.forall T U

content: notation:50 "∀[X<:" S "]" T => SType.tforall S T

content: notation:50 "∀[c<:" B "]" T => SType.cforall B T

content: notation:max S " ^ " C => CType.capt C S

content: notation:40 "∃c." T => EType.ex T

content: notation:40 "Label[" S "]" => SType.label S

content: notation:60 "□" T => SType.box T

-- Repository lemmas used:
content: theorem FinFun.id_ext :
  (FinFun.ext (n := n) id) = id

-- Local definitions used:

-- Local lemmas used:
content: theorem EType.trename_id {E : EType n m k} :
  E.trename FinFun.id = E

content: theorem CType.trename_id {T : CType n m k} :
  T.trename FinFun.id = T

-- Target theorem and proof:
theorem SType.trename_id {S : SType n m k} :
  S.trename FinFun.id = S :=
  match S with
  | SType.top => by simp [SType.trename]
  | SType.tvar X => by simp [SType.trename, FinFun.id]
  | SType.forall E1 E2 => by
    have ih1 := CType.trename_id (T := E1)
    have ih2 := EType.trename_id (E := E2)
    simp [SType.trename, FinFun.id_ext, ih1, ih2]
  | SType.tforall S E => by
    have ih1 := SType.trename_id (S := S)
    have ih2 := EType.trename_id (E := E)
    simp [SType.trename, FinFun.id_ext, ih1, ih2]
  | SType.cforall B E => by
    have ih := EType.trename_id (E := E)
    simp [SType.trename, ih]
  | SType.box T => by
    have ih := CType.trename_id (T := T)
    simp [SType.trename, ih]
  | SType.label S => by
    have ih := SType.trename_id (S := S)
    simp [SType.trename, ih]
:=
  match S with
  | SType.top => by simp [SType.trename]
  | SType.tvar X => by simp [SType.trename, FinFun.id]
  | SType.forall E1 E2 => by
    have ih1 := CType.trename_id (T := E1)
    have ih2 := EType.trename_id (E := E2)
    simp [SType.trename, FinFun.id_ext, ih1, ih2]
  | SType.tforall S E => by
    have ih1 := SType.trename_id (S := S)
    have ih2 := EType.trename_id (E := E)
    simp [SType.trename, FinFun.id_ext, ih1, ih2]
  | SType.cforall B E => by
    have ih := EType.trename_id (E := E)
    simp [SType.trename, ih]
  | SType.box T => by
    have ih := CType.trename_id (T := T)
    simp [SType.trename, ih]
  | SType.label S => by
    have ih := SType.trename_id (S := S)
    simp [SType.trename, ih]