Denotationelle Semantik von ML0

ML0
Syntax, Typsystem und Semantik
-Kalkül





Fromalisierung von funktionaler Berechenbarkeit
Allgemeine Syntax:
x TermVar
M ::= x
// Variable
| x.M
// Abstraktion
|MM
// Applikation
Variablenumgebung : TermVar  Werte
Kann auf verschiedene Art und Weise durch
Typsystem ergänzt werden
Dabei: Ausdrucksmächtigkeit vs. Sicherheit
Ungetyptes -Kalkül


Kein Typsystem
exotische „sinnvolle“ Terme erlaubt:



Jedoch auch unsinnige Terme erlaubt:


(f. f( f )) y.y
f.( (x. f( x(x) )) (x.f( x(x) )) )
(„paradoxical combinator“)
zero( zero )
sehr ausdrucksmächtig, aber genauso unsicher
Explizit getyptes -Kalkül

Typen sind explizit gegeben:




Typumgebung H: TermVar  Typen
t ::= Grundtyp | tt
M ::= x
| x:t.M
|MM
Typregeln:

[Proj]
xH


[Abs]
H├ x:H(x)
H, x:s├ M:t


[Appl]
H├ x:s.M : st
H├ M: st
H├ N: s

H├ M(N) : t
Implizit getyptes -Kalkül



Keine Type-Tags
M ::= x | x.M
|MM
Term korrekt gdw. äquivalenter explizit
getypter Term existiert
D.h. Typregeln gleich, nur kein Type-Tag
bei Abstraktion:
[Abs]
H, x:s├ M:t

H├ x.M : st
Implizit getyptes -Kalkül:
Typinferenz


Gegeben: Term M, Typumgebung H
Können wir einen Typen für M
rekonstruieren ?
Bsp.
M  x. f. f(x)



alle Typen der Form r(rs)s möglich
(„Typschema“)
r und s können als Variablen gesehen werden
Typ t erfüllt M:t gdw. t eine Substitutionsinstanz vom
Typschema
Implizit getyptes -Kalkül:
Mächtigkeitsgrenze

Bsp.




M  f. f(f)
Typ von f müsste zwei Typschemata
entsprechen:
rs und r
Für gleichen Subterm aber nicht mehrere
Typen nach Typregeln herleitbar
M kein korrekter Term
Kann aber manchmal sinnvoll sein
z.B. (f. f(f)) (y. y)
Polymorphismus



Typsystem, das Terme erlaubt mit...
gleichem Subterm
in verschiedenen Kontexten
mit verschiedenen Typen
Deckt „grauen Bereich“ sinnvoller Terme
zwischen ungetyptem
und
implizit getyptem -Kalkül ab
Mehrere mögliche Implementierungen:




ML0
Girard-Reynolds polymorphes -Kalkül
Typ:Typ Kalkül
...
ML0






Kern des Typsystems von ML
Verwendet u.a. in Haskell
Polymorphismus an Let-Konstrukt gebunden
 „Let-bound“ Polymorphismus
Typvariablen und Typschemata im Typsystem
Keine Type-Tags
Typinferenz
Syntax von ML0
x TermVar
a TypeVar
t ::= a
T ::= t
M ::=
x
| tt
| a. T
// Typen
// Typschemata
| x.M
| MM
| let x=M in M

// let-Konstrukt
Let ähnlich (x.N) M jedoch andere Typregeln
Typsystem von ML0

Typumgebung H: TermVar  Typschema
Bsp.
H  {zero
: a. a, id : a. aa,
filter : a.i. (aBool)(ia)(ia) }

Typ s ist Instanz von Typschema T  a1. ... an.t
(kurz: s  T)
gdw.  Substitution  auf {a1,...,an} mit (t)=s
Bsp.

a. aa
StringString 
a. aa
NatNat
Typsystem von ML0

Abschluss (closure) eines Typs t
bzgl. Typumgebung H:
close(H; t) = a1. ... an.t
mit {a1,...,an} = Ftv(t) – Ftv(H)



Ftv(t)  freie Typvariablen in t
Ftv(H) = Ftv( H(x) ) mit x  H
 freie Typvariablen in Typumgebung
Typkonstanten (Nat, Bool, ...)
close verallegmeinert Typ zu passendem Typschema
Bsp.
H  { x:Bool, id : a. aa }
t  aBool
Ftv(H) = { Bool } Ftv(t)= { a, Bool }
close(H; t) = a. aBool
Typsystem von ML0

[Proj]
x:TH tT


H├ x:t

[Abs]
H, x:s├ M:t

H├ x.M : st

[Appl]
H├ M: st
H├ N: s

H├ M(N) : t

[Let]
H├ M : s
H, x:close(H; s)├ N : t

H├ let x=M in N : t
Typsystem von ML0
Projektion einer Variablen aus der Typumgebung
[Proj]
x:TH tT



H├ x:t
Für „herkömmliche“ Variablen x:t H:



einzige Instanzierung: Typ t
Entspricht alter Projektionsregel
Für polymorphe Variablen x:T H
mit Typschema T  a1. ... an.t :


mehrere Instanziierungen möglich
X kann mehrere Typen haben
Typsystem von ML0
„Let-bound“ Polymorphismus
[Let]
H├ M : s
H, x:close(H; s)├ N : t



H├ let x=M in N : t
Voraussetzung:
 x bekommt Verallgemeinerung von Typ s close(H; s)
und damit soll N:t sein
 D.h. x kann beliebig oft frei in N vorkommen und
jedesmal einen anderen Typ t mit t  close(H; s) haben
Folge:

Term M vom Typ s kann typkorrekt für x in N eingesetzt
werden
Typsystem von ML0
Bsp. N  let f = x.x in f(f)
[Proj]
[Abs] x:a├ x:a

├ x.x : aa und close(, aa) = a.aa
[Proj]
[Appl] f:a.aa├ f : aa
f:a.aa├ f : (aa)(aa)

f:a.aa├ f(f) : aa
[Let]
├ x.x : aa
f:a.aa├ f(f) : aa
 
├ let f = x.x in f(f) : aa
Semantik von ML0



Für freie Typvariablen a  Ftv(H):
Typvariablen-Umgebung : Ftv(H)  D
Für freie Termvariablen x  H:
Termvariablen-Umgebung 
mit (x)  |[ H(x) ]|
(H(x) ist i.A. ein Typschema)
D.h. wir arbeiten auf der semantischen Seite mit
zwei Universen:


Universum U der semantischen Interpretation von
Typen
Universum V der semantischen Interpretation von
Typschemata
Semantik von ML0
Universum U
 semantische Interpretation von Typen
 Rekursiv definiert:



D0 = {X0} mit X0 Interpretation des Grundtyps
Dn+1 = Dn  { XY | X,Y  Dn }
U = n  |N Dn
D0 = { X0 }
// Konstanten
D1 = D0 { X0X0 }
// 2-st. Funktionen
D2 = D1 { X0(X0X0), (X0 X0)X0 }
...
// 3-st. Funktionale
Semantik von ML0
Universum V
 semantische Interpretation von Typschemata
(als Funktionen  von Typen auf Typen)
 Rekursiv definiert:



V0 = U (Universum der Interpret. der Typen)
Vn+1 = Vn  UVn
V = n  |N Vn
V0 = U
// einfache Typen
V1 = V0  UU
// einfach parametr. T.S.
= U  { : UU }
V2 = V1  { : U U  { : UU }}
Semantik von ML0
Von F abhängiges Produkt XU F(X)
 Hilfsmittel zur Darstellung der Interpretation von
Typschemata als Funktionen 
 XU F(X) = F(X1)×...×F(Xn)
= { : U XU F(X) | (X)  F(X)}
Für jedes Tupel Projektionsfunktion , um
Element des Tupels herauszuprojezieren
 Bsp. F(1)={a, b}; F(2)={c, d}
X{1,2} F(X)
= {a, b}×{c, d} = { (a,c), (a,d), (b,c), (b,d) }
= { : {1,2} X{1,2} F(X) | (X)  F(X) }
= { {1|a, 2|c}, {1|a, 2|d},
{1|b, 2|c}, {1|b, 2|d} }
Semantik von ML0
Interpretation von Typen und Typschemata
 Typvariablen a:
|[a]| = (a)
 Funktionstypen:
|[st]| = |[s]||[t]|
 Typschemata:
|[a.T]| =
XU |[T]|[a|X]

Typschemafunktion F(X) = |[T]|[a|X] liefert uns
für jede konkrete Typeinsetzung X in den formalen
Typparameter a die Interpretation...



einer Typinstanz des Schemas
Oder eines weiteren Typschemas
(Schema war mehrfach parametrisiert)
Abhängiges Produkt liefert uns Tupel, die alle
möglichen Werte bei Einsetzung aller möglichen
Typen beschreiben
Semantik von ML0
Bsp.

U = {Bool, Nat}
|[a.a]|
= XU |[a.a]|[a|X]
= |[a]|[a|Bool]
× |[a]|[a|Nat]
=  [a|Bool](a)
× [a|Nat](a)
= Bool
× Nat
= { (T, 0), (T, 1), ..., (F, 0), (F, 1), ... }
= { : {Bool, Nat}BoolNat | (X)  F(X) }
= { {Bool|T, Nat|0}, {Bool|T, Nat|1},...
{Bool|F, Nat|0}, {Bool|F, Nat|1},...}
Für alle möglichen Typen und alle möglichen
dazu passenden Werte haben wir ein 
Semantik von ML0
Interpretation von Termen
Termvariablen x
mit H├ x:t und t  H(x)  a1. ... an.s
 D.h.  Substitution  mit (s)  t
 Sei Xi = |[(ai)]| für i {1,...,n}
|[H├ x:t]| = (x)(X1)...(Xn)
Bsp. x:a.a├ x:Bool

Bool  H(x)  a.a mit (a)  Bool
 X = |[(a)]| = |[Bool]| = Bool
 (x)  |[H(x)]| = { {Bool|T, Nat|0}, ...


{Bool|F, Nat|0},...}
z.B. (x) = {Bool|T, Nat|0}
|[x: a.a├ x:Bool]| = (x)(Bool) = T
Semantik von ML0
Abstraktion
|[H├ x.M : st]| ist Funktion |[s]||[t]| mit
d | |[H, x:s├ M : t]|[x|d]
Bsp.
|[├ x.x : NatNat]| ist Funktion |[Nat]||[Nat]| mit
d | |[x:s├ x : Nat]|[x|d] = d
Applikation
|[H├ M(N) : t]|
= (|[H├ M : st]|) (|[H├ N : s]|)
Semantik von ML0
Let-Term
 polymorpher Typ s mit
close(H; s) = a1. ... an.s
 H├M:s
 Sei   |[close(H; s)]| mit
(X1)...(Xn) = |[H├ M : s]|([a1,...,an| X1...Xn])
|[H├ let x=M in N : t]|
= |[H, x:close(H; s)├ N : t]|[x|]
Semantik von ML0
Bsp. Let-Term


=
=
=
=
close(H; s) = a.a und H├y:s
Sei   |[close(H; s)]| mit
 = |[H├ y : s]|([a| X])
= (y) : |[s]|[a| X]
= {Bool |T, Nat|0} ist eine mögliche Belegung
|[H├ let x=y in pair(succ(x), not(y)) : t]|
|[H, x:close(H; s)├ pair(succ(x), not(x)) : t]|[x|]
pair( succ(|[H, x:close(H; s)├ x:s]|[x|] ),
not( |[H, x:close(H; s)├ x:s]|[x|]))
pair( succ([x|](x)(Nat)), not([x|](x)(Bool)))
pair( succ(0), not(T) )
Typinferenz in ML0

Für Term M in Typumgebung H lässt sich
ein Typ rekonstruieren („inferieren“)
Polymorphes -Kalkül


Eigentlich:
Girard-Reynolds polymorphes -Kalkül
(wegen großer Bekanntheit meist einfach
nur „ polymorphes -Kalkül“)
Verallgemeinerung von ML0


Abstraktion und Applikation für Typvariablen
explizit in Termen
D.h. eigene Syntax für Typen in Termen
Syntax des
polymorphen -Kalküls
x TermVar
a TypeVar
t ::=
a
// Typen
| tt
| a. T
M ::=
x
| x:t.M
| MM
| a.M
// Typabstraktion
| M{t}
// Typapplikation
Polymorphes -Kalkül - Ausblick

Zur Beschreibung der Semantik
Mengentheorethisches Modell nicht
ausreichend



Partielle Äquivalenzrelationen
Domains
Typinferenz ist nicht entscheidbar (1994)