Typeteori

I matematikk, informatikk og logikk er typeteori studien av visse formelle systemer som relaterer termer til typer.
Typeteori ble opprinnelig utviklet for reparere Russels og Whiteheads logiske system Principia Mathematica, som
Kurt Gödel i 1902 oppdaget var inkonsistent, men typeteori er i dag et studium i seg selv.
Det forskes på bruk av typeteori som et alternativ til mengdelære som fundamentet for matematikk, og det
er en nær sammenheng mellom datatyper, slik man finner dem i programmeringsspråk, og typene i typeteori.
Videre er det en tett sammenheng med logikk, tydeliggjort av Curry-Howard-korrespondansen.


== Lambdakalkylen med endelige typer ==
Lambdakalylen med endelig typer (eng: "simply typed lambda calculus"), 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
  , ble utviklet
av Alonzo Church i 1940, i et forsøk på temme den utypete lambdakalkylen, som er logisk sett inkonsistent.


=== Syntaks ===
Den syntaktiske kategorien for typer defineres som følger, hvor 
  
    
      
        B
      
    
    {\displaystyle B}
   er en mengde med "basistyper",

  
    
      
        τ
        ::=
        τ
        →
        τ
        ∣
        T
        
        
          h
          v
          o
          r
        
        
        T
        ∈
        B
      
    
    {\displaystyle \tau ::=\tau \to \tau \mid T\quad \mathrm {hvor} \quad T\in B}
  .Et eksempel på basistyper som man kan finne i programmeringsspråk er

  
    
      
        B
        =
        {
        
          n
          a
          t
        
        ,
        
        
          b
          o
          o
          l
        
        }
      
    
    {\displaystyle B=\{\mathrm {nat} ,\;\mathrm {bool} \}}
  ,hvor nat står for naturlige tall, og
bool for bolske verdier. 
Da vil f.eks. typen 
  
    
      
        
          n
          a
          t
        
        →
        
          b
          o
          o
          l
        
      
    
    {\displaystyle \mathrm {nat} \to \mathrm {bool} }
   representere
en funksjon som tar et naturlig tall og returnerer en boolsk verdi. En funksjon som tar flere
argumenter, f.eks. pluss funksjonen, vil ha typen 
  
    
      
        
          n
          a
          t
        
        →
        
          n
          a
          t
        
        →
        
          n
          a
          t
        
      
    
    {\displaystyle \mathrm {nat} \to \mathrm {nat} \to \mathrm {nat} }
  .
Termene i 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   er definert som 

  
    
      
        e
        ::=
        x
        ∣
        e
        
        e
        ∣
        λ
        x
        :
        τ
        .
        e
      
    
    {\displaystyle e::=x\mid e\,e\mid \lambda x:\tau .e}
  .Her represetnerer 
  
    
      
        λ
        x
        :
        τ
        .
        e
      
    
    {\displaystyle \lambda x:\tau .e}
   en funksjon
som tar et argument 
  
    
      
        x
      
    
    {\displaystyle x}
   av typen 
  
    
      
        τ
      
    
    {\displaystyle \tau }
  ,
og som returnerer 
  
    
      
        e
      
    
    {\displaystyle e}
  . Jukstaposisjon av to termer, 
  
    
      
        
          e
          
            1
          
        
        
        
          e
          
            2
          
        
      
    
    {\displaystyle e_{1}\,e_{2}}
  
representerer funksjonskall (vanlig notasjon innen matematikk er 
  
    
      
        
          e
          
            1
          
        
        (
        
          e
          
            2
          
        
        )
      
    
    {\displaystyle e_{1}(e_{2})}
  ), og 
  
    
      
        x
      
    
    {\displaystyle x}
   er referanse til en variable.


=== Typesjekking ===
Relasjonen 
  
    
      
        Γ
        ⊢
        e
        
        :
        
        τ
      
    
    {\displaystyle \Gamma \vdash e\,:\,\tau }
   definerer hvorvidt et uttykk 
  
    
      
        e
      
    
    {\displaystyle e}
   har typen 
  
    
      
        τ
      
    
    {\displaystyle \tau }
   under
antagelsene 
  
    
      
        Γ
        =
        
          x
          
            1
          
        
        :
        
          τ
          
            1
          
        
        ,
        …
        ,
        
          x
          
            n
          
        
        :
        
          τ
          
            n
          
        
      
    
    {\displaystyle \Gamma =x_{1}:\tau _{1},\ldots ,x_{n}:\tau _{n}}
   (hvor 
  
    
      
        
          x
          
            i
          
        
        :
        
          τ
          
            i
          
        
      
    
    {\displaystyle x_{i}:\tau _{i}}
   representerer antagelsen at variabelen 
  
    
      
        x
      
    
    {\displaystyle x}
   har typen 
  
    
      
        τ
      
    
    {\displaystyle \tau }
  ).

  
    
      
        Γ
      
    
    {\displaystyle \Gamma }
   kalles en kontekst.
Relasjonen defineres som følger:

For å være formell, må det spesifiseres hva 
  
    
      
        Γ
      
    
    {\displaystyle \Gamma }
   er og hva 
  
    
      
        Γ
        ,
        x
        :
        τ
      
    
    {\displaystyle \Gamma ,x:\tau }
   og 
  
    
      
        Γ
        (
        x
        )
        =
        τ
      
    
    {\displaystyle \Gamma (x)=\tau }
   skal bety.
Det er flere måter å gjøre dette på. Det konseptuelt enkleset er å si at 
  
    
      
        Γ
      
    
    {\displaystyle \Gamma }
   er en endelig, partiell funksjon fra mengden av variabler til typer,
og å definere 
  
    
      
        Γ
        ,
        x
        :
        τ
      
    
    {\displaystyle \Gamma ,x:\tau }
   som funksjonen slik at 
  
    
      
        (
        Γ
        ,
        x
        :
        τ
        )
        (
        x
        )
        =
        τ
      
    
    {\displaystyle (\Gamma ,x:\tau )(x)=\tau }
  , og ellers 
  
    
      
        (
        Γ
        ,
        x
        :
        τ
        )
        (
        y
        )
        =
        Γ
        (
        y
        )
      
    
    {\displaystyle (\Gamma ,x:\tau )(y)=\Gamma (y)}
  ,
gitt at 
  
    
      
        x
        ≠
        y
      
    
    {\displaystyle x\not =y}
  .


=== Semantikk ===
Standardsemantikken for lambda kalkylen er 
  
    
      
        β
      
    
    {\displaystyle \beta }
  -reduksjon, som kan defineres som 
  
    
      
        (
        λ
        x
        :
        τ
        .
        
          e
          
            1
          
        
        )
        
        
          e
          
            2
          
        
        
          →
          
            β
          
        
        
          e
          
            1
          
        
        [
        
          e
          
            2
          
        
        
          /
        
        x
        ]
      
    
    {\displaystyle (\lambda x:\tau .e_{1})\,e_{2}\to _{\beta }e_{1}[e_{2}/x]}
  , hvor

  
    
      
        
          e
          
            1
          
        
        [
        
          e
          
            2
          
        
        
          /
        
        x
        ]
      
    
    {\displaystyle e_{1}[e_{2}/x]}
   er funksjonen som substituerer alle frie forekomster av 
  
    
      
        x
      
    
    {\displaystyle x}
   i 
  
    
      
        
          e
          
            1
          
        
      
    
    {\displaystyle e_{1}}
   med 
  
    
      
        
          e
          
            2
          
        
      
    
    {\displaystyle e_{2}}
  , og samtidig
passer på at ingen av de fri variablene i 
  
    
      
        
          e
          
            2
          
        
      
    
    {\displaystyle e_{2}}
   blir bundet av binderne i 
  
    
      
        
          e
          
            1
          
        
      
    
    {\displaystyle e_{1}}
  .
Siden et uttrykk på formen 
  
    
      
        (
        λ
        x
        :
        τ
        .
        
          e
          
            1
          
        
        )
        
          e
          
            2
          
        
      
    
    {\displaystyle (\lambda x:\tau .e_{1})e_{2}}
   kan 
  
    
      
        β
      
    
    {\displaystyle \beta }
  -reduseres, kalles uttrykk på den formen en "redex" (eng "reducable expression", norsk: reduserbart uttrykk).
Denne relasjonen kan så løftes til en relasjon som gjør en enkel 
  
    
      
        β
      
    
    {\displaystyle \beta }
  -reduksjon hvor som helst i en term. Relasjonen defineres som følger:

Gjentatt reduksjon representeres med relasjonen 
  
    
      
        e
        
          →
          
            ∗
          
        
        
          e
          ′
        
      
    
    {\displaystyle e\to ^{*}e'}
  , som tilsvarer den refleksive og transitive tillukkningen av 
  
    
      
        e
        →
        
          e
          ′
        
      
    
    {\displaystyle e\to e'}
  , og som defineres som :

Hvis en term 
  
    
      
        e
      
    
    {\displaystyle e}
   ikke kan reduseres, altså, det finnes ingen 
  
    
      
        
          e
          ′
        
      
    
    {\displaystyle e'}
   slik at 
  
    
      
        e
        →
        
          e
          ′
        
      
    
    {\displaystyle e\to e'}
  , så kalles 
  
    
      
        e
      
    
    {\displaystyle e}
   en verdi. 
Det er bevist at for alle termer 
  
    
      
        e
      
    
    {\displaystyle e}
  , kontekster 
  
    
      
        Γ
      
    
    {\displaystyle \Gamma }
   og typer 
  
    
      
        τ
      
    
    {\displaystyle \tau }
   slik at 
  
    
      
        Γ
        ⊢
        e
        :
        τ
      
    
    {\displaystyle \Gamma \vdash e:\tau }
  ,
så vil 
  
    
      
        e
        →
        
          e
          ′
        
      
    
    {\displaystyle e\to e'}
   slik at 
  
    
      
        
          e
          ′
        
      
    
    {\displaystyle e'}
   er en verdi. Dette er ikke tilfellet for utypet lambdakalkyle, hvor f.eks. termen 
  
    
      
        (
        λ
        x
        .
        x
        
        x
        )
        (
        λ
        x
        .
        x
        
        x
        )
      
    
    {\displaystyle (\lambda x.x\,x)(\lambda x.x\,x)}
  
ikke reduserer til noen verdi.


=== Lambdakalkyle à la Curry ===
Presentasjonen av 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   i avsnittene over, er presentert à la Church, siden termene er annotert med typer. Et alternativ er å beholde de utypede termene fra den 
utypede lambdakalkylen. Dette kalles à la Curry, og definisjonen av termer er da:

  
    
      
        e
        ::=
        x
        ∣
        λ
        x
        .
        e
        ∣
        e
        
        e
      
    
    {\displaystyle e::=x\mid \lambda x.e\mid e\,e}
  og typerelasjonen er

Hvorvidt et typesystem er presentert à la Curry eller Church vil få følger for hvilke egenskaper systemet får. F.eks. kan et uttrykk 
  
    
      
        e
      
    
    {\displaystyle e}
   i 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   à la Church kun
ha en type, mens i à la Curry kan et term ha mange forskjellige typer. For mer uttrykksfulle typesystemer, så kan typesjekking bli uavgjørbart i Curry form, mens de oftere er avgjørbare i Church form. 
Noen typesystemer har kun mening i en av formuleringene.


=== Normalform ===
I motsetning til utypet lambdakalkyle, så har alle vell-typede termer i 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   en unik normalform (opp til alpha-ekvivalens).


== System F ==
System F generaliserer 
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  -kalkyle med endelige typer, ved å legge til kvantifisering over typer. 
Typesystemet går også under navnene Andreordens 
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  -kalkulus og polymorfisk 
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  -kalkulus.
System F ble oppdaget av både logikeren Jean-Yves Girard og informatikeren John C. Reynolds uanvhengig av hverandre.


=== Motivasjon ===
Hvis man ser på den utypede funksjonen 
  
    
      
        λ
        x
        .
        x
      
    
    {\displaystyle \lambda x.x}
  , altså identitetsfunksjone, så kan man se at den har typen 
  
    
      
        τ
        →
        τ
      
    
    {\displaystyle \tau \to \tau }
   for 
alle 
  
    
      
        τ
      
    
    {\displaystyle \tau }
   i 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   à la Curry. Men hvis funksjonen forekommer som en del-term og den bindes til en variabel, så vil den variabelen
kun ha èn type i den gitte derivasjonen. Det betyr at i 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   må man gjenta definisjoner for forskjellige typer, selv om det er «unødvendig».
I System F løses dette ved å innføre variabler for typer og en kvantor som gjør det mulig å uttrykke for alle typer 
  
    
      
        α
      
    
    {\displaystyle \alpha }
  , så er 
  
    
      
        τ
      
    
    {\displaystyle \tau }
   en type, hvor

  
    
      
        α
      
    
    {\displaystyle \alpha }
   kan forekomme fritt i 
  
    
      
        τ
      
    
    {\displaystyle \tau }
  . Konkret notasjon for kvantoren er 
  
    
      
        ∀
        α
        .
        τ
      
    
    {\displaystyle \forall \alpha .\tau }
  . Her er noen eksempler på 
funksjonstyper hvor allkvantoren kommer til nytte:

  
    
      
        i
        d
        e
        n
        t
        i
        t
        y
        :
        ∀
        α
        .
        
        α
        →
        α
      
    
    {\displaystyle identity:\forall \alpha .\;\alpha \to \alpha }
  . Identitetsfunksjonen.

  
    
      
        c
        o
        n
        s
        :
        ∀
        α
        .
        
        α
        →
        
          L
          i
          s
          t
        
        
        α
        →
        
          L
          i
          s
          t
        
        
        α
      
    
    {\displaystyle cons:\forall \alpha .\;\alpha \to \mathrm {List} \;\alpha \to \mathrm {List} \;\alpha }
  . Funksjonen som legger til et element foran i en liste.

  
    
      
        m
        a
        p
        :
        ∀
        α
        .
        ∀
        β
        .
        
        
          L
          i
          s
          t
        
        
        α
        →
        (
        α
        →
        β
        )
        →
        
          L
          i
          s
          t
        
        
        β
      
    
    {\displaystyle map:\forall \alpha .\forall \beta .\;\mathrm {List} \,\alpha \to (\alpha \to \beta )\to \mathrm {List} \,\beta }
   (Hvor 
  
    
      
        L
        i
        s
        t
      
    
    {\displaystyle List}
   er antatt en primitiv type for lister med elementer av en gitt type.)

  
    
      
        ∀
        α
        .
        α
        →
        (
        α
        →
        α
        )
        →
        α
      
    
    {\displaystyle \forall \alpha .\alpha \to (\alpha \to \alpha )\to \alpha }
  . Typen for Church-enkodingen av naturlige tall.


=== Definisjon ===
Typene fra 
  
    
      
        
          λ
          
            2
          
        
      
    
    {\displaystyle \lambda ^{2}}
   utvides med to nye former:

  
    
      
        τ
        ::=
        T
        ∣
        α
        ∣
        τ
        →
        τ
        ∣
        ∀
        α
        .
        τ
      
    
    {\displaystyle \tau ::=T\mid \alpha \mid \tau \to \tau \mid \forall \alpha .\tau }
  hvor 
  
    
      
        α
      
    
    {\displaystyle \alpha }
   kalles en type-variabel, og 
  
    
      
        ∀
        α
        .
        τ
      
    
    {\displaystyle \forall \alpha .\tau }
   representerer polymorfi.
Termene utvides med to nye konstruktører:

  
    
      
        e
        ::=
        x
        ∣
        e
        
        e
        ∣
        λ
        x
        :
        τ
        .
        e
        ∣
        Λ
        α
        .
        e
        ∣
        e
        
        τ
      
    
    {\displaystyle e::=x\mid e\,e\mid \lambda x:\tau .e\mid \Lambda \alpha .e\mid e\,\tau }
  hvor 
  
    
      
        Λ
        α
        .
        e
      
    
    {\displaystyle \Lambda \alpha .e}
   sier at termen 
  
    
      
        e
      
    
    {\displaystyle e}
   skal fungere for alle typer satt inn i 
  
    
      
        e
      
    
    {\displaystyle e}
  ,
og 
  
    
      
        e
        
        τ
      
    
    {\displaystyle e\,\tau }
  , som forventer at 
  
    
      
        e
      
    
    {\displaystyle e}
   er av typen 
  
    
      
        ∀
        α
        .
        
          τ
          ′
        
      
    
    {\displaystyle \forall \alpha .\tau '}
  , betyr at uttrykket

  
    
      
        e
      
    
    {\displaystyle e}
   skal spesialiseres til typen 
  
    
      
        τ
      
    
    {\displaystyle \tau }
  .
Typereglene for System F er som for 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
  , men med to ekstra regler:

  
    
      
        
          Γ
          ⊢
          e
          :
          τ
          
          α
          ∉
          
            F
            V
          
          (
          Γ
          )
        
        
          Γ
          ⊢
          Λ
          α
          .
          e
          :
          ∀
          α
          .
          τ
        
      
    
    {\displaystyle \Gamma \vdash e:\tau \quad \alpha \not \in \mathrm {FV} (\Gamma ) \over \Gamma \vdash \Lambda \alpha .e:\forall \alpha .\tau }
  
og

  
    
      
        
          Γ
          ⊢
          e
          :
          ∀
          α
          .
          
            τ
            
              1
            
          
        
        
          Γ
          ⊢
          e
          
          
            τ
            
              2
            
          
          :
          
            τ
            
              1
            
          
          [
          
            τ
            
              2
            
          
          
            /
          
          α
          ]
        
      
    
    {\displaystyle \Gamma \vdash e:\forall \alpha .\tau _{1} \over \Gamma \vdash e\,\tau _{2}:\tau _{1}[\tau _{2}/\alpha ]}
  . Notasjonen 
  
    
      
        
          F
          V
          (
          Γ
          )
        
      
    
    {\displaystyle \mathrm {FV(\Gamma )} }
  
betyr her mengden av frie type-variabler som forekommer i 
  
    
      
        Γ
      
    
    {\displaystyle \Gamma }
  . 


=== Eksempler ===
Vi kan observere at vi nå kan definere en genrell identitetsfunksjon, 
  
    
      
        Λ
        α
        .
        
        λ
        x
        :
        α
        .
        x
      
    
    {\displaystyle \Lambda \alpha .\,\lambda x:\alpha .x}
   som har typen 
  
    
      
        ∀
        α
        .
        α
        →
        α
      
    
    {\displaystyle \forall \alpha .\alpha \to \alpha }
  .
Hvis vi kaller funksjonen 
  
    
      
        i
        d
      
    
    {\displaystyle id}
   ser vi at uttrykket 
  
    
      
        i
        d
        
        
          n
          a
          t
        
      
    
    {\displaystyle id\,\mathrm {nat} }
   har typen 
  
    
      
        
          n
          a
          t
        
        →
        
          n
          a
          t
        
      
    
    {\displaystyle \mathrm {nat} \to \mathrm {nat} }
  .
Det er også mulig å representere naturlige tall ved å benytte Churchs enkoding i System F. Ideen bak Churchs enkoding er at et tall 
  
    
      
        n
      
    
    {\displaystyle n}
   representeres av
en iterator som itererer 
  
    
      
        n
      
    
    {\displaystyle n}
   ganger. I utypet 
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  -kalkyle kan man definere 0 som 
  
    
      
        λ
        x
        .
        λ
        f
        .
        x
      
    
    {\displaystyle \lambda x.\lambda f.x}
  , altså
funksjonen som tar et element 
  
    
      
        x
      
    
    {\displaystyle x}
   og en funksjon 
  
    
      
        f
      
    
    {\displaystyle f}
  , og sender 
  
    
      
        x
      
    
    {\displaystyle x}
   gjennom funksjonen 
  
    
      
        f
      
    
    {\displaystyle f}
   null ganger.
Videre defineres 1 som 
  
    
      
        λ
        x
        .
        λ
        x
        .
        f
        
        x
      
    
    {\displaystyle \lambda x.\lambda x.f\,x}
  , altså funksjonen som sender 
  
    
      
        x
      
    
    {\displaystyle x}
   gjennom 
  
    
      
        f
      
    
    {\displaystyle f}
   en gang, og
2 defineres som 
  
    
      
        λ
        x
        .
        λ
        f
        .
        f
        
        (
        f
        
        x
        )
        )
      
    
    {\displaystyle \lambda x.\lambda f.f\,(f\,x))}
  , funksjonen som sender 
  
    
      
        x
      
    
    {\displaystyle x}
   gjennom 
  
    
      
        f
      
    
    {\displaystyle f}
   to ganger. Generelt
defineres tallet 
  
    
      
        n
      
    
    {\displaystyle n}
   som funksjonen 
  
    
      
        λ
        x
        .
        λ
        f
        .
        
          f
          
            n
          
        
        
        x
      
    
    {\displaystyle \lambda x.\lambda f.f^{n}\,x}
  .

La 
  
    
      
        n
        a
        t
      
    
    {\displaystyle nat}
   være en forkortelse for typen 
  
    
      
        ∀
        α
        .
        α
        →
        (
        α
        →
        α
        )
        →
        α
      
    
    {\displaystyle \forall \alpha .\alpha \to (\alpha \to \alpha )\to \alpha }
  .
La 
  
    
      
        0
      
    
    {\displaystyle 0}
   være definert som 
  
    
      
        ∀
        α
        .
        λ
        x
        :
        α
        .
        λ
        f
        :
        α
        →
        α
        .
        x
      
    
    {\displaystyle \forall \alpha .\lambda x:\alpha .\lambda f:\alpha \to \alpha .x}
  . Observer at 
  
    
      
        ⊢
        0
        :
        n
        a
        t
      
    
    {\displaystyle \vdash 0:nat}
  .
La 
  
    
      
        S
      
    
    {\displaystyle S}
   være definert som 
  
    
      
        λ
        n
        :
        n
        a
        t
        .
        ∀
        α
        .
        λ
        x
        :
        α
        .
        λ
        f
        :
        α
        →
        α
        .
        n
        α
        
        x
        
        (
        f
        
        x
        )
      
    
    {\displaystyle \lambda n:nat.\forall \alpha .\lambda x:\alpha .\lambda f:\alpha \to \alpha .n\alpha \,x\,(f\,x)}
  . Navnet 
  
    
      
        S
      
    
    {\displaystyle S}
   er første bokstav i suksessor, og representerer pluss en funksjonen. Observer at 
  
    
      
        ⊢
        S
        :
        n
        a
        t
        →
        n
        a
        t
      
    
    {\displaystyle \vdash S:nat\to nat}
  .


== Barendregts lambda-kube ==

Matematikeren Henk Barendregt utviklet lambda-kuben, 
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  -kuben, for å utforske forskjellige utvidelser av typesystemer.
Han tar utgangspunkt i 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
  , og ser på tre utvidelser, som vises som akser i kuben:

Typeoperatorer — typer som er avhenger av typer, z-aksen
Polymorphisme — termer som avhenger av typer, y-aksen
Dependent typer — typer som avhenger av termer, x-aksenDisse utvidelsene gir opphav til åtte forskjellige typesystemer, avhengig av hvilke utvidelser man tar med. Lambda-kuben gir et 
rammeverk som definerer alle åtte systemene samtidig, men det er også mulig å definere hvert system for seg selv.
Hvis man ikke tar med noen av utvidelsene så får man 
  
    
      
        
          λ
          
            →
          
        
      
    
    {\displaystyle \lambda ^{\to }}
   som beskrevet over, 
og tar man med alle, får man noe som tilsvarer Calculus of Constructions.


=== Definisjon av lambda kuben ===
Det er ikke lenger praktisk å ha to seperate syntaktiske kategorier for termer og typer, og i 
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  -kuben definerer man derfor pseudo-termer som

  
    
      
        
          
            T
          
        
        ::=
        x
        ∣
        C
        ∣
        
          
            
              T
            
          
          
            1
          
        
        
        
          
            
              T
            
          
          
            2
          
        
        ∣
        λ
        x
        :
        
          
            
              T
            
          
          
            1
          
        
        .
        
          
            
              T
            
          
          
            2
          
        
        ∣
        Π
        x
        :
        
          
            
              T
            
          
          
            1
          
        
        .
        
          
            
              T
            
          
          
            2
          
        
      
    
    {\displaystyle {\mathcal {T}}::=x\mid C\mid {\mathcal {T}}_{1}\,{\mathcal {T}}_{2}\mid \lambda x:{\mathcal {T}}_{1}.{\mathcal {T}}_{2}\mid \Pi x:{\mathcal {T}}_{1}.{\mathcal {T}}_{2}}
  hvor 
  
    
      
        C
      
    
    {\displaystyle C}
   er en mengde konstanter, som minst inneholder 
  
    
      
        ∗
      
    
    {\displaystyle *}
   (les: type) og 
  
    
      
        ◻
      
    
    {\displaystyle \Box }
   (les: 'kind').


==== Felles regler ====
Alle systemene har noen regler til felles.


==== Parametriske regler ====
Følgende regel er parametrisk i 
  
    
      
        
          s
          
            1
          
        
        ,
        
          s
          
            2
          
        
        ∈
        {
        ∗
        ,
        ◻
        }
      
    
    {\displaystyle s_{1},s_{2}\in \{*,\Box \}}
  . 

  
    
      
        
          Γ
          ⊢
          A
          :
          
            s
            
              1
            
          
          
          Γ
          ,
          x
          :
          A
          ⊢
          B
          :
          
            s
            
              2
            
          
        
        
          Γ
          ⊢
          Π
          x
          :
          A
          .
          B
          :
          
            s
            
              2
            
          
        
      
    
    {\displaystyle \Gamma \vdash A:s_{1}\quad \Gamma ,x:A\vdash B:s_{2} \over \Gamma \vdash \Pi x:A.B:s_{2}}
  Man kan bestemme hvilket typesystem man ønsker ved å bestemme hvilke instanser av 
  
    
      
        (
        
          s
          
            1
          
        
        ,
        
          s
          
            2
          
        
        )
      
    
    {\displaystyle (s_{1},s_{2})}
   man som er godtatt. Tabellen under lister opp alle mulighetene.


== Egenskaper ved typesystemer ==
To klassiske egenskaper som typesystemer kan ha er:

Preservering (eng: subject reduction el. preservation): hvis 
  
    
      
        ⊢
        e
        :
        τ
      
    
    {\displaystyle \vdash e:\tau }
   og 
  
    
      
        e
        →
        
          e
          ′
        
      
    
    {\displaystyle e\to e'}
  , så 
  
    
      
        ⊢
        
          e
          ′
        
        :
        τ
      
    
    {\displaystyle \vdash e':\tau }
  . Altså, reduksjon bevarer typen.
Progresjon (eng: progress): hvis 
  
    
      
        ⊢
        e
        :
        τ
      
    
    {\displaystyle \vdash e:\tau }
  , så er enten 
  
    
      
        e
      
    
    {\displaystyle e}
   en verdi, eller så eksisterer en 
  
    
      
        
          e
          ′
        
      
    
    {\displaystyle e'}
   slik at 
  
    
      
        e
        →
        
          e
          ′
        
      
    
    {\displaystyle e\to e'}
  . Altså, vel-typede termer henger ikke.


== Litteratur ==
S. Abramsky / D. M. Gabbay / T. S. E. Maibaum / H. P. Barendregt (1993). "Handbook of Logic in Computer Science, volume II, chapter Lambda Calculi with Types"
Jean-Yves Girard (1989). Proofs and Types, Cambridge University Press. ISBN 0 521 37181 3. Tilgjengelig online: http://www.paultaylor.eu/stable/Proofs+Types.html