Prinzipien von Programmiersprachen Vorlesung Wintersemester 2007 2020 - HTWK Leipzig

Prinzipien von Programmiersprachen Vorlesung
              Wintersemester 2007 – 2020
                         Johannes Waldmann, HTWK Leipzig
                                     17. November 2020

1     Einleitung
Programme und Algorithmen
    • Algorithmus (vgl. VL Alg. und Datenstr.)
      Vorschrift zur Lösung einer Aufgabe
    • Programm (vgl. VL zu (Anwendungsorientierter) Progr.)
      Realisierung eines Algorithmus in konkreter Programmiersprache, zur Ausführung
      durch Maschine
    • Programmiersprache
      bietet Ausdrucksmittel zur Realisierung von Algorithmen als Programme

Deutsch als Programmiersprache
     §6 (2) . . . Der Zuteilungsdivisor ist so zu bestimmen, dass insgesamt so viele Sitze auf die
Landeslisten entfallen, wie Sitze zu vergeben sind. Dazu wird zunächst die Gesamtzahl der Zweit-
stimmen aller zu berücksichtigenden Landeslisten durch die Zahl der jeweils nach Absatz 1 Satz 3
verbleibenden Sitze geteilt. Entfallen danach mehr Sitze auf die Landeslisten, als Sitze zu vergeben
sind,. . .
     §6 (5) Die Zahl der nach Absatz 1 Satz 3 verbleibenden Sitze wird so lange erhöht, bis jede
Partei bei der zweiten Verteilung der Sitze nach Absatz 6 Satz 1 mindestens die bei der ersten Ver-
teilung nach den Absätzen 2 und 3 für sie ermittelten zuzüglich der in den Wahlkreisen errungenen
Sitze erhält, die nicht nach Absatz 4 Satz 1 von der Zahl der für die Landesliste ermittelten Sitze
abgerechnet werden können.
     https://www.gesetze-im-internet.de/bwahlg/__6.html

                                                 1

Beispiel: mehrsprachige Projekte
   ein typisches Projekt besteht aus:
    • Datenbank: SQL
    • Verarbeitung: Java
    • Oberfläche: HTML
    • Client-Code: Java-Script
und das ist noch nicht die ganze Wahrheit:
   nenne weitere Sprachen, die üblicherweise in einem solchen Projekt vorkommen

In / Into
    • David Gries (1981) zugeschrieben, zitiert u.a. in McConnell: Code Complete, 2004.
      Unterscheide:

            – programming in a language
              Einschränkung des Denkens auf die (mehr oder weniger zufällig) vorhandenen
              Ausdrucksmittel
            – programming into a language
              Algorithmus Ñ Programm

    • Ludwig Wittgenstein: Die Grenzen meiner Sprache sind die Grenzen meiner Welt
      (sinngemäß — Ü: Original?)
    • Folklore:
      A good programmer can write LISP in any language.

Sprache
    • wird benutzt, um Ideen festzuhalten/zu transportieren (Wort, Satz, Text, Kontext)
    • wird beschrieben durch
            –   Lexik
            –   Syntax
            –   Semantik
            –   Pragmatik
    • natürliche Sprachen / formale Sprachen

                                              2

Wie unterschiedlich sind Sprachen?

   • weitgehend übereinstimmende Konzepte.

        – LISP (1958) “ Perl “ PHP “ Python “ Ruby “ Javascript “ Clojure: impe-
          rativ, (funktional),
          nicht statisch typisiert (d.h., unsicher und ineffizient)
        – Algol (1958) “ Pascal “ C “ Java “ C#
          imperativ, statisch typisiert
        – ML (1973) “ Haskell:
          statisch typisiert, generische Polymorphie

   • echte Unterschiede ( Neuerungen“) gibt es auch
                         ”
        – CSP (1977) “ Occam (1983) “ Go: Prozesse, Kanäle
        – Clean (1987) « Rust (2012): Lineare Typen
        – Coq (1984) “ Agda (1999) “ Idris: dependent types

Konzepte

   • Hierarchien (baumartige Strukturen)

        – einfache und zusammengesetzte (arithmetische, logische) Ausdrücke
        – einfache und zusammengesetzte Anweisungen
          (strukturierte Programme)
        – Komponenten (Klassen, Module, Pakete)

   • Typen beschreiben Daten, gestatten statische Prüfung

   • Namen stehen für Werte, gestatten Wiederverwendung

   • flexible Wiederverwendung durch Parameter (Argumente)
     Unterprogramme: Daten, Polymorphie: Typen

                                           3

Paradigmen

   • imperativ
     Programm ist Folge von Befehlen
     (Befehl bewirkt Zustandsänderung)

   • deklarativ (Programm ist Spezifikation)

           – funktional (Gleichungssystem)
           – logisch (logische Formel über Termen)
           – Constraint (log. F. über anderen Bereichen)

   • objektorientiert (klassen- oder prototyp-basiert)

   • nebenläufig (nichtdeterministisch, explizite Prozesse)

   • (hoch) parallel (deterministisch, implizit)

Ziele der LV
   Arbeitsweise:      Methoden, Konzepte, Paradigmen
   • isoliert beschreiben

   • an Beispielen in (bekannten und unbekannten) Sprachen wiedererkennen
   Ziel:
   • verbessert die Organisation des vorhandenen Wissens

   • gestattet die Beurteilung und das Erlernen neuer Sprachen

   • hilft bei Entwurf eigener (anwendungsspezifischer) Sprachen

Beziehungen zu anderen LV

   • Grundlagen der Informatik, der Programmierung:
     strukturierte (imperative) Programmierung
   • Softwaretechnik 1/2:
     objektorientierte Modellierung und Programmierung, funktionale Programmierung
     und OO-Entwurfsmuster

                                              4

• Compilerbau: Implementierung von Syntax und Semantik

Sprachen für bestimmte Anwendungen, mit bestimmten Paradigmen:

   • Datenbanken, Computergrafik, künstliche Intelligenz, Web-Programmierung, paral-
     lele/nebenläufige Programmierung

Organisation

   • Vorlesung

   • Hausaufgaben (ergibt Prüfungszulassung) mit diesen Aufgaben-Formen:

        – individuell online (autotool)
        – in Gruppen (je 3 Personen) Bearbeitung im Forum, Präsentation und Bewer-
          tung in Übung
          Koordination: Opal-Kurs (Wiki, Forum)

   • Klausur: 120 min, ohne Hilfsmittel

Literatur

   • http://www.imn.htwk-leipzig.de/˜waldmann/edu/ws20/pps/folien/
   • Robert W. Sebesta: Concepts of Programming Languages, Addison-Wesley 2004,
     ...

Zum Vergleich/als Hintergrund:

   • Abelson, Sussman, Sussman: Structure and Interpretation of Computer Programs,
     MIT Press 1984 http://mitpress.mit.edu/sicp/
   • Turbak, Gifford: Design Concepts of Programming Languages, MIT Press 2008
     https://cs.wellesley.edu/˜fturbak/

                                          5

Inhalt
   (nach Sebesta: Concepts of Programming Languages)

   • Methoden: (3) Beschreibung von Syntax und Semantik
   • Konzepte:

        – (5) Namen, Bindungen, Sichtbarkeiten
        – (6) Typen von Daten, Typen von Bezeichnern
        – (7) Ausdrücke und Zuweisungen, (8) Anweisungen und Ablaufsteuerung, (9)
          Unterprogramme

   • Paradigmen:

        – (12) Objektorientierung ( (11) Abstrakte Datentypen )
        – (15) Funktionale Programmierung

Haus-Aufgaben
  0. Lesen Sie E. W. Dijkstra: On the foolishness of natural language programming“
https://www.cs.utexas.edu/users/EWD/transcriptions/EWD06xx/EWD667.
html
  und beantworten Sie

   • womit wird “einfaches Programmieren” fälschlicherweise gleichgesetzt?

   • welche wesentliche Verbesserung brachten höhere Programmiersprachen, welche
     Eigenschaft der Maschinensprachen haben sie trotzdem noch?

   • warum sollte eine Schnittstelle narrow sein?

   • welche formalen Notationen von Vieta, Descartes, Leibniz, Boole sind gemeint?
     (jeweils: Wissenschaftsbereich, (heutige) Bezeichnung der Notation, Beispiele)

   • warum können Schüler heute das lernen, wozu früher nur Genies in der Lage waren?

   • Übersetzen Sie den Satz “the naturalness of . . . obvious”.

Geben Sie dazu jeweils an:

   • die Meinung des Autors, belegt durch konkrete Textstelle und zunächst wörtliche,
     dann sinngemäße Übersetzung

                                             6

• Beispiele aus Ihrer Erfahrung

    1. zu Skriptsprachen: finde die Anzahl der "*.java"-Dateien unter $HOME/workspace,
die den Bezeichner String enthalten (oder eine ähnliche Anwendung) (Benutze eine Pi-
pe aus drei Unix-Kommandos.)
    Lösungen:

find workspace/ -name "*.java" | xargs grep -l String       | wc -l
find workspace/ -name "*.java"   -exec grep -l String {} \; | wc -l

   Das dient als Wiederholung zur Benutzung von Unix (GNU/Linux): führen Sie vor:

   • eine Shell öffnen

   • in der Manpage von find die Beschreibung von -exec anzeigen. Finden Sie (mit
     geeignetem Shell-Kommandos) den Quelltext dieser Manpage, zeigen diesen an.
     (Wie benutzt man man? so: man man.)

   • was bedeutet der senkrechte Strich? in welcher Manpage steht das? in welcher Vor-
     lesung war das dran?

   • erklären Sie https://xkcd.com/378/, führen Sie die vier genannten Editoren
     vor, in dem Sie jeweils eine einzeilige Textdatei erzeugen.

Bei Vorführung (dann mit Screen-Sharing)

   • schwarze Schrift auf weißem Grund

   • große Schrift

   2. funktionales Programmieren in Haskell (http://www.haskell.org/)

ghci
:set +t
length $ takeWhile (== ’0’) $ reverse $ show $ product [ 1 .. 100 ]

   • zeigen Sie (den Studenten, die das noch nicht gesehen haben), wo die Software (hier
     ghc) im Pool installiert ist, und wie man sie benutzt und die Benutzung vereinfacht
     (PATH)

   • Werten Sie den angegebenen Ausdruck aus sowie alle Teilausdrück ([1..100],
     product [1..100], usw.

                                            7

• den Typ von reverse durch ghci anzeigen lassen

    • nach diesem Typ in https://hoogle.haskell.org/ suchen. (Einschränken
      auf package:base) Die anderen (drei) Funktionen dieses Typs aufrufen.

    • eine davon erzeugt unendliche Listen, wie werden die im Speicher repräsentiert, wie
      kann man sie benutzen? (Am Beispiel zeigen.)

    3. PostScript

42 42 scale 7 9 translate .07 setlinewidth .5 setgray/c{arc clip fill
setgray}def 1 0 0 42 1 0 c 0 1 1{0 3 3 90 270 arc 0 0 6 0 -3 3 90 270
arcn 270 90 c -2 2 4{-6 moveto 0 12 rlineto}for -5 2 5{-3 exch moveto
9 0 rlineto}for stroke 0 0 3 1 1 0 c 180 rotate initclip}for showpage

   In eine Text-Datei what.ps schreiben (vgl. Aufgabe 1) ansehen mit gv what.ps
(im Menu: State Ñ watch file).
   Mit Editor Quelltext ändern, Wirkung betrachten.

    • Ändern Sie die Strich-Stärke!

    • wie funktioniert die Steuerung einer Zählschleife?

    • warum ist PostScript: imperativ? strukturiert? prozedural?

    • führen Sie wenigstens ein weiteres ähnliches PostScript-Programm vor (kurzer Text,
      aber nichttriviale Rechnung). Quelle angeben, Programmtext erklären!

    • nennen Sie einige Aspekte von PS, die in PDF übernommen wurden (Beantworten
      Sie anhand der Original-Dokumentation.)

    • Warum sollte man niemals “online und ganz umsonst PS to PDF converter” benut-
      zen?

2    Syntax von Programmiersprachen
Programme als Bäume

    • ein Programmtext repräsentiert eine Hierarchie (einen Baum) von Teilprogrammen
    • Die Semantik des Programmes wird durch Induktion über diesen Baum definiert.

                                            8

• In den Blättern des Baums stehen Token,
   • jedes Token hat einen Typ und einen Inhalt (eine Zeichenkette).
   • dieses Prinzip kommt aus der Mathematik (arithmetische Ausdrücke, logische For-
     meln — sind Bäume)

Token-Typen

   • reservierte Wörter (if, while, class, . . . )
   • Bezeichner (foo, bar, . . . )
   • Literale für ganze Zahlen, Gleitkommazahlen, Strings, Zeichen, . . .
   • Trenn- und Schlußzeichen (Komma, Semikolon)
   • Klammern (runde: paren(these)s, eckige: brackets, geschweifte: braces, spitze: angle
     brackets)
   • Operatoren (=, +, &&, . . . )
   • Leerzeichen, Kommentare (whitespace)

alle Token eines Typs bilden eine formale Sprache.

Formale Sprachen

   • ein Alphabet ist eine Menge von Zeichen,
   • ein Wort ist eine Folge von Zeichen,
   • eine formale Sprache ist eine Menge von Wörtern.

   Beispiele:

   • Alphabet Σ “ ta, bu,
   • Wort w “ ababaaab,
   • Sprache L “ Menge aller Wörter über Σ gerader Länge.
   • Sprache (Menge) aller Gleitkomma-Literale in C.

                                                 9

Spezifikation formaler Sprachen
   man kann eine formale Sprache beschreiben:

   • algebraisch (Sprach-Operationen)
     Bsp: reguläre Ausdrücke

   • generativ (Grammatik), Bsp: kontextfreie Grammatik,

   • durch Akzeptanz (Automat), Bsp: Kellerautomat,
                             "            ˆ                                   ˙*
                                               pp ă r ^ wrps “ a ^ wrrs “ cq
   • logisch (Eigenschaften), w | @p, r :
                                            ñ Dq : pp ă q ^ q ă r ^ wrqs “ bq

Sprach-Operationen
   Aus Sprachen L1 , L2 konstruiere:

   • Mengenoperationen

        – Vereinigung L1 Y L2 ,
        – Durchschnitt L1 X L2 , Differenz L1 zL2 ;

   • Verkettung L1 ¨ L2 “ tw1 ¨ w2 | w1 P L1 , w2 P L2 u
                                        Ť      k
   • Stern (iterierte Verkettung) L˚1 “  kě0 L1

   Def: Sprache regulär : ðñ kann durch diese Operationen aus endlichen Sprachen
konstruiert werden.
   Satz: Durchschnitt und Differenz braucht man dabei nicht.

Reguläre Sprachen/Ausdrücke
   Die Menge EpΣq der regulären Ausdrücke über einem Alphabet (Buchstabenmenge)
Σ ist die kleinste Menge E, für die gilt:

   • für jeden Buchstaben x P Σ : x P E
     (autotool: Ziffern oder Kleinbuchstaben)
   • das leere Wort  P E (autotool: Eps)
   • die leere Menge H P E (autotool: Empty)
   • wenn A, B P E, dann
        – (Verkettung) A ¨ B P E (autotool: * oder weglassen)

                                          10

– (Vereinigung) A ` B P E (autotool: +)
         – (Stern, Hülle) A˚ P E (autotool: ˆ*)

Jeder solche Ausdruck beschreibt eine reguläre Sprache.

Beispiele/Aufgaben zu regulären Ausdrücken
   Wir fixieren das Alphabet Σ “ ta, bu.

   • alle Wörter, die mit a beginnen und mit b enden: aΣ˚ b.

   • alle Wörter, die wenigstens drei a enthalten Σ˚ aΣ˚ aΣ˚ aΣ˚

   • alle Wörter mit gerade vielen a und beliebig vielen b?

   • Alle Wörter, die ein aa oder ein bb enthalten: Σ˚ paa Y bbqΣ˚

   • (Wie lautet das Komplement dieser Sprache?)

Erweiterte reguläre Ausdrücke

  1. zusätzliche Operatoren (Durchschnitt, Differenz, Potenz),
      die trotzdem nur reguläre Sprachen erzeugen
      Beispiel: Σ˚ zpΣ˚ abΣ˚ q2
      ähnlich in Konfiguration der autotool-Aufgaben

  2. zusätzliche nicht-reguläre Operatoren

      Beispiel: exakte Wiederholungen L k :“ twk | w P Lu

      Bsp.: pab˚ q 2 “ taa, abab, abbabb, ab3 ab3 , . . . u R

  3. Markierung von Teilwörtern, definiert (evtl. nicht-reguläre) Menge von Wörtern mit
     Positionen darin

                                               11

Implementierung regulärer Ausdrücke

    • die richtige Methode ist Kompilation des RE in einen endlichen Automaten
      Ken Thompson: Regular expression search algorithm, Communications of the ACM
      11(6) (June 1968)

    • wenn nicht-reguläre Sprachen entstehen können (durch erweiterte RE), ist keine ef-
      fiziente Verarbeitung (mit endlichen Automaten) möglich.

    • auch reguläre Operatoren werden gern schlecht implementiert.
      Russ Cox: Regular Expression Matching Can Be Simple And Fast (but is slow in
      Java, Perl, PHP, Python, Ruby, ...), 2007 https://swtch.com/˜rsc/regexp/
      regexp1.html

Bemerkung zu Reg. Ausdr.
  Wie beweist man w P LpXq?
  (Wort w gehört zur Sprache eines regulären Ausdrucks X)

    • wenn X “ X1 ` X2 :
      beweise w P LpX1 q oder beweise w P LpX2 q
    • wenn X “ X1 ¨ X2 :
      zerlege w “ w1 ¨ w2 und beweise w1 P LpX1 q und beweise w2 P LpX2 q.
    • wenn X “ X1˚ :
      wähle einen Exponenten k P N und beweise w P LpX1k q (nach vorigem Schema)

Beispiel: w “ abba, X “ pab˚ q˚ .
   w “ abb ¨ a “ ab2 ¨ ab0 P ab˚ ¨ ab˚ Ď pab˚ q2 Ď pab˚ q˚ .

Übungen zu Lexik (Testfragen)
   (ohne Wertung, zur Wiederholung und Unterhaltung)

    • was ist jeweils Eingabe und Ausgabe für: lexikalische Analyse, syntaktische Analy-
      se?

    • warum werden reguläre Ausdrücke zur Beschreibung von Tokenmengen verwendet?
      (was wäre die einfachste Alternative? für welche Tokentypen funktioniert diese?)

    • pΣ˚ , ¨, q ist Monoid, aber keine Gruppe

                                            12

• pPowpΣ˚ q, Y, ¨, . . . , . . . q ist Halbring (ergänzen Sie die neutralen Elemente)

   • In jedem Monoid: Damit ab`c “ ab ¨ ac immer gilt, muß man a0 wie definieren?

   • Suchen und diskutieren Sie Wadler’s law (of language design)“.
                               ”
     Am Entwurf welcher Programmiersprachen war der Autor beteiligt?

    Aufgaben zu regulären Ausdrücken: autotool. Das ist Wiederholung aus VL Theo-
retische Informatik—Automaten und Formale Sprachen. Fragen dazu notfalls im Opal-
Kurs/Forum.

Übungen zu Lexik (Hausaufgaben)

  1. Für jedes Monoid M “ pD, ¨, 1q definieren wir die Teilbarkeits-Relation u | w :“
     Dv : u ¨ v “ w
     Geben Sie Beispiele u | w,       pu | wq an in den Monoiden

        • pN, `, 0q
        • pZ, `, 0q
        • pN, ¨, 1q
        • pta, bu˚ , ¨, q
        • p2N , Y, Hq

     Zeigen Sie (nicht für ein spezielles Monoid, sondern allgemein): die Relation | ist
     reflexiv und transitiv.
     Ist sie antisymmetrisch? (Beweis oder Gegenbeispiel.)
     NB: Beziehung zur Softwaretechnik:

        • Monoid“ ist die Schnittstelle (API, abstrakter Datentyp),
          ”
        • pN, 0, `q ist eine Implementierung (konkreter Datentyp).
        • allgemein zeigen“ bedeutet: nur die in den Axiomen des ADT (API-Beschreibung)
          ”
          genannten Eigenschaften benutzen

  2. Zeichnen Sie jeweils das Hasse-Diagramm dieser Teilbarkeitsrelation

        • für pN, `, 0q, eingeschränkt auf t0, 1, . . . , 4u
        • für pN, ¨, 1q, eingeschränkt auf t0, 1, . . . , 10u

                                                13

• für p2tp,q,ru , Y, Hq
      • für pta, bu˚ , ¨, q auf ta, buď2

   Geben Sie eine Halbordnung auf t0, 1, 2u2 an, deren Hasse-Diagramm ein auf der
   Spitze stehendes Quadratnetz ist.
   Diese Halbordnung soll intensional angegeben werden (durch eine Formel), nicht
   extensional (durch Aufzählen aller Elemente).

3. Führen Sie vor (auf Rechner im Pool Z430, vorher von außen einloggen und probie-
   ren)
   Editieren, Kompilieren, Ausführen eines kurzen (maximal 3 Zeilen) Pascal-Programms
   Der Compiler fpc (https://www.freepascal.org/) ist installiert (/usr/local/waldmann
   (Zweck dieser Teilaufgabe ist nicht, daß Sie Pascal lernen, sondern der Benutzung
   von ssh, evtl. tmux, Kommandozeile (PATH), Text-Editor wiederholen)

   Zu regulären Ausdrücke für Tokenklassen in der Standard-Pascal-Definition http:
   //www.standardpascal.org/iso7185.html
   Welche Notation wird für unsere Operatoren ` und Stern benutzt? Was bedeuten
   die eckigen Klammern?
   In Ihrem Beispiel-Programm: erproben Sie mehrere (korrekte und fehlerhafte) Va-
   rianten für Gleitkomma-Literale. Vergleichen Sie Spezifikation (geben Sie den pas-
   senden Abschnitt der Sprachdefinition an) und Verhalten des Compilers.
   Dieser Compiler (fpc) ist in Pascal geschrieben. Was bedeutet das für: Installation
   des Compilers, Entwicklung des Compilers?

4. Führen Sie vor (wie und warum: siehe Bemerkungen vorige Aufgabe): Editieren,
   Kompilieren (javac), Ausführen (java) eines kurzen (maximal 3 Zeilen) Java-
   Programms.
   Suchen und buchmarken Sie die Java Language Specification (Primärquelle in der
   aktuellen Version) Beantworten Sie damit (und nicht mit Hausaufgabenwebseiten
   und anderen Sekundärquellen):
   gehören in Java

      • null
      • Namen für Elemente von Aufzählungstypen

                                             14

zum Tokentyp Literal, reserviertes Wort (Schlüsselwort), Bezeichner (oder evtl. an-
     deren)?
     Wo stehen die Token-Definitionen im javac-Compiler? https://hg.openjdk.
     java.net/jdk/jdk15/file/
     In Ihrem Beispiel-Programm: erproben Sie verschiedene Varianten von Ganzzahl-
     Literalen (siehe vorige Aufgabe)
  5. (erst in der darauffolgenden Woche) Gelten die Aussagen von Cox (2007) ( but it’s
                                                                             ”
     slow in. . .“) jetzt immer noch? Überprüfen Sie das praktisch.

Wort-Ersetzungs-Systeme
  Berechnungs-Modell (Markov-Algorithmen)
   • Zustand (Speicherinhalt): Zeichenfolge (Wort)
   • Schritt: Ersetzung eines Teilwortes
   Syntax: Programm ist Regelmenge R Ď Σ˚ ˆ Σ˚
   Semantik: die 1-Schritt-Ableitungsrelation ÑR
   u ÑR v ðñ Dx, z P Σ˚ , pl, rq P R : u “ x ¨ l ¨ z ^ x ¨ r ¨ z “ v.
   Beispiele:
   • Bubble-Sort: tba Ñ ab, ca Ñ ac, cb Ñ bcu
   • Potenzieren: ab Ñ bba (Details: Übung)
   • gibt es unendlich lange Ableitungen für: R1 “ t1000 Ñ 0001110u, R2 “ taabb Ñ
     bbbaaau?

Grammatiken
  Grammatik G besteht aus:                       Grammatik
                                                   { terminale
       • Terminal-Alphabet Σ                            = mkSet "abc"
                                                   , variablen
         (üblich: Kleinbuchst., Ziffern)
                                                        = mkSet "SA"
       • Variablen-Alphabet V                      , start = ’S’
         (üblich: Großbuchstaben)                 , regeln = mkSet
                                                        [ ("S", "abc")
       • Startsymbol S P V                              , ("ab", "aabbA")
       • Regelmenge                                     , ("Ab", "bA")
         (Wort-Ersetzungs-System)                       , ("Ac", "cc")
                                                        ]
         R Ď pΣ Y V q˚ ˆ pΣ Y V q˚                 }

                                            15

von G erzeugte Sprache: LpGq “ tw | S Ñ˚R w ^ w P Σ˚ u.

Formale Sprachen: Chomsky-Hierarchie

    • (Typ 0) aufzählbare Sprachen (beliebige Grammatiken, Turingmaschinen)
    • (Typ 1) kontextsensitive Sprachen (monotone Grammatiken, linear beschränkte Au-
      tomaten)
    • (Typ 2) kontextfreie Sprachen (kontextfreie Grammatiken, Kellerautomaten)
    • (Typ 3) reguläre Sprachen (rechtslineare Grammatiken, reguläre Ausdrücke, endli-
      che Automaten)

    Tokenklassen sind meist reguläre Sprachen.
    Syntax von Programmiersprachen meist kontextfrei.
    Zusatzbedingungen (Bsp: Benutzung von Bezeichnern nur nach Deklaration) meist
Teil der statischen Semantik

Typ-3-Grammatiken
   (“ rechtslineare Grammatiken)
   jede Regel hat die Form
    • Variable Ñ Terminal Variable
    • Variable Ñ Terminal
    • Variable Ñ 
   (vgl. lineares Gleichungssystem)
   Beispiele
    • G1 “ pta, bu, tS, T u, S, tS Ñ , S Ñ aT, T Ñ bSuq
    • G2 “ pta, bu, tS, T u, S, tS Ñ , S Ñ aS, S Ñ bT, T Ñ aT, T Ñ bSuq

Sätze über reguläre Sprachen
    Für jede Sprache L sind die folgenden Aussagen äquivalent:
    • es gibt einen regulären Ausdruck X mit L “ LpXq,

    • es gibt eine Typ-3-Grammatik G mit L “ LpGq,

    • es gibt einen endlichen Automaten A mit L “ LpAq.

                                           16

Beweispläne:
   • Grammatik Ø Automat (Variable “ Zustand)
   • Ausdruck Ñ Automat (Teilbaum “ Zustand)
   • Automat Ñ Ausdruck (dynamische Programmierung)
      LA pp, q, rq “ alle Pfade von p nach r über Zustände ď q.

Kontextfreie Sprachen
  Def (Wdhlg): G ist kontextfrei (Typ-2), falls @pl, rq P RpGq : l P V 1
  geeignet zur Beschreibung von Sprachen mit hierarchischer Struktur.
Anweisung -> Bezeichner = Ausdruck
    | if Ausdruck then Anweisung else Anweisung
Ausdruck -> Bezeichner | Literal
    | Ausdruck Operator Ausdruck
   Bsp: korrekt geklammerte Ausdrücke: G “ pta, bu, tSu, S, tS Ñ aSbS, S Ñ uq.
   Bsp: Palindrome: G “ pta, bu, tSu, S, tS Ñ aSa, S Ñ bSb, S Ñ q.
   Bsp: alle Wörter w über Σ “ ta, bu mit |w|a “ |w|b

Klammer-Sprachen

   Abstraktion von vollständig geklammerten Ausdrücke mit zweistelligen Operatoren

   (4*(5+6)-(7+8)) ñ (()()) ñ aababb

   Höhendifferenz: h : ta, bu˚ Ñ Z : w ÞÑ |w|a ´ |w|b

   Präfix-Relation: u ď w : ðñ Dv : u ¨ v “ w

   Dyck-Sprache: D “ tw | hpwq “ 0 ^ @u ď w : hpuq ě 0u

   CF-Grammatik: G “ pta, bu, tSu, S, tS Ñ , S Ñ aSbSuq

   Satz: LpGq “ D. Beweis (Plan):

   LpGq Ď D Induktion über Länge der Ableitung

   D Ď LpGq Induktion über Wortlänge

                                            17

(erweiterte) Backus-Naur-Form
   • Noam Chomsky: Struktur natürlicher Sprachen (1956)
   • John Backus, Peter Naur: Definition der Syntax von Algol (1958)
   Backus-Naur-Form (BNF) « kontextfreie Grammatik
 ->  = 
 ->   | 
   Erweiterte BNF
   • Wiederholungen (Stern, Plus) ˆ+
   • Auslassungen
     if  then  [ else  ]
kann in BNF übersetzt werden

Ableitungsbäume für CF-Sprachen
     Def: ein geordneter Baum T mit Markierung m : T Ñ ΣYtuYV ist Ableitungsbaum
für eine CF-Grammatik G, wenn:
   • für jeden inneren Knoten k von T gilt mpkq P V
   • für jedes Blatt b von T gilt mpbq P Σ Y tu
   • für die Wurzel w von T gilt mpwq “ SpGq (Startsymbol)
   • für jeden inneren Knoten k von T mit Kindern k1 , k2 , . . . , kn gilt pmpkq, mpk1 qmpk2 q . . . mpkn qq P
     RpGq (d. h. jedes mpki q P V Y Σ)
   • für jeden inneren Knoten k von T mit einzigem Kind k1 “  gilt pmpkq, q P RpGq.

Ableitungsbäume (II)
   • Def: der Rand eines geordneten, markierten Baumes pT, mq ist die Folge aller Blatt-
     Markierungen (von links nach rechts).
   • Beachte: die Blatt-Markierungen sind P tu Y Σ, d. h. Terminalwörter der Länge 0
     oder 1.
   • Für Blätter: randpbq “ mpbq,
   • für innere Knoten: randpkq “ randpk1 q randpk2 q . . . randpkn q
   • Satz: w P LpGq ðñ existiert Ableitungsbaum pT, mq für G mit randpT, mq “ w.

                                              18

Eindeutigkeit

    • Def: G heißt eindeutig : @w P LpGq D genau ein Ableitungsbaum pT, mq für G mit
      randpT, mq “ w.
      Bsp: pta, bu, tSu, S, tS Ñ aSb|SS|uq ist mehrdeutig.
      (beachte: mehrere Ableitungen S Ñ˚R w sind erlaubt
      und wg. Kontextfreiheit auch gar nicht zu vermeiden.)
    • Die naheliegende Grammatik für arith. Ausdr.

      expr -> number | expr + expr | expr * expr

      ist mehrdeutig (aus zwei Gründen!) — Auswege:

         – Transformation zu eindeutiger Grammatik (benutzt zusätzliche Variablen)
         – Operator-Assoziativitäten und -Präzedenzen

Assoziativität

    • (Wdhlg.) Definition: Operation ist assoziativ

    • für nicht assoziativen Operator d muß man festlegen, was x d y d z bedeuten soll:
                                          ?           ?
                          p3 ` 2q ` 4 “ 3 ` 2 ` 4 “ 3 ` p2 ` 4q
                                          ?           ?
                          p3 ´ 2q ´ 4 “ 3 ´ 2 ´ 4 “ 3 ´ p2 ´ 4q
                                      ?               ?
                         p3 ˚ ˚2q ˚ ˚4 “ 3 ˚ ˚2 ˚ ˚4 “ 3 ˚ ˚p2 ˚ ˚4q

    • . . . und dann die Grammatik entsprechend einrichten
      (d.h., eine äquivalente eindeutige Grammatik konstruieren, deren Ableitungsbäume
      die gewünschte Struktur haben)

Assoziativität (II)

    • X1 - X2 + X3 auffassen als (X1 - X2) + X3

    • Grammatik-Regeln

                                              19

Ausdruck -> Zahl | Ausdruck + Ausdruck
                      | Ausdruck - Ausdruck

   • ersetzen durch

     Ausdruck -> Summe
     Summe    -> Summand | Summe + Summand
                         | Summe - Summand
     Summand -> Zahl

Präzedenzen
   • Beispiel
                                         ?           ?
                             p3 ` 2q ˚ 4 “ 3 ` 2 ˚ 4 “ 3 ` p2 ˚ 4q

   • Grammatik-Regel

     summand -> zahl

   • erweitern zu

     summand -> zahl | produkt
     produkt -> ...

     (Assoziativität beachten)

Zusammenfassung Operator/Grammatik
   Ziele:
   • Klammern einsparen
   • trotzdem eindeutig bestimmter Syntaxbaum
Festlegung:
   • Assoziativität: bei Kombination eines Operators mit sich
   • Präzedenz: bei Kombination verschiedener Operatoren
Realisierung in CFG:
   • Links/Rechts-Assoziativität ñ Links/Rechts-Rekursion
   • verschiedene Präzedenzen ñ verschiedene Variablen

                                             20

Hausaufgaben (Rewriting, Typ-0-Grammatiken)

   • Für das R “ tab Ñ baau über Σ “ ta, bu:
     was ist die R-Normalform von

        – a3 b, allgemein ak b,
        – ab3 , allgemein abk ,

     formulieren Sie die allgemeinen Aussagen exakt, überprüfen Sie für k “ 3, bewei-
     sen Sie durch vollständige Induktion.

Hausaufgaben (CF-Grammatiken)

  1. zur Geschichte:

        • Definitionen von CFG und Ableitungsbaum in Noam Chomsky: Three Mo-
          dels for the Description of Language, 1956 https://chomsky.info/
          articles/. Wie heißt CFG dort?
        • vergleichen Sie die Syntax-Definitionen von Fortran (John Backus 1956) und
          Algol (Peter Naur 1960),
          Quellen siehe http://web.eah-jena.de/˜kleine/history/

  2. für die offizielle Java-Grammatik (nach JLS in aktueller Version)

        • es werden tatsächlich zwei Grammatiken benutzt (lexikalische, syntaktische),
          zeigen Sie deren Zusammenwirken an einem einfachen Beispiel (eine Ablei-
          tung, bei der in jeder Grammatik nur wenige Regeln benutzt werden)
        • bestimmen Sie den Ableitungsbaum (bzgl. der syntaktischen Grammatik) für
          das übliche hello world-Programm,
        • Beispiele in jshell vorführen. Wie lautet die Grammatik für die dort erlaub-
          ten Eingaben? Falls es sie gibt - sonst eine andere primäre Dokumentations
          dafür.

  3. bzgl. der eindeutigen Grammatik für arithmetische Ausdrücke, die in der VL (Skript)
     entwickelt wurde:

        • Ableitungsbaum für 1*2-3*4

                                           21

• Grammatik erweitern für geklammerte Ausdrücke,
            Eindeutigkeit begründen,
            Ableitungsbaum für 1*(2-3)*4 angeben
          • welche Variable der offiziellen Java-Grammatik erzeugt arithemetische Aus-
            drücke? Ableitungsbaum für 1*(2-3)*4 von dieser Variablen aus angeben.

    4. (autotool) diese oder ähnliche Aufgaben:

          • CF-Grammatik für tw | w P ta, bu˚ , |w|a “ |w|b u
          • CF-Grammatik für tw | w P ta, bu˚ , 2 ¨ |w|a “ |w|b u
          • jeweils auch als eindeutige CFG

3     Semantik von Programmiersprachen
Statische und dynamische Semantik
   Semantik “ Bedeutung

    • statisch (kann zur Übersetzungszeit geprüft werden)
       Beispiele (in C, Java, . . . )

          – Typ-Korrektheit von Ausdrücken,
          – Bedeutung (Bindung) von Bezeichnern

    • dynamisch (beschreibt Ausführung des Programms)
       operational, axiomatisch, denotational

Hilfsmittel: Attributgrammatiken

Bsp statische/dynamische Semantik
   Benutzung eines undeklarierten Namens:
    • Java: verhindert durch statische Semantik-Prüfung (Programm wird nicht übersetzt,
      nicht ausgeführt)

       { System.out.print("foo"); System.out.printl(x);}
       | Error:
       | cannot find symbol
       |    symbol:   variable x

                                             22

• ECMA-Script (Javascript): dynamische Semantik ist Exception wird ausgelöst“
                                                        ”
      (Programm wird ausgeführt)

      > {console.log("foo"); console.log(x);}
      foo
      Thrown:
      ReferenceError: x is not defined

Attributgrammatiken (I)

    • Attribut: Annotation an Knoten des Syntaxbaums.
      A : Knotenmenge Ñ Attributwerte          (Bsp: Z)
    • Attributgrammatik besteht aus:

           – kontextfreier Grammatik G (Bsp: tS Ñ e | mSSu)
           – für jeden Knotentyp (Terminal ` Regel)
             eine Menge (Relation) von erlaubten Attribut-Tupeln pApX0 q, ApX1 q, . . . , ApXn qq
             für Knoten X0 mit Kindern rX1 , . . . , Xn s

             S Ñ mSS , ApX0 q ` ApX3 q “ ApX2 q; S Ñ e, ApX0 q “ ApX1 q; Terminale:
             Apeq “ 1, Apmq “ 0

Attributgrammatiken (II)
   ein Ableitungsbaum mit Annotationen ist korrekt bezüglich einer Attributgrammatik,
wenn

    • er zur zugrundeliegenden CF-Grammatik paßt

    • in jedem Knoten das Attribut-Tupel (von Knoten und Kindern) zur erlaubten Tupel-
      menge gehört

   Plan:

    • Baum beschreibt Syntax, Attribute beschreiben Semantik

    Ursprung: Donald Knuth: Semantics of Context-Free Languages, (Math. Systems Theo-
ry 2, 1968)
    technische Schwierigkeit: Attributwerte effizient bestimmen. (beachte: (zirkuläre) Abhängig-
keiten)

                                              23

Donald E. Knuth

   • The Art Of Computer Programming (1968, . . . )
     (Band 3: Sortieren und Suchen)
   • TEX, Metafont, Literate Programming (1983, . . . )
     (Leslie Lamport: LATEX)
   • Attribut-Grammatiken (1968)
   • Anwendung der Landau-Notation (Opf q, Analysis) und Erweiterung (Ω, Θ) für asym-
     ptotische Komplexität
   • ...

   https://www-cs-faculty.stanford.edu/˜uno/

Arten von Attributen

   • synthetisiert:
     hängt nur von Attributwerten in Kindknoten ab
     Bsp: Typ von Ausdrücken, Wert von Ausdrücken
   • ererbt (inherited)
     hängt nur von Attributwerten in Elternknoten und (linken) Geschwisterknoten ab
     Bsp: deklarierte Typen für Namen

   Wenn Abhängigkeiten bekannt sind, kann man Attributwerte durch Werkzeuge bestim-
men lassen.
   (Bransen et al.: Linearly Ordered Attribute Grammar Scheduling . . . , TACAS 2015
https://doi.org/10.1007/978-3-662-46681-0_24 )

Attributgrammatiken–Beispiele

   • Auswertung arithmetischer Ausdrücke (dynamisch)

   • Bestimmung des abstrakten Syntaxbaumes

   • Typprüfung (statisch)

   • Kompilation (für Kellermaschine) (statisch)

                                          24

Konkrete und abstrakte Syntax

    • konkreter Syntaxbaum “ der Ableitungsbaum

    • abstrakter Syntaxbaum “ wesentliche Teile des konkreten Baumes

unwesentlich sind z. B. die Knoten, die zu Hilfsvariablen der Grammatik gehören.
   abstrakter Syntaxbaum kann als synthetisiertes Attribut konstruiert werden.

E -> E + P         ;    E.abs = new Plus(E.abs, P.abs)
E -> P             ;    E.abs = P.abs

Regeln zur Typprüfung
   . . . bei geschachtelten Funktionsaufrufen

    • Funktion f hat Typ A Ñ B

    • Ausdruck X hat Typ A

    • dann hat Ausdruck f pXq den Typ B

   Beispiel

class C {
  static class A {} static class B {}
  static B f (A y) { .. }
  static A g (B x) { .. }
  ..
  .. C.g (C.f (new C.A())) .. }

Bsp. Operationale Semantik: Keller

    • Kellerspeicher

         – Zustand ist Zahlenfolge s P Z˚ , Empty “ rs
         – Operationen:
              * Pushpxq, Semantik: rs1 , . . . , sn s Ñ rx, s1 , . . . , sn s
              * y :“ Poppq, Semantik: ry, s1 , . . . , sn s Ñ rs1 , . . . , sn s

                                                 25

• Realisierung zweistelliger Verknüpfungen: Argumente vom Keller holen, Resultat
     auf Keller schreiben, z.B.
     Plus ” ta :“ Poppq; b :“ Poppq; Pushpa ` bqu

   • benutzt in Prog.-Spr. Forth (1970), PostScript (1982),
     JVM (Java Virtual Machine, 1994), Bsp: 6.5 iadd

Kompilation für Kellermaschine

   • Spezifikation:

        – Eingabe: Java-Ausdruck A, Bsp. 3 ˚ x ` 1
        – Ausgabe: JVM-Programm P , Bsp:
          push 3; push x; imul; push 1; iadd;
                                 P
        – Zusammenhang: rs ´Ñ rWertpAqs
                                         P
        – dann gilt auch @k P Z˚ : k ´Ñ prWertpAqs ˝ kq

   • Realisierung (Kompilation):

        – Code für Konstante/Variable c : push c;
        – Code für Ausdruck x ˝ y: code(x); code(y); o;

     der so erzeugte Code ist synthetisiertes Attribut

   • JVM-Programm (Bytecode) ansehen mit javap -c,

Attributgrammatiken mit SableCC

   • SableCC: https://sablecc.org/
     SableCC is a parser generator for building compilers, interpreters . . . , strictly-typed
     abstract syntax trees and tree walkers

   • Syntax einer Regel

     linke-seite { -> attribut-typ }
        = { zweig-name } rechte-seite { ->                         attribut-wert }

                                             26

• Quelltexte: git clone https://gitlab.imn.htwk-leipzig.de/waldmann/pps-ws1
     Benutzung: cd pps-ws15/rechner ; make ; make test ; make clean
     (dafür muß sablecc gefunden werden, siehe http://www.imn.htwk-leipzig.
     de/˜waldmann/etc/pool/)

   • Struktur:

        – rechner.grammar enthält Attributgrammatik, diese beschreibt die Kon-
          struktion des abstrakten Syntaxbaumes (AST) aus dem Ableitungsbaum (kon-
          kreten Syntaxbaum)
        – Eval.java enthält Besucherobjekt, dieses beschreibt die Attributierung der
          AST-Knoten durch Zahlen
        – Hauptprogramm in Interpreter.java
        – bauen, testen, aufräumen: siehe Makefile
        – generierte Dateien in rechner/*

   Bemerkungen (häufige/nicht offensichtliche Fehlerquellen)

   • Redefinition of ... : nicht so: foo -> bar ; foo -> baz; sondern
     so: foo -> {eins} bar | {zwei} baz;
     Regeln mit gleicher linker Seite zusammenfassen,
     die rechten Seiten durch Label ({eins},{zwei}) unterscheiden

   • ... conflict ... :
     die Grammatik ist nicht eindeutig (genauer: wird von Sablecc nicht als eindeutig
     erkannt)

    Kommentar: in Java fehlen: algebraische Datentypen, Pattern Matching, Funktionen
höherer Ordnung. Deswegen muß SableCC das simulieren — das sieht nicht schön aus.
Die richtige“ Lösung sehen Sie später im Compilerbau.
    ”
    Abstrakter Syntaxbaum, Interpreter: http://www.imn.htwk-leipzig.de/˜waldmann/
edu/ws11/cb/folien/main/node12.html, Kombinator-Parser: http://www.
imn.htwk-leipzig.de/˜waldmann/edu/ws11/cb/folien/main/node70.
html

                                          27

Hausaufgaben
  1. die angegebene Sablecc-Grammatik ergänzen: Multiplikation, Subtraktion, Klam-
     mern
  2. javap -c vorführen für Übersetzung von arithmetischen Ausdrücken (keine Pro-
     grammablaufsteuerung)
     Ausgabe vergleichen mit dem Verfahren aus VL
     welchen Maschinencode erzeugt der JIT-Compiler der JVM daraus? (https://
     wiki.openjdk.java.net/display/HotSpot/PrintAssembly , ist/wird
     im Pool installiert)
  3. ggf. Effizienz der Impl. reg. Ausdr. (alte Aufgabe)

Dynamische Semantik
   • operational:
     beschreibt Wirkung einzelner Anweisungen durch Änderung des Speicherbelegung
   • denotational:
     ordnet jedem (Teil-)Programm einen Wert zu, Bsp: eine Funktion (höherer Ord-
     nung).
     Beweis von Programmeigenschaften durch Term-Umformungen
   • axiomatisch (Bsp: Hoare-Kalkül):
     enthält Schlußregeln, um Aussagen über Programme zu beweisen

Operationale Semantik: Sprünge
   • Maschinenmodell:
     Variable PC (program counter) enthält Adresse des nächsten auszuführenden Be-
     fehls
   • Semantik von Gotopzq ist: PC :“ z
     Semantik der Nicht-Sprungbefehle: . . . , PC :“ PC ` 1
   • andere Varianten der Programmablaufsteuerung können in Goto-Programme über-
     setzt werden
     Bsp: Schleife while (B) A ñ if (B) ...
     das findet bei Kompilation von Java nach JVM statt

                                           28

Denotationale Semantik
   Beispiele: Semantik von . . . ist . . .

    • (nebenwirkungsfreies) Unterprogramm ñ Funktion von Argument nach Resultat
    • Anweisung ñ Funktion von Speicherbelegung nach Speicherbelegung

    Vorteile denotationaler Semantik:

    • Bedeutung eines Programmes “ mathematisches Objekt
    • durch Term beschreiben, durch äquivalente Umformungen verarbeiten (equational
      reasoning)

Vorteil deklarativer Programierung: Programmiersprache ist Beschreibungssprache (ist
Mathematik)

Beispiele Denotationale Semantik

    • jeder arithmetische Ausdruck (aus Konstanten und Operatoren)
      beschreibt eine Zahl
    • jeder aussagenlogische Ausdruck (aus Variablen und Operatoren)
      beschreibt eine Funktion (von Variablenbelegung nach Wahrheitswert)
    • jeder reguläre Ausdruck
      beschreibt eine formale Sprache
    • jedes rekursive definierte Unterprogramm
      beschreibt eine partielle Funktion

Beispiel: Denotationale Sem. von Unterprogr.

    • Unterprogramme definiert durch Gleichungssysteme.
      Sind diese immer lösbar? (eindeutig?)

    • Diese f , t sind tatsächlich einfach darstellbar:

      f (x) = if x > 52
        then x - 11 else f (f (x + 12))

                                              29

t (x, y, z) = if x           = 5} while (true) ; {x == 42}

                                           30

Eiffel
    Bertrand Meyer, http://www.eiffel.com/

class Stack [G]     feature
    count : INTEGER
    item : G is require not empty do ... end
    empty : BOOLEAN is do .. end
    full : BOOLEAN is do .. end
    put (x: G) is
       require not full do ...
       ensure not empty
              item = x
              count = old count + 1

Beispiel sinngemäß aus: B. Meyer: Object Oriented Software Construction, Prentice Hall
1997

Hoare-Kalkül: Überblick
   zu jedem Knotentyp in abstrakten Syntaxbäumen von strukturierten imperativen Pro-
grammen ein Axiom-Schema

   • elementare Anweisung:
        – Zuweisung { N[x/E] } x := E { N }
   • zusammengesetzte Anweisungen:
        – wenn { V } C { Z } und               { Z } D { N }
          dann { V } C; D { N }
        – wenn { V und     B } C { N }
          und { V und not B } D { N }
          dann { V } if (B) then C else D { N }
        – wenn     { I and B } A { I },
          dann     { I } while (B) do A { I and not B }

Anwendung des Zuweisungs-Axioms

   • Axiom (-Schema): { N[x/E] } x := E { N }

                                          31

• dabei bedeutet N rx{Es:
     der Ausdruck N , wobei jedes Vorkommen des Namens x durch den Ausdruck E
     ersetzt wird
     Bsp: py ě 7qry{x ` 3s “ px ` 3 ě 7q “ px ě 4q
   • Bsp: Anwendung { ... } y := x+3 { y >= 7 }
   • Übung: welche Vorbedingung ergibt sich für
     a := a + b; b := a - b ; a := a - b;
     und Nachbedingung a “ X ^ b “ Y ?
     Dabei auch Axiom für Nacheinanderausführung benutzen

Hoare-Kalkül: Ergänzung
   • logische Umformungen (Programm A bleibt erhalten)
        – Verschärfen einer Vorbedingung (von V zu V 1 )
        – Abschwächen einer Nachbedingung (von N zu N 1 )
     wenn { V } A { N } und V’ => V und N => N’
     dann { V’ } A { N’ }
   • Anwendung: beweise {x < 4} x := 5-x { x > 2 }
        – Zuweisungs-Axiom ergibt {5-x>2} x:=5-x {x>2}
        – äquivalent umgeformt zu {x2}
        – dann o.g. Axiom anwenden mit V=(x 9 }
     if (x > y) then a := x - 2 else a := y + 2
     { a > 7 }

                                          32

Axiom für Verzweigung (Rechnung)
   • wir müssen {x>9 und x>y} a:=x-2 {a>7}
     und {x>9 und x7} zeigen,
     um das Axiom-Schema anwenden zu können

   • Zuweisungs-Axiom ergibt {x-2>7} a:=x-2 {a>7}
     äquivalent umgeformt {x>9} a:=x-2 {a>7}
     Axiom-Schema zum Verschärfen der Vorbedingung (V 1 “ px ą 9q ^ px ą yq, V “ px ą
     9q) ergibt erstes Teilziel

   • Zuweisungs-Axiom ergibt {y+2>7} a:=y+2 {a>7}
     äquivalent umgeformt {y>5} a:=y+2 {a>7}
     Axiom-Schema zu Verschärfen der Vorbedingung ist anwendbar für V 1 “ px ą 9 ^ x ď
     yq, V “ py ą 5q wegen V 1 ñ V , ergibt zweites Teilziel

Anwendung des Axioms für Schleifen

   • wenn    { I and B } A { I },
     dann    { I } while (B) do A { I and not B }

   • Eingabe int p, q;   // p = P und q = Q
     int c = 0;
     // inv: p * q + c = P * Q
     while (q > 0) {
        ??? := ???; q := q - 1;
     }
     // c = P * Q

   • Invariante muß: 1. vor der Schleife gelten, 2. im S.-Körper invariant bleiben, 3. nach
     der Schleife nützlich sein

   • erst Spezifikation (hier: Invariante), dann Imple- mentierung. (sonst: cart before the
     horse, EWD 1305)

Aufgaben axiomatische Semantik

  1. zur Folie Zuweisungs-Axiom“:
              ”
     bestimmen Sie die Vorbedingung zu a := a + b; ..., aus den Axiomen für
     Zuweisung und Nacheinanderausführung.

                                            33

2. Ergänzen Sie das Programm, so daß die Spezifikation (das Potenzieren) erfüllt wird.

     Eingabe: natürliche Zahlen a, b;
     // a = A und b = B
     int p := 1; int c := ???;
     // Invariante: cˆb * p = AˆB
     while (b /= 0) {
         if (b ist ungerade)
           then (c,p) := ...
           else (c,p) := ...
         // Z
         b := abrunden (b/2);
     }
     Ausgabe: p; // p = AˆB

        • Initialisieren Sie c so, daß die Invariante gilt.
        • Wieso folgt aus der Invariante bei Verlassen der Schleife die Korrektheit der
          Ausgabe?
        • Bestimmen Sie eine geeignete Aussage Z als Vorbedingung der nachfolgenden
          Anweisung bezüglich der Invariante.
        • Bestimmen Sie daraus die Lücken (...)

Literatur/Kommentar zu Verifikation

   • Einführung Hoare-Kalkül: Kap. 2.11 in Gumm/Sommer: Informatik, Oldenbourg
     2013 (online über HTWK-Bibl.).

   • Dort allerdings fällt das Programm (Schleife) vom Himmel und der Beweis (Invari-
     ante) wird nachträglich geraten.

   • Vergleiche dazu E. W. Dijkstra: putting the cart (das Programmieren) before the hor-
     se (das Beweisen). https://www.cs.utexas.edu/users/EWD/transcriptions/
     EWD13xx/EWD1305.html.

   • In welchen Semestern finden Sie die VL zum Program mieren, die VL zur Pro-
     grammverifikation? Autsch.
     Vergleichen Sie mit Studiengang Bauingenieurwesen, VL Baumechanik/VL Bau-
     wirtschaft (und ähnliche)

                                            34

4    Mehr zu Korrektheit und Termination
Erweiterter Euklidische Algorithmus (Spezif.)

    • Spezifikation:       (Beispiel: x “ 60, y “ 35, . . . )

          – Eingabe: x, y P N
          – Ausgabe: a, b P Z mit g “ a ¨ x ` b ¨ y ^ g|x ^ g|y

    • Satz: g “ gcdpx, yq.

    • Def: gcdpx, yq ist das Infimum (größte untere Schranke) von x und y in der Teilbarkeits-
      Halbordnung, d.h.,
      gcdpx, yq|x ^ gcdpx, yq|y ^ @h : . . .

    • Beweis des Satzes:
      1. g|x ^ g|y nach Spezifikation,
      2. . . .

Erweiterter Euklid — funktional (Aufgabe)

    • Ausgabe: a, b P Z mit gcdpx, yq “ a ¨ x ` b ¨ y

    • ee :: Int -> Int -> (Int, Int)
      ee x y =
        if y == 0 then ( ... , ... )
        else let (d,m) = divMod x y
                 (p,q) = ee y m
             in ( ... ,      ... )

    • Beweis: Induktion nach y

    • benutzt Eigenschaften des gcd:
      gcdpx, 0q “ . . . , gcdpd ¨ y ` m, yq “ gcdpm, yq.

Erweiterter Euklid — funktional (Lösung)

    • Ausgabe: a, b P Z mit gcdpx, yq “ a ¨ x ` b ¨ y

                                               35

• ee :: Int -> Int -> (Int, Int)
     ee x y =
       if y == 0 then (1 , 0)
       else let (d , m) = divMod x y
                (p , q) = ee y m
            in (q, p - d * q)

Simultan-Zuweisung

   • Anweisung pv1 , v2 q :“ pe1 , e2 q für v1 ‰ v2

   • axiomatische Semantik:
     tN rv1 {e1 , v2 {e2 su pv1 , v2 q :“ pe1 , e2 q tN u
     verwendet links simultane Ersetzung

   • Bsp: t. . . u pa, bq :“ pb, aq ta “ 2 ^ b “ 5u
     Bsp: t. . . u px, yq :“ px ` y, x ´ yq tx “ 7 ^ y ě 3u

   • realisiert in der Sprache CPL 1963

   • in JS als destructuring assignment, ECMA 262: 12.15.5
     [a,b]=[8,9]; [a,b]=[b,a]

Erweiterter Euklid — imperative Impl.

   • Ansatz: verwende x, y, a, b, p, q ě 0 mit Invariante
     gcdpx, yq “ gcdpxin , yin q ^ x “ a ¨ xin ` b ¨ yin , y “ p ¨ xin ` q ¨ yin

   • // X = x, Y = y, x >= 0,                      y >= 0
     (a,b,p,q) := ...
     // Inv: gcd (x,y) = gcd                       (X,Y) ,
     //       x = a X + b Y ,                      y = p X + q Y
     while ( y > 0 ) {
       (x,y,a,b,p,q) := (y, x                      mod y, ... )
     }
     // gcd(X,Y) = a X + b Y

                                                   36

Aufgabe zum erweiterten Eukl. Alg.

  1. Für das Programm

     Eingabe: positive natürliche Zahlen A, B;
     (a,b,c,d) := (A,B,B,A)
     while (a /= b) {
       if (a > b) then (a,d) := (a-b,c+d)
                  else (b,c) := (b-a,d+c)
     }
     Ausgabe: (a+b)/2 , (c+d)/2

        • zeigen Sie, daß die erste Ausgabe gleich gcd(A,B) ist.
          Beweisen Sie dazu die Invarianz von gcd(a,b) = gcd(A,B).
          Welche Eigenschaften des gcd werden benötigt?
        • was ist die zweite Ausgabe?
          Geben Sie eine Vermutung an und beweisen Sie mit einer geeigneten Invarian-
          te.
        • wozu ist die Bedingung positiv“ notwendig?
                                ”

Partielle und totale Korrektheit

   • Hoare-Tripel {V} A {N} beschreibt partielle Korrektheit:
     wenn vorher V gilt und A hält, dann gilt danach N
     Bsp: {true} while (true); {x=42} ist wahr
   • stärker (und nützlicher) ist totale Korrektheit:
     partielle Korrektheit und A hält tatsächlich (Termination)
   • Beweis-Verfahren (für Schleifen while (B) do A)
        – partielle Korrektheit: Invariante
        – Termination: Maßfunktion (Schrittfunktion)
          m: Speicherbelegung Ñ N mit {m = M} A { m < M}
     Bsp: eine Maßf. für while(x>0){ ...; x=x/2;} ist x
   • es gilt: mpaktueller Zustandq ě verbleibende Anzahl der Schleifendurchläufe (Schrit-
     te)

                                              37

Wie findet man die Maßfunktion?

   • die richtige Antwort ist (wie für die Invariante):
     das ist die falsche Frage.
   • das softwaretechnisch richtige Vorgehen ist:

       1. (Entwurf) Invariante und Maßfunktion hinschreiben,
       2. (Implementierung) Schleife so ausprogrammieren, daß diese Behauptungen
          stimmen.

   • in der Praxis wünscht man eine Teil-Automatisierung:
     maschinelles Finden von einfachen ( offensichtlichen“) Maßfunktionen und Bewei-
                                        ”
     sen dafür
   • vgl. Typisierung von Namen:

        – Deklaration (durch Programmierer),
        – Inferenz (durch Compiler) (z.B. var in C#, auto in C++)

Maßfunktionen für funktionale Programme

   • (VAR x y) (RULES g(Z,y) -> Z  g(x,Z) -> Z
      g (S(x),S(y)) -> S (g(g(x,S(y)), g(S(x),y))) )
      Speicherbelegung“ ist jetzt Term-Baum
     ”
   • automatische Terminations-Analyse mit TTT2 http://colo6-c703.uibk.ac.
     at/ttt2/ (U. Innsbruck)

     $ ttt2 min.trs # YES Proof: DP Processor: ...
      Matrix Interpretation Processor: ...
       g#(S(x),S(y)) = 2y+2 >= 2y = g#(g(x,S(y)),g(S(x),y))

   • genau das ist mein Forschungsgebiet https://dblp.uni-trier.de/pers/hd/
     w/Waldmann:Johannes,

   • Teil der VL Symbolisches Rechnen (im SS 21) https://informatik.htwk-leipzig.
     de/waldmann/lehre.html

                                             38

Totale Programmiersprachen

   • eine Sprache P heißt total, wenn jedes (statisch korrekte) P -(Unter)Programm f für
     alle Argumente terminiert
     (denotationale Semantik von f ist eine totale Funktion)

   • nicht total: beliebige Sprünge, beliebige (bedingungsgesteuerte) Schleifen, beliebige
     Rekusion

   • total: Sprünge nur nach vorn, nur Zählschleifen (bei denen Zähler im Schleifenkörper
     nicht geändert wird), Rekursion nur durch Schema (fold, primitive Rekursion)

   • Beispiel: Agda (Ulf Norell 2007, Andreas Abel, et al.) https://wiki.portal.
     chalmers.se/agda/agda.php?n=ReferenceManual.Totality

Ressourcenverbrauch von Programmen

   • für totale Programme: Schranken f. Ressourcenverbrauch
     (max. Anzahl Rechenschritte als Fkt. der Eingabegröße)
     z.B. polynomiell, quadratisch, linear
     deklarieren (manuell) und inferieren (automatisch)

   • Martin Hofman, Jan Hoffman, et al.: Resource Aware ML, https://www.raml.
     co/publications/

   • https://accidentallyquadratic.tumblr.com/
     Bsp: einfach verkettete Listen: xs ++ ys ist linear in xs

        – (..(xs1 ++ xs2) ++ .. ) ++ xsN, d.h., foldl
        – xs1 ++ (xs2 ++ (.. ++ xsN)..), d.h., foldr

Aufgaben und Literatur zu Termination

   • (für das Wahlfach Symbolisches Rechnen einschreiben!)
   • Nachum Dershowitz: 33 Examples of Termination, 1993. http://www.math.
     tau.ac.il/˜nachumd/papers/printemp-print.pdf
     Geben Sie möglichst lange Ableitungen (von kleinem Startterm) für das Term-Ersetzungs-
     System 12 (disjunktive Normalform) an. Überprüfen Sie für einen Schritt t1 ÑR t2
     aus einer solchen Ableitung die Eigenschaft t1 ą t2 der angegebenen Maßfunktion.

                                             39

• Alan Turing (1950): Checking a Large Routine http://www.turingarchive.
 org/browse.php/B/8
 Wo wird Termination behandelt? Wie? — Das ist der älteste bekannte Terminations-
 beweis eines Programms!

                                     40