Lehrstuhl für Programmierparadigmen

Lehrstuhl für Programmierparadigmen

Sebastian Ullrich Max Wagner

sebastian.ullrich@kit.edu maximilian.wagner@kit.edu

Semantik von Programmiersprachen – SS 2019

http://pp.ipd.kit.edu/lehre/SS2019/semantik

Lösungen zu Blatt 8: Typsicherheit Besprechung: 17.06.2019

1. Welche der folgenden Aussagen sind richtig, welche falsch? (H) (a) [x7→int, y7→bool]`(x + 3 <= 17) || (not y):bool

(b) Im Kontext[x7→bool]ist true == x ist ein typkorrekter Ausdruck.

(c) EJ0 * (x - y)K[x7→5, y7→tt] = 0

(d) Jeder Ausdruckehat in jedem KontextΓ höchstens einen Typτ. (e) Der Typ eines Wertesv ließe sich auch so definieren:

type(v) =τ gdw. Γ`v:τ (f) Es gibt keinen KontextΓ mit

Γ`{ var x = x; z := x }; { var y = x; if (y) then z := 5 else skip }X

(g) WennΓ`cXundhc, σi →<sub>1</sub>hc<sup>0</sup>, σ<sup>0</sup>i mitσ<sup>0</sup> : Γ undΓ`c⁰X, dann auchσ : Γ.

(h) WennΓ`cXundσ : Γ, dann gibt esc⁰ undσ⁰ mit hc, σi →₁ hc⁰, σ⁰i.

Lösung:

(1a) Das hängt vom Syntaxbaum des Ausdrucks ab. Durch die geänderte Grammatik gibt es zwei mögliche Syntaxbäume:

((x + 3) <= 17) || (not y) und (x + (3 <= 17)) || (not y)

Im linken Fall gilt die Aussage, obwohl für+und||keine Typregeln definiert wurden – diese sind nur syntaktischer Zucker und damit automatisch abgedeckt. Ohne syntaktischen Zucker schreibt sich dieser Ausdruck wie folgt:

not ((not ((x - (0 - 3)) <= 17)) && (not (not y)))

Der Ableitungsbaum im Typsystem müsste für diesen Ausdruck aufgestellt werden.

Im rechten Fall gilt die Typaussage nicht, weil int + bool nicht typisierbar ist.

(1b) Falsch.true == x ist zwar ein Ausdruck, aber nicht typkorrekt. e1 == e2 ist syntaktischer Zucker für(e₁ <= e₂) && (e₂ <= e₁). Nach den Typregeln für<= müssen e₁ unde₂ den Typint besitzen.

Wollte man Gleichheit auch für boolesche Ausdrücke, gibt es zwei Möglichkeiten:

i. Explizite Produktion für==in Exp. Dann bräuchte man dafür auch eine eigene Typregel Γ`e<sub>1</sub> :τ Γ`e₂ :τ

Γ`e₁ == e₂:bool

und entsprechend auch eigene Semantikregeln, Beweisfälle etc.

ii. Man führt zwei Ersetzungsmöglichkeiten füre₁ == e₂ ein:

(e1 <= e2) && (e2 <= e1) und (e1 && e2) || ((not e1) && (not e2)) Dann ist es aber unmöglich, mit ==einen eindeutigen Syntaxbaum zu beschreiben. Erst ein Typcheck könnte „unsinnige“ Syntaxbäume eliminieren.

(1c) Falsch. WegenEJx - yK[x7→5, y7→tt] =⊥giltEJ0 * (x - y)K[x7→5, y7→tt] =⊥.

0 ist für* (wiefalse für &&)nicht mehr ein absorbierendes Element.

(1d) Richtig. Formal: WennΓ`e:τ und Γ`e:τ⁰, dannτ =τ⁰.

Beweis. Normal bräuchte man Regel-Induktion über Γ ` e : τ (τ⁰ beliebig). Für unser einfaches Typsystem reicht aber Fallunterscheidung:

• Fälle _TNum,_TMinus,_TTimes:

Zu zeigen: Wenn Γ`e:τ⁰ (wobeie=n,e=e₁ - e₂ odere=e₁ * e₂), dann int=τ⁰. Beweis durch Regelinversion.

• Fälle _TTrue,_TLeq,_TAnd,_TNot: Analog mit bool.

• Fall _TVar: Zu zeigen: WennΓ`x:τ⁰ und Γ(x) =τ, dann τ =τ⁰. Beweis: Durch Regelinversion gilt Γ(x) =τ⁰.

Typsysteme, die jeder syntaktischen Einheit höchstens einen Typ zuweisen, heißen mono- morph.

(1e) Falsch. Wie in (1d) gezeigt, ist der Typ eines Ausdrucks zwar eindeutig, aber hier wird wieder Syntax mit abstrakten Werten vermischt. v ist aus Z+B, kein Ausdruck. Richtig wäre z.B. type(v) =τ gdw.Γ` V⁻¹JvK:τ.

(1f) Richtig. Aus den Typregeln ergeben sich folgende widersprüchliche Bedingungen:

• Im vorderen Block muss die lokale Variable x wegen der Initialisierung den gleichen Typ wie die globale Variablex haben. Wegenz := xmussz den gleichen Typ haben wie die lokale Varialbe x. Insgesamt: Γ(z) = Γ(x)

• Da die lokale Variable y des zweiten Blocks als Bedingung auftaucht, muss sie den Typ bool haben. Wegen der Initialisierung mit der globalen Variablex gilt also:Γ(x) =bool.

• Wegen z := 5muss geltenΓ(z) =int.

(1g) Falsch. Dies ist die Umkehrung zur Erhaltung der Zustandskonformanz (Lem. 77). Gegen- beispiel:

Sei Γ = [x7→int]. Dann gilt Γ ` x := 0 X, hx := 0, [x7→tt]i →<sub>1</sub> hskip, [x7→0]i mit [x7→0] : Γund Γ`skipX, aber nicht [x7→tt] : Γ.

(1h) Falsch. Dies ist nurfast das Fortschrittslemma 76. Für den Fall c=skipgilt es nicht.

2. Ausgaben (H)

Erweitern Sie die SpracheWhile_T um Ausgaben:

(a) Ergänzen Sie die Syntax um eine neue Anweisungprint e für Ausgaben.

(b) Passen Sie die Typ-Regeln an. Sowohl Zahlen als auch Wahrheitswerte sind als Ausgabe erlaubt.

(c) Ändern Sie die Big-Step-Semantik, sodass die neue Auswertungsrelation hc, σi ⇓_o σ⁰ die Anweisung c im Anfangszustand σ zum Endzustand σ⁰ auswertet, wobei die Liste der Ausgabeno entsteht.

(d) Passen Sie auch die Small-Step-Semantik an Ausgaben an. Unterscheidet sie sich in der Ausdrucksmächtigkeit von der Big-Step-Semantik?

(e) Ist die erweiterte Sprache typsicher? Begründen Sie!

Lösung:

(2a) Man braucht nur die Anweisungssyntax zu erweitern:

Com c ::= skip |x := e|c₁; c₂ |if (e) then c₁ else c₂ |while (e) do c| { var x = e; c } |print e

(2b) Neue Typregel:

TPrint: Γ`e:τ Γ`print eX (2c) Man muss jede Regel anpassen – auch erst einmal fürWhile_T:

Skip^O_BS:hskip, σi ⇓_[] σ _Ass^O_BS: EJeKσ =v hx := e, σi ⇓_[] σ[x7→v]

Seq^O_BS: hc₁, σi ⇓_o1 σ⁰ c2, σ⁰

⇓_o2 σ⁰⁰ hc₁; c₂, σi ⇓_o1++o2 σ⁰⁰

IfTT^O_BS: EJeKσ=tt hc₁, σi ⇓_oσ⁰ hif (e) then c₁ else c₂, σi ⇓_oσ⁰

IfFF^O_BS: EJeKσ=ff hc₂, σi ⇓_oσ⁰ hif (e) then c1 else c2, σi ⇓_oσ⁰

WhileFF^O_BS: EJeKσ =ff

hwhile (e) do c, σi ⇓_[] σ

WhileTT^O_BS: EJeKσ=tt hc, σi ⇓_o1 σ⁰

while (e) do c, σ⁰

⇓_o2 σ⁰⁰ hwhile (e) do c, σi ⇓_o1++o2 σ⁰⁰

Block^O_BS: EJeKσ=v hc, σ[x7→v]i ⇓_o σ⁰ h{ var x = e; c }, σi ⇓_oσ⁰[x7→σ(x)]

Die neue Regel für print e:

Print^O_BS: EJeKσ =v hprint e, σi ⇓_[v]σ

(2d) Auch die Small-Step-Relationhc, σi→ hc^{o 0}, σ⁰i muss komplett angepasst werden. Über dem Pfeil steht jetzt die Ausgabe des aktuellen Schritts (als maximal einelementige Liste).

Ass^O_SS: EJeKσ=v

hx := e, σi→ hskip, σ[x^[] 7→v]i

Print^O_SS: EJeKσ =v

hprint e, σi→ hskip, σi^[v]

Seq1^O_SS: hc₁, σi→ hc^{o 0}₁, σ⁰i

hc₁; c₂, σi→ hc^{o 0}₁; c₂, σ⁰i ^IfTT

O

SS: EJeKσ=tt

hif (e) then c1 else c2, σi→ hc^[] ₁, σi

Seq2^O_SS:hskip; c, σi→ hc, σi^[] IfFF^O_SS: EJeKσ=ff

hif (e) then c1 else c2, σi→ hc^[] ₂, σi

While^O_SS:hwhile (e) do c, σi→ h^[] if (e) then c; while (e) do c else skip, σi

Block1^OSS: EJeKσ =v hc, σ[x7→v]i→ hc^{o 0}, σ⁰i h{ var x = e; c }, σi→ h{ var^o x = V⁻¹q

σ⁰(x)y

; c⁰ }, σ⁰[x7→σ(x)]i

Block2^OSS: EJeKσ 6=⊥

h{ var x = e; skip }, σi→ h^[] skip, σi

Jetzt muss man auch die Semantik durch Ableitungsfolgen anders definieren. Eine endliche Ableitungsfolgehc₀, σ0i→ hc^o0 ₁, σ1i→^o1 . . .^o→ hcⁿ⁻¹ _n, σnifassen wir nun mithc, σi→^o∗ hc⁰, σ⁰i zusammen, wobei o =o₀++o₁++. . . on−1. Entsprechend verkürzen wir eine unendliche Ableitungsfolge hc₀, σ0i→ hc^o0 ₁, σ1i→^o1 . . . auf hc₀, σ0i→^{o ∞}, wobeio=o0++o1++. . ..

Big- und Small-Step-Semantik sind jetzt nicht mehr gleich ausdrucksstark: Die Ausgaben nichtterminierender Programme sind in der Small-Step-Semantik ausdrückbar; in der Big- Step-Semantik gibt es nur Nichtableitbarkeit, aber keine Unterscheidung der generierten Ausgaben.

(2e) Ja, die neue Sprache ist typsicher. Der Typsicherheitsbeweis mit Fortschrittslemma, Erhaltung der Zustandskonformanz und Subject Reduction lässt sich leicht um die neuen Fälle für print eergänzen. Die zusätzlichen Ausgaben in allen Regeln werden von Typsystem und Konformanz ignoriert und führen auch keine neuen Bedingungen in den Small-Step-Regeln durch die Hintertür ein.

3. Typsicherheit mit der Big-Step-Semantik (Ü)

Typsicherheit lässt sich auch für eine Big-Step-Semantik zeigen, in dieser Aufgabe für While_T: (a) Ändern Sie die Auswertungsrelation so, dass eine Anweisung mit einem Zustand statt zu

einem Endzustand auch zu einem speziellen Fehlerwert Errauswerten kann. Fügen Sie nun für jede Regel, die einen Typcheck (implizit) durchführt, eine neue Regel für den Fehlerfall hinzu. Vergessen Sie auch nicht Propagationsregeln für den TypfehlerErr.

(b) Zeigen Sie, dass typkorrekte Programme von konformanten Zuständen aus nie Typfehler erzeugen: WennΓ`cX,σ: Γ undhc, σi ⇓σ¯⁰, dann σ¯⁰6=Errundσ¯⁰ : Γ.

(c) Vergleichen Sie diesen Ansatz, Typsicherheit einer Sprache zu zeigen, mit dem Small-Step- Ansatz aus der Vorlesung.

Lösung:

(3a) Unterscheidung in korrekte Auswertungσ und TypfehlerErr:

h·, ·i ⇓ · ⊆Com×Σ×(Σ +{Err})

Normale Regeln der Big-Step-Semantik mit der Variablenkonventionσ¯∈(Σ +{Err}):

Skip^T_BS:hskip, σi ⇓σ _Ass^T_BS: EJeKσ =v

hx := e, σi ⇓(σ[x7→v])

Seq^T_BS: hc₁, σi ⇓σ⁰ c₂, σ⁰

⇓σ¯⁰⁰ hc₁; c₂, σi ⇓σ¯⁰⁰

IfTT^T_BS: EJeKσ =tt hc₁, σi ⇓σ¯⁰ hif (e) then c₁ else c₂, σi ⇓σ¯⁰

IfFF^T_BS: EJeKσ =ff hc₂, σi ⇓σ¯⁰ hif (e) then c₁ else c₂, σi ⇓σ¯⁰

WhileFF^T_BS: EJeKσ =ff hwhile (e) do c, σi ⇓σ

WhileTT^T_BS: EJeKσ=tt hc, σi ⇓σ⁰

while (e) do c, σ⁰

⇓σ¯⁰⁰ hwhile (e) do c, σi ⇓σ¯⁰⁰

Block^T_BS: EJeKσ =v hc, σ[x7→v]i ⇓σ⁰ h{ var x = e; c }, σi ⇓(σ⁰[x7→σ(x)])

Anmerkung zu den Änderungen: Ergebnisse müssen immer die Formσ oderErr haben.

Wenn das Resultat einer Regel weiterverarbeitet werden soll (in weiteren Prämissen wie Seq^T_BS und_WhileTT^T_BS oder durch Änderung des Zustands wie in_Block^T_BS), dann darf dies nur bei normaler Auswertungσ möglich sein.

Und jetzt noch die ganzen Regeln für Typfehler (keine vergessen!):

Ass^Err_BS : EJeKσ=⊥

hx := e, σi ⇓Err ^Seq

Err

BS : hc₁, σi ⇓Err hc₁; c2, σi ⇓Err

If^Err_BS : EJeKσ /∈B

hif (e) then c1 else c2, σi ⇓Err

While^Err_BS ¹: EJeKσ /∈B

hwhile (e) do c, σi ⇓Err ^While

Err2

BS : EJeKσ =tt hc, σi ⇓Err hwhile (e) do c, σi ⇓Err

Block^Err_BS ¹: EJeKσ=⊥

h{ var x = e; c }, σi ⇓Err ^Block

Err2

BS : EJeKσ =v hc, σ[x7→v]i ⇓Err h{ var x = e; c }, σi ⇓Err (3b) Diese Aussage beinhaltet im Wesentlichen den Beweis zur Zustandskonformanzerhaltung bei

Small-Step (Lem. 77).

Zu zeigen: Wennhc, σi ⇓σ¯⁰ mit Γ`cXund σ: Γ, dann ist σ⁰ von der Form σ⁰⁰ mitσ⁰⁰: Γ.

Beweis. Regel-Induktion überhc, σi ⇓σ¯⁰ (Γbeliebig). Wegen der nichtterminierenden Regel WhileTT^T_BS ist dies die einzige Beweismöglichkeit.

• Fälle _Skip^T_BS,_WhileFF^T_BS: Trivial.

• Fall _Ass^T_BS: Beweis analog zur Zustandskonformanzerhaltung bei Small-Step (Lem. 77).

• Fall _Ass^Err

BS : Aus Γ ` x := e X erhält man durch Regelinversion (<sub>TAss</sub>) ein τ mit Γ(x) =τ undΓ`e:τ. Zusammen mitσ: Γgilt nach Lem. 75:EJeKσ6=⊥. Widerspruch zur FallannahmeEJeKσ =⊥.

• Fall _Seq^T

BS: Induktionsannahmen:

(i) WennΓ`c₁ Xundσ : Γ, dann istσ⁰ von der Form. . . naja, ist ja schon von der Form.

Wir erhalten allerdings noch σ⁰: Γ.

(ii) WennΓ`c₂Xund σ⁰ : Γ, dann istσ¯⁰⁰ von der Form σ⁰⁰⁰ mit σ⁰⁰⁰ : Γ.

Zu zeigen: Wenn Γ`c₁; c₂ Xund σ: Γ, dann ist σ¯⁰⁰ von der Formσ⁰⁰⁰ mitσ⁰⁰⁰ : Γ.

Aus Γ`c1; c2 Xerhält manΓ`c1 Xund Γ`c2 Xdurch Regelinversion (_TSeq).

Mitσ: Γfolgt nach Induktionsannahme (i), dassσ⁰: Γ(hier benötigt man den Erhalt der Zustandskonformanz). Aus Induktionsannahme (ii) folgt dann direkt die Behauptung.

• Fall _Seq^Err_BS : Induktionsannahme: WennΓ`c1 Xund σ: Γ, dann istErrvon der Form σ⁰ mitσ⁰ : Γ.

Zu zeigen: Wenn Γ`c₁; c₂ Xund σ: Γ, dann ist Errvon der Form σ⁰ mit σ⁰ : Γ.

Regelinversion auf Γ`c1; c2 XliefertΓ`c1X. Damit kann man die die Induktionsan- nahme anwenden, die eine absurde Aussage liefert, und eine absurde Aussage ist so gut wie jede andere.

• Fall _WhileTT^T_BS: Induktionsannahmen:

(i) Wenn Γ`cXundσ : Γ, dann ist σ⁰ von eben der Form und σ⁰ : Γ.

(ii) Wenn Γ`while (e) do cXundσ⁰ : Γ, ist σ¯⁰⁰ von der Form σ⁰⁰⁰ mit σ⁰⁰⁰: Γ.

Zu zeigen: Wenn Γ`while (e) do cXund σ: Γ, ist σ¯⁰⁰ von der Formσ⁰⁰⁰ mit σ⁰⁰⁰: Γ.

Aus Γ`while (e) do cXfolgt Γ`cX. Mit Induktionsannahme (i) erhält man wieder σ⁰ : Γ. Induktionsannahme (ii) liefert die Behauptung.

Dieser Fall ist ähnlich zu _Seq^T_BS, braucht aber die Induktion über hc, σi ⇓ σ¯⁰ für die Induktionsannahme (ii), deren Anweisung nicht kleiner ist als die Konklusion.

• Fall _While^Err_BS ¹: Aus Lem. 75 folgt mit Γ ` e :B (Regelinversion_TWhile) und σ : Γ, dassEJeKσ=v mitv∈B. Widerspruch zur Fallannahme EJeKσ /∈B.

• Fälle _While^Err2

BS ,_Block^Err2

BS : Analog zu_Seq^Err

BS .

• Fälle _IfTT^T_BS,_IfFF^T_BS,_If^Err_BS : Analog zu while.

• Fall _Block^T_BS: Analog zur Erhaltung der Zustandskonformanz in Lem. 77. Induktionsan- nahme brauchtΓ beliebig.

• Fall _Block^Err_BS ¹: Analog zu _Ass^Err_BS .

(3c) Typfehler werden in der Small-Step-Semantik durch Blockieren modelliert. Bei Big-Step ist dies nicht möglich, da Nichtableitbarkeit auch durch Nichttermination entstehen kann.

Vorteile Big-Step:

• Intuitiverer Ansatz, da Typfehler explizit modelliert werden.

• Beweis insgesamt einfacher, da kein Fortschritts- oder Subject-Reduction-Lemma gezeigt werden muss.

Nachteile Big-Step:

• Massive Veränderung an der Semantik nötig, i.d.R. doppelt so viele Regeln (und damit auch Beweis-Fälle in jedem Beweis über die Big-Step-Semantik.

• Typfehlerregeln sind semantisch irrelevant, weil für typkorrekte Programme nie anwend- bar. Deswegen gehören sie auch nicht in die Semantik.

• Keine Kontrolle, ob wirklich alle Typfehlerregeln eingefügt wurden.