The basic subtyping system
(the source language)

(x : T) in G
------------
G |- x : T

G, x : T1 |- t2 : T2
---------------------
G |- \x.t2 : T1 -> T2

G |- t1 : T1 -> T2    G |- t2 : T1
----------------------------------
G |- t1 t2 : T2

G |- t1 : T1 ... G |- tn : Tn
-----------------------------------------
G |- (l1=t1,...,ln=tn) : (l1=T1,...ln=Tn)

G |- t : (l1=T1,...ln=Tn)
-------------------------
G |- t.li : Ti

G |- t : T1    T1 <: T2
-----------------------
G |- t : T2


------
T <: T

--------
T <: Top

S <: T    T <: U
----------------
S <: U

S' <: S    T <: T'
------------------
S -> T <: S' -> T'

  functions are contravariant in the argument, covariant in the result

------------------------------------------------  where  m < n
(l1:T1,...,lm:Tm,...,ln:Tn) <: (l1:T1,...,lm:Tm)

  width subtyping

S1 <: T1  ...   Sn <: Tn
--------------------------------------
(l1:S1,...,ln:Sn) <: (l1:T1,...,ln:Tn)

  depth subtyping


The target language is simply typed lambda calculus with records,
but without subtyping or the subsumption rule.



Penn Interpretation

(x : T) in G
----------------
G |- x : T --> x

G, x : T1 |- t2 : T2 --> u2
-------------------------------------
G |- \x:T1.t2 : T1 -> T2 --> \x:T1.u2

G |- t1 : T1 -> T2 --> u1    G |- t2 : T1 --> u2
------------------------------------------------
G |- t1 t2 : T2 --> u1 u2

G |- t1 : T1 --> ui  ...  G |- tn : Tn --> un
-----------------------------------------------------------------
G |- (l1=t1,...,ln=tn) : (l1=T1,...ln=Tn) --> (l1=u1,...,ln = un)

G |- t : (l1=T1,...ln=Tn) --> u
-------------------------------
G |- t.li : Ti --> u.li

G |- t : T1 --> u    T1 <: T2 --> c
-----------------------------------
G |- t : T2 --> c u



-------------
T <: T --> id

  id = \x:T.x

S <: T --> c    T <: U --> d
----------------------------
S <: U --> d.c

  d.c = \x:S.d(c(x))

S' <: S --> c   T <: T' --> d
-------------------------------
S -> T <: S' -> T'  -->  c -> d

  c -> d  =  \f:S->T. \x:S'. d(f(c(x)))  =  \f:S->T. d.f.c
  (c -> d) f  =  d . f . c

  functions are contravariant in the argument, covariant in the result

------------------------------------------------  where  m < n
(l1:T1,...,lm:Tm,...,ln:Tn) <: (l1:T1,...,lm:Tm)
  --> \r:(l1:T1,...,lm:Tm,...,ln:Tn).(l1=r.l1,...,lm=r.lm)

  width subtyping

S1 <: T1 --> c1  ...   Sn <: Tn --> cn
------------------------------------------------
(l1:S1,...,ln:Sn) <: (l1:T1,...,ln:Tn)
  --> \r:(l1:S1,...,ln:Sn).(l1=c1(r.l1),...,ln=cn(r.ln))

  depth subtyping