Funktionales Programmieren Teil 9 Carl Philipp Reh

Funktionales Programmieren

Teil 9

Carl Philipp Reh

Universit¨ at Siegen

12. Juni 2020

Domains

Um denotationelle Semantik f¨ ur Haskell-Programme formal zu definieren, m¨ ussen wir zun¨ achst die Wertebereiche f¨ ur Typen festlegen. Diese werden Domains genannt. Jede Domain wird eine CPO sein. Dem Basistyp Int ordnen wir den Domain

D(Int) = Z ⊥ zu.

Welche Domains sollte man Data-Deklarationen zuordnen?

Betrachten wir

d a t a I n t P a i r = M a k e Int Int mit folgenden Beispielwerten

c :: I n t P a i r d :: I n t P a i r c = u n d e f i n e d

d = M a k e u n d e f i n e d u n d e f i n e d

Hier ist c komplett undefiniert, wohingegen d den Wertkonstruktor

Domains von Data-Deklarationen

Dass c und d sich anders verhalten, kann man gut an den folgenden beiden Funktionen erkennen:

f :: I n t P a i r - > Int f p = 0

g :: I n t P a i r - > Int

g p = c a s e p of M a k e x y - > 0

Wir haben, dass f c = 0 und f d = 0 . Ebenso haben wir g d = 0 . Allerdings terminiert g c nicht, weil es sein Argument so weit auswerten muss, bis klar ist, welcher Wertkonstruktor (hier M a k e ) angewandt wurde.

Wir ben¨ otigen also nicht nur ⊥-Werte f¨ ur die Argumente von

Wertkonstruktoren, sondern auch noch ein zus¨ atzliches ⊥ f¨ ur den

Fall, dass kein Wertkonstruktor angewandt wurde.

Weitere CPOs

Um die n¨ achsten CPO-Konstruktionen etwas zu vereinfachen, formulieren wir folgendes Lemma:

Lemma 12

Sei (D, v _D ) eine CPO und c : N → D eine Kette.

1. Dann ist auch c _k : N → D mit c _k (n) = c (n + k) f¨ ur jedes k ∈ N eine Kette und es gilt tc _k = tc.

2. Sei (E , v _E ) eine CPO mit E ⊆ D, wobei v _E die

Einschr¨ ankung von v _D auf E ist, und sei Img(c) ⊆ E . Dann ist auch c _E : N → E mit c _E (n) = c (n) eine Kette und es gilt tc _E = tc.

Beweis.

Wir haben Punkt 1 bereits f¨ ur k = 1 in der ¨ Ubung gezeigt. F¨ ur

k > 1 funktioniert die Argumentation analog. Punkt 2 ist klar.

Lift einer CPO (Teil 1)

Der Lift einer CPO (D, v _D ) ist (D ⊥ , v _D

) mit D ⊥ = D ] {⊥ _D } und d v _D

d ⁰ genau dann, wenn d = ⊥ _D oder d , d ⁰ ∈ D mit d v _D d ⁰ .

Lemma 13

(D ⊥ , v _D

) ist eine CPO.

Beweis.

Reflexivit¨ at: Sei d ∈ D ⊥ . Wenn d = ⊥ _D , dann gilt d v d . Wenn

d ∈ D, dann gilt d v _D d , also auch d v d . Antisymmetrie: Seien

d , d ⁰ ∈ D ⊥ mit d v d ⁰ und d ⁰ v d . Wenn d = ⊥ _D , dann gilt

d ⁰ v ⊥ _D und somit muss d ⁰ = ⊥ _D sein. Der Fall, dass d ⁰ = ⊥ _D ,

ist analog. Wenn d , d ⁰ ∈ D, dann gilt d v _D d ⁰ und d ⁰ v _D d , also

auch d = d ⁰ . Transitivit¨ at: Seien d , d ⁰ , d ⁰⁰ ∈ D ⊥ mit d v d ⁰ und

d ⁰ v d ⁰⁰ . Wenn d = ⊥ _D , dann gilt auch d v d ⁰⁰ . Wenn d ∈ D,

dann gilt d v _D d ⁰ . Daraus folgt d ⁰ ∈ D, also auch d ⁰ v _D d ⁰⁰ . Also

gilt d ⁰ v _D d ⁰⁰ und somit d v d ⁰⁰ .

Lift einer CPO (Teil 2)

Beweis.

Nach Definition von v _D

ist klar, dass ⊥ _D das kleinste Element ist.

Sei c : N → D ⊥ eine Kette. Wir haben zwei F¨ alle zu unterscheiden:

Wenn c (n) = ⊥ _D f¨ ur alle n ∈ N , dann ist c ⁰ : N → {⊥ _D } mit

c ⁰ (d ) = c (d ) eine Kette und es gilt tc = tc ⁰ nach Punkt 2 von

Lemma 12. Ansonsten gibt es ein k ∈ N mit c (k) ∈ D. Nach

Definition von v _D

muss dann f¨ ur alle k ⁰ > k gelten, dass

c(k ⁰ ) ∈ D. Also ist c ⁰ : N → D mit c ⁰ (n) = c(n + k ) eine Kette

und es gilt tc = tc ⁰ nach Punkten 2 und 1 von Lemma 12.

Domains von Data-Deklarationen

Wir betrachten zun¨ achst nicht rekursive Data-Deklarationen mit nur einem Wertkonstruktor: d a t a T C o n = V C o n. Solch ein Wertkonstruktor V C o n ist allgemein von der Form

V C o n = N T_1 ... T_n

wobei N ein Bezeichner ist und T_1 bis T_n f¨ ur n ≥ 0 Typen sind.

Werte, die mit N erzeugt wurden, sollen ein Element folgender Menge sein:

D(VCon) := {N} × D(T ₁ ) × · · · × D(T _n ) Die Menge {N} enth¨ alt nur einen Wert, der uns sagt, welcher Wertkonstruktor angewandt wurde. Da wir ein zus¨ atzliches ⊥ ben¨ otigen f¨ ur den Fall, dass kein Wertkonstruktor angewandt wurde, w¨ ahlen wir f¨ ur T C o n also

D(TCon) := D(VCon) _⊥ = ({N} × D(T ₁ ) × · · · × D(T _n )) ⊥

Domains von Data-Deklarationen

Betrachten wir wieder

d a t a I n t P a i r = M a k e Int Int

Hier haben wir also

D(IntPair) = D(Make Int Int) _⊥ = ({Make} × Z ⊥ × Z ⊥ ) ⊥

F¨ ur die vorherigen Werte c = u n d e f i n e d

d = M a k e u n d e f i n e d u n d e f i n e d

erhalten wir dann J c K = ⊥ und J d K = (Make, ⊥, ⊥). F¨ ur e = M a k e 0 1

erhalten wir J e K = (Make, 0, 1).

Domains f¨ ur mehrere Wertkonstruktoren

Als N¨ achstes betrachten wir Data-Deklarationen mit mehr als einem Wertkonstruktor. Die einfachste von diesen ist B o o l mit d a t a B o o l = T r u e | F a l s e

Wir haben D(True) = {True} und D(False) = {False} f¨ ur die beiden Wertkonstruktoren. Um beide Werte zusammenzuf¨ ugen, liften wir zun¨ achst die Domains und erhalten

D(True) _⊥ = {True, ⊥} und D(False) _⊥ = {False, ⊥}. Diese werden dann ¨ uber die verschmolzene Summe zusammengef¨ ugt, wo die beiden ⊥ von D(True) _⊥ und D(False) _⊥ identifiziert werden.

Wir werden außerdem aus technischen Gr¨ unden Elemente aus D(True) und D(False) mit

” Tags“ versehen, die sicher stellen,

dass nur disjunkte Mengen vereinigt werden.

Summe

Die Summe von n ≥ 0 Mengen M 1 , . . . , M n ist

M ₁ + · · · + M _n = (M ₁ × {1}) ∪ · · · ∪ (M _n × {n}).

Im Fall, dass n = 0, nehmen wir ∅. Die

” Tags“ 1, . . . , n stellen sicher, dass man f¨ ur jedes Element weiß, aus welcher Menge es gekommen ist, da die Mengen M 1 , . . . , M n nicht disjunkt sein m¨ ussen. Im Gegensatz zu Summen kann man bei der Vereinigung zweier Mengen diese Information verlieren, zum Beispiel bei N ∪ Z = Z . Der Name Summe kommt daher, dass

|A + B| = |A| + |B| f¨ ur alle Mengen A und B gilt. Wenn klar ist,

aus welcher Quellmenge ein Element (m, i) ∈ M _i × {i } kommt,

schreiben wir auch einfach nur m.

Verschmolzene Summe

Seien (D 1 , v _D

), . . . , (D n , v _D

) CPOs. Die Verschmolzene Summe (D 1 ⊕ · · · ⊕ D n , v _D

_{⊕···⊕D}

) ist

D 1 ⊕ · · · ⊕D _n = ((D 1 \ {⊥ _D

}) +· · · + (D n \ {⊥ _D

})) ∪ {⊥ _D

_{⊕···⊕D}

}, wobei d v _D

_{⊕···⊕D}

d ⁰ genau dann, wenn d = ⊥ _D

_{⊕···⊕D}

, oder d = (e, i ) ∈ (D i \ {⊥ _D

}) × {i } und

d ⁰ = (e ⁰ , i) ∈ (D _i \ {⊥ _D

}) × {i} f¨ ur 1 ≤ i ≤ n mit e v _D

e ⁰ . Wir entfernen also alle kleinsten Elemente aus D ₁ , . . . , D _n und f¨ ugen ein neues kleinstes Element hinzu.

Lemma 14

(D ₁ ⊕ · · · ⊕ D _n , v _D

_{⊕···⊕D}

) ist eine CPO.

Beweis.

Ubung. ¨

Domains f¨ ur mehrere Wertkonstruktoren

Im Fall von B o o l erhalten wir also

D(Bool) = D(True) _⊥ ⊕ D(False) _⊥

= {True, ⊥} ⊕ {False, ⊥}

= ({True} + {False}) ∪ {⊥}

= {(True, 1), (False, 2), ⊥}

Da bei (True, 1) und (False, 2) klar ist, aus welcher Menge sie kamen, k¨ onnen wir stattdessen einfach True und False schreiben.

Grafisch ergibt sich folgende Ordnung:

True False

⊥

Domains f¨ ur mehrere Wertkonstruktoren

Allgemeiner sei

d a t a T C o n = V C o n _ 1 | ... | V C o n _ n wobei jedes V C o n _ i f¨ ur 1 ≤ i ≤ n mit n ≥ 0 einen

Wertkonstruktor deklariert. Auch hier erlauben wir zun¨ achst keine Rekursion. Wir ordnen T C o n folgenden Domain zu:

D(TCon) = D(VCon ₁ ) ⊥ ⊕ · · · ⊕ D(VCon _n ) ⊥

Da wir im Allgemeinen nur F¨ alle betrachten werden, wo die

Wertkonstruktornamen in den V C o n _ i verschieden sind, werden

wir die Tags in der Summe – wie wir es bei True und False getan

haben – ignorieren k¨ onnen.