ml 0 syntax, typsystem und semantik. -kalkül fromalisierung von funktionaler berechenbarkeit...
TRANSCRIPT
![Page 1: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/1.jpg)
ML0
Syntax, Typsystem und Semantik
![Page 2: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/2.jpg)
-Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax:
x TermVarM ::= x // Variable| x.M // Abstraktion| M M// Applikation
Variablenumgebung : TermVar Werte Kann auf verschiedene Art und Weise durch Typsystem
ergänzt werden Dabei: Ausdrucksmächtigkeit vs. Sicherheit
![Page 3: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/3.jpg)
Ungetyptes -Kalkül Kein Typsystem exotische „sinnvolle“ Terme erlaubt:
(f. f( f )) y.y f.( (x. f( x(x) )) (x.f( x(x) )) )
(„paradoxical combinator“) Jedoch auch unsinnige Terme erlaubt:
zero( zero ) sehr ausdrucksmächtig, aber genauso unsicher
![Page 4: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/4.jpg)
Explizit getyptes -Kalkül Typen sind explizit gegeben:
Typumgebung H: TermVar Typen t ::= Grundtyp | tt M ::= x | x:t.M | M M
Typregeln: [Proj] x H
H├ x:H(x) [Abs] H, x:s├ M:t
H├ x:s.M : st [Appl] H├ M: st H├ N: s
H├ M(N) : t
![Page 5: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/5.jpg)
Implizit getyptes -Kalkül Keine Type-Tags
M ::= x | x.M | M M 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 : st
![Page 6: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/6.jpg)
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(rs)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
![Page 7: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/7.jpg)
Implizit getyptes -Kalkül:Mächtigkeitsgrenze Bsp. M f. f(f)
Typ von f müsste zwei Typschemata entsprechen:rs 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)
![Page 8: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/8.jpg)
Polymorphismus Typsystem, das Terme erlaubt mit...
gleichem Subtermin verschiedenen Kontexten mit verschiedenen Typen
Deckt „grauen Bereich“ sinnvoller Terme zwischenungetyptem und implizit getyptem -Kalkül ab
Mehrere mögliche Implementierungen: ML0 Girard-Reynolds polymorphes -Kalkül Typ:Typ Kalkül ...
![Page 9: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/9.jpg)
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
![Page 10: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/10.jpg)
Syntax von ML0
x TermVara TypeVart ::= a | tt // TypenT ::= t | a. T // TypschemataM ::= x| x.M | M M| let x=M in M // let-Konstrukt
Let ähnlich (x.N) M jedoch andere Typregeln
![Page 11: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/11.jpg)
Typsystem von ML0
Typumgebung H: TermVar TypschemaBsp.H {zero : a. a, id : a. aa,
filter : a.i. (aBool)(ia)(ia) }
Typ s ist Instanz von Typschema T a1. ... an.t
(kurz: s T)
gdw. Substitution auf {a1,...,an} mit (t)=s
Bsp. NatNat a. aa
StringString a. aa
![Page 12: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/12.jpg)
Typsystem von ML0 Abschluss (closure) eines Typs t
bzgl. Typumgebung H:close(H; t) = a1. ... an.tmit {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 TypschemaBsp. H { x:Bool, id : a. aa }
t aBoolFtv(H) = { Bool } Ftv(t)= { a, Bool }close(H; t) = a. aBool
![Page 13: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/13.jpg)
Typsystem von ML0 [Proj] x:TH tT
H├ x:t
[Abs] H, x:s├ M:t
H├ x.M : st
[Appl] H├ M: st 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
![Page 14: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/14.jpg)
Typsystem von ML0
Projektion einer Variablen aus der Typumgebung[Proj] x:TH tT
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
![Page 15: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/15.jpg)
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
![Page 16: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/16.jpg)
Typsystem von ML0
Bsp. N let f = x.x in f(f)
[Proj] [Abs] x:a├ x:a
├ x.x : aa und close(, aa) = a.aa
[Proj][Appl] f:a.aa├ f : aa f:a.aa├ f : (aa)(aa)
f:a.aa├ f(f) : aa
[Let] ├ x.x : aa f:a.aa├ f(f) : aa
├ let f = x.x in f(f) : aa
![Page 17: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/17.jpg)
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
![Page 18: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/18.jpg)
Semantik von ML0Universum U semantische Interpretation von Typen Rekursiv definiert:
D0 = {X0} mit X0 Interpretation des Grundtyps Dn+1 = Dn { XY | X,Y Dn } U = n |N Dn
D0 = { X0 } // KonstantenD1 = D0 { X0X0 } // 2-st. FunktionenD2 = D1 { X0(X0X0), (X0 X0)X0 }... // 3-st. Funktionale
![Page 19: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/19.jpg)
Semantik von ML0Universum V semantische Interpretation von Typschemata
(als Funktionen von Typen auf Typen) Rekursiv definiert:
V0 = U (Universum der Interpret. der Typen) Vn+1 = Vn UVn
V = n |N Vn
V0 = U // einfache TypenV1 = V0 UU // einfach parametr. T.S.= U { : UU }V2 = V1 { : U U { : UU }} ... // 2-fach parametr. T.S.
![Page 20: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/20.jpg)
Semantik von ML0
Von F abhängiges Produkt XU F(X) Hilfsmittel zur Darstellung der Interpretation von
Typschemata als Funktionen XU F(X) = F(X1)×...×F(Xn)
= { : U XU 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} }
![Page 21: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/21.jpg)
Semantik von ML0
Interpretation von Typen und Typschemata Typvariablen a: |[a]| = (a) Funktionstypen: |[st]| = |[s]||[t]| Typschemata: |[a.T]| =
XU |[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
![Page 22: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/22.jpg)
Semantik von ML0Bsp. U = {Bool, Nat}
|[a.a]| = XU |[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}BoolNat | (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
![Page 23: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/23.jpg)
Semantik von ML0Interpretation von TermenTermvariablen 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
![Page 24: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/24.jpg)
Semantik von ML0
Abstraktion|[H├ x.M : st]| ist Funktion |[s]||[t]| mitd | |[H, x:s├ M : t]|[x|d]Bsp.|[├ x.x : NatNat]| ist Funktion |[Nat]||[Nat]| mitd | |[x:s├ x : Nat]|[x|d] = d
Applikation|[H├ M(N) : t]|
= (|[H├ M : st]|) (|[H├ N : s]|)
![Page 25: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/25.jpg)
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|]
![Page 26: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/26.jpg)
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) )
![Page 27: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/27.jpg)
Typinferenz in ML0
Für Term M in Typumgebung H lässt sich ein Typ rekonstruieren („inferieren“)
![Page 28: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/28.jpg)
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
![Page 29: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/29.jpg)
Syntax des polymorphen -Kalküls
x TermVara TypeVart ::= a // Typen| tt| a. TM ::= x| x:t.M| M M| a.M // Typabstraktion| M{t} // Typapplikation
![Page 30: ML 0 Syntax, Typsystem und Semantik. -Kalkül Fromalisierung von funktionaler Berechenbarkeit Allgemeine Syntax: x TermVar M ::= x// Variable | x.M](https://reader036.vdocuments.pub/reader036/viewer/2022062502/570491c41a28ab14218da02f/html5/thumbnails/30.jpg)
Polymorphes -Kalkül - Ausblick Zur Beschreibung der Semantik
Mengentheorethisches Modell nicht ausreichend Partielle Äquivalenzrelationen Domains
Typinferenz ist nicht entscheidbar (1994)