meta–synthese - Institut für Informatik

META–SYNTHESE
Synthese von Programmen, die Programme generieren
Christoph Kreitz
Fachgebiet Intellektik, Fachbereich Informatik, TH Darmstadt
Alexanderstraße 10, 6100 Darmstadt
ÜBERSICHT
1. Rechnergestützte Software-Entwicklung
(a) Ziele und Realität
(b) Wozu Meta-Synthese?
2. Formalisierung von Software-Entwicklung
(a) Objektwissen
(b) Grundbegriffe der Programmierung
(c) Syntheseparadigmen
(d) Synthesestrategien
3. Ausblick
(a) Verwendbarkeit von Formalisierung
(b) Zukünftige Forschungsrichtungen
SOFTWARE-KRISE
Kommerzielle Software wird “von Hand” und direkt
in einer gegebenen Programmiersprache entwickelt.
• Schnelle Produktion von Software
• Hohe Kosten für Erstellung und Wartung
• Modifikationen und Erweiterungen schwierig
– keine Dokumentation des Programmierprozesses
• Mangelnde Zuverlässigkeit mit fatalen Folgen
– Tests sind nicht aussagekräftig
– Korrektheitsbeweise undurchführbar
SYSTEMATISCHE
SOFTWARE-ENTWICKLUNG
• Programmierung ist logisches Schließen
• Programmierung verarbeitet Wissen
über Programme, Anwendungsbereiche, Programmiermethoden
• Menschen machen Fehler im Detail
• Formalisierung und Automatisierung nötig
• CASE-tools sind nicht genug
Softwareproduktion braucht
Wissensbasiertes Software-Engineering
PROGRAMMSYNTHESE
Automatisierte Entwicklung validierter Software
• Algorithmen-Synthese aus formalen Spezifikationen
• Hilfe beim Entwurf formaler Spezifikationen
• Hilfsmittel zur
– algorithmischen Optimierung,
– Implementierung abstrakter Datentypen
– sprachabhängigen Compilierung / Optimierung
...
• Dokumentation getroffener Entscheidungen
• Verfahren zum Erwerb von Synthesewissen
PROGRAMMSYNTHESE –
KALKÜLE
• Regeln für syntaktische Manipulation von Formeln
ersetzen semantisch-logisches Schließen
• Absolut formal, wohlbekannte Eigenschaften
• Ausdruckstark genug zur Formalisierung
der gesamten Mathematik und Programmierung
• Abstraktionsniveau gering: Einzelschritte zu atomar
• Wenige praktische Ergebnisse
• Forschung richtet sich auf theoretische Eigenschaften
PROGRAMMSYNTHESE –
SYSTEME
• “Halb-formale” Beschreibung auf dem Papier
• Implementierung erfolgreich an Beispielen getestet
• Bald verwendbar für Routineprogrammierung ?
• Einsatz in der Lehre möglich ?
• Implementierung “ad hoc”
• Gleiche Probleme wie konventionelle Software:
– tatsächliches Verhalten unklar
– Wartung und Modifikation schwierig
– Korrektheit nicht gesichert
META-SYNTHESE – ZIELE
Systeme für rechnergestützte Software-Entwicklung
müssen systematisch entwickelt werden.
• Formalisiere die Objekt- und Meta-Theorie
der Programmierung in einheitlichem Rahmen.
• Durch Abstraktion schließe Lücke zwischen formalen Kalkülen
und semi-formalen Syntheseverfahren.
• Beweise Eigenschaften von deduktiven Methoden
und erzeugten Programmen als formale Theoreme.
• Realisiere Formalisierung mit einem Beweiseditor
für den zugrundeliegenden logischen Kalkül.
• Leite Implementierungen deduktiver Methoden ab aus
Theoremen über Erfüllbarkeit von Spezifikationen.
VERWANDTE GEBIETE
• Formale Kalküle und ihre Implementierung
Intuitionistische Typentheorie (Martin-Löf),
Kalkül der Konstruktionen (Huet/Coquand),
System F, Fω , Lineare Logik (Girard), . . .
• Strategien für automatische Programmsynthese
KIDS (Kestrel Institute), PRECOMAS (Franova),
LOPS (Bibel), OYSTER-CLAM (Bundy), . . .
+ Formale Methoden des Software-Engineering (VDM)
• Meta-programmierung (“taktisches Beweisen”)
LCF (Edinburgh / Cambridge), NuPRL (Cornell),
KIV (Heisel/Reif/Stephan), DEVA (GMD Karlsruhe)
OYSTER-CLAM, . . .
• Meta-Reasoning und Logical Frameworks
Isabelle (Paulson, Cambridge), λ-Prolog (Felty/Miller)
LF (Edinburgh), Elf (Pfenning), FOL (Weyrauch)
INTUITIONISTISCHE
TYPEN-THEORIE
Basiskalkül für Logik, Datentypen und Berechnung
• Sortierte Logik höherer Stufe
• Gleichheitsbegriff abhängig vom Datentyp
• Funktionale Programmiersprache
• Viele Datentyp-Konstrukte vordefiniert:
– Zahlen, Strings, Funktionenräume, Produkträume,
– disjunkte Vereinigung, Listen, Sub-Typen, Faktorisierung,
– Rekursive Datentypen, Partiell-rekursive Funktionen.
• Top-Down Sequenzenkalkül (ca. 150 Regeln)
• NuPRL: Interaktives Theorie-Entwicklungs-System
– Beweiseditor
– Programmextraktion aus Beweisen
– Definitionsmechanismus (Textmacros mit Parametern)
– Meta-level Programmierung von Beweisstrategien
– Bibliothek
DARSTELLUNG VON
OBJEKTWISSEN
Begriffe prägen – Eigenschaften als Lemmata beweisen
• Explizit definierte Operationen und Konzepte
– Implementiert durch direkte Definition
– Zugriff durch Instantiierung der Definition
• Formal verifizierte Lemmata
(elementare Eigenschaften der Kombination von Operationen)
• Definition abstrakter Datentypen
(endliche Sequenzen, Mengen, Abbildungen, Arrays, . . . )
– Definition von Signaturen und Axiomen
– Implementiert durch Theorem über Erfüllbarkeit
– Zugriff nur auf Axiome
Zur Zeit ca. 150 Definitionen, 650 Lemmata
ABSTRAKTER DATENTYP: Menge
Abstrakte Definition:
FINITE SETS(α)
≡
TYPES
Set(α)
OPERATIONS
∅: Set(α)
+: Set(α)×
×α → Set(α)
∈:
AXIOMS
α×
×Set(α) → Bool
∀S:Set(α).∀x,a:α.
a 6∈ ∅
∧
x ∈ (S+a) ⇔ (x=a
∧
(S+a)+x = (S+x)+a
∧
(S+a)+a = S+a
∧
∀P:PROP(Set(α)).
P(∅)
⇒
∧
∨
x ∈ S)
∀S:Set(α).∀a:α. P(S) ⇒ P(S+a)
∀S:Set(α).P(S)
Implementierungstheorem:
∀α:TYPES. FINITE SETS(α) has a model
PROGRAMMIERUNG: Grundbegriffe
Eine Spezifikation besteht aus Ein- und Ausgabetypen D und R, einer
Eingabebedingung I und einer Ausgabebedingung O.
Ein Programm besteht aus einer Spezifikation (DD,RR,I,O) und einer
(berechenbaren, partiellen) Funktion body:DD6→R.
Formale Definitionen:
SPECIFICATIONS
≡ D:TYPES × R:TYPES × PROP(DD) × PROP(DD× R)
DOM(spec)
≡ let spec=(DD,RR,I,O) in {x:DD | I(x)}
PROGRAMS
≡ spec:SPECIFICATIONS × DOM(spec)→RR(spec)
consistent(p)≡ let p=( (DD,RR,I,O), body) in
∀x:DD. I(x) ⇒ O(x,body(x))
spec is satisfiable ≡ ∃body:DOM(spec)→RR(spec).
consistent(spec,body)
Programmsynthese = Beweis von spec is satisfiable
Notation mit Schlüsselwörtern:
FUNCTION f (x:DD):RR
RETURNS y
= body(x)
WHERE I(x)
SUCH THAT O(x,y)
METHODEN als METATHEOREME
“Erzeuge korrektes Programm für Spezifikation spec
durch den Nachweis bestimmter Bedingungen”
• Formalisierung: Formulierung eines Metatheorems
‘‘spec is satisfiable
⇐
Bedingungen’’
• Validierung: Beweis des Metatheorems
• Implementierung des Ableitungsschrittes:
Anwendung des computerisierten Metatheorems
• Implementierung der Algorithmenkonstruktion:
Enthalten im computerisierten konstruktiven Beweis
SYNTHESEPARADIGMEN
•
Beweise als Programme
– Extraktion aus konstruktivem Beweis eines Theorems
•
Synthese durch Transformationen
– Äquivalenzumformung in ausführbare Form
•
Algorithmenschemata
– Wissensbasierte Verfeinerung von Standardlösungen
für algorithmische Grundstrukturen
Unterscheiden sich durch
– Interne Aufgabenstellung (Darstellung des Problems)
– Interne Lösungsmethode (Art der Inferenz)
– Konstruktion des Algorithmus aus interner Lösung
Individuelle Notationen und Heuristiken variieren stark.
ÄQUIVALENZ DER PARADIGMEN
Formales Meta-Theorem:
∀spec=(DD,RR,I,O):SPECIFICATIONS.
spec
is satisfiable
⇔ ∀x:DD. ∃y:RR. I(x) ⇒ O(x,y)
is provable
⇔ ∃OD :PROP(DD× Seq(DD)). ∃OC :PROP(DD× Seq(DD)×
×Seq(RR)×
×R).
∀x,y. O(x,y) ⇔ ∃x̄,ȳ. OD (x,x̄)
∧
O∗ (x̄,ȳ)
∧
OD is a well-founded relation
∧
( D, Seq(DD), I, OD )
is satisfiable
∧
( D× D× R, R, I, OC )
is satisfiable
∧
OC (x,x̄,ȳ,y)
⇔ ∃A:THEORIES.∃A:Models(A).
A is an algorithm theory
∧
A extends spec
Macht individuelle Ansätze zur Programmsynthese
originalgetreu darstellbar, korrekt implementierbar,
vergleichbar und integrierbar
SYNTHESE-STRATEGIEN
Formalisierung repräsentiert, verfeinert, verbessert und
implementiert Beschreibungen existierender Strategien.
LOPS (Bibel, 1980 . . . )
• Ausformulierung der verbalen Beschreibung
• Verifikation von Teilstrategien
• Grundlage für Neuimplementierung
KIDS (Kestrel Institute, 1985 . . . )
• Verfeinerung einer Formalisierung
• Aufdeckung kleiner Fehler
• Schließen von Lücken durch neue Konzepte
Implementierung einer Strategie wird identisch
mit ihrer textueller Beschreibung
SYNTHESE von GS-ALGORITHMEN
Berechnung aller Lösungen eines Problems
GLOBALSUCHE:
– Manipulation von Mengen von Lösungskandidaten
– Verallgemeinerung von Binärsuche, Backtracking, etc.
– Vollständig
Synthese durch Analyse der Struktur
• Darstellung durch “space descriptors” s ∈ S
J(x,s): s ist ein sinnvoller Deskriptor für x
sat(z,s): z ist in der durch s beschriebenen Menge
• Initialdeskriptor s0(x) ∈ S umfaßt alle Lösungen
• Direkte Extraktion ext(s) ∈ Set(RR) von Kandidaten
• Aufspaltung von Deskriptoren split(x,s) ∈ Set(S)
• Elimination von Deskriptoren durch Filter Φ(x,s)
• Rekursion bis kein Splitting mehr möglich ist
FORMALE GS-SCHEMATA
G is a GS-theory
≡ let G=((DD,RR,I,O), S, J, s0, sat, split, ext) in
consistent((DD,RR,S,J), s0)
∧
∀x:DD.I(x) ⇒ ∀s:S. J(x,s) ⇒ ∀t ∈ split(x,s).J(x,t)
∧
∀x:DD.I(x) ⇒ ∀z:R. O(x,z) ⇒ sat(z,s0(x))
∧
∀x:DD.I(x) ⇒ ∀s:S. J(x,s) ⇒ ∀z:R.
sat(z,s) ⇔ ∃k:IN.∃t ∈ splitk (x,s). z ∈ ext(t)
splitk (x,s)
≡ if k=0 then {s} else
S
{splitk−1 (x,t)|t ∈ split(x,s)})
G is well-founded
≡ let G=((DD,RR,I,O), S, J, s0, sat, split, ext) in
∀x:D.∀s:S. ∃k:IN. splitk (x,s) = ∅
G extends spec
≡ let G=((DD,RR,I,O), S, J, s0, sat, split, ext) in
spec = (DD,RR,I,O) in SPECIFICATIONS
GS-STRATEGIE
Eine Spezifikation wird synthetisiert durch Einbettung in
ein wohlfundiertes Globalsuch-Schema. (Smith, 1988)
Implementierungstheorem:
∀spec=(DD,RR,I,O):SPECIFICATIONS.
FUNCTION f (x:DD):Set(RR)
RETURNS S
WHERE I(x)
SUCH THAT S={y:RR|O(x,y)}
is satisfiable
⇐ ∃G. G is a GS-theory
∧
∧
G is well-founded
G extends spec
Beweis durch explizite Angabe des Lösungsschemas
Sei G=((DD,RR,I,O), S, J, s0, sat, split, ext)
Setze f (x)
:= Fgs (x,s0(x))
Fgs (x,s) :=
{z|z ∈ ext(s) ∧ O(x,z)}
∪
S
{Faux (x,t)| t ∈ split(x,s)}
Verifiziere Schema durch Induktion über die Anzahl
der Schritte bis kein Splitting mehr möglich ist.
GS-STRATEGIE – verfeinert
Synthetisiere durch Spezialisierung eines GS-Schemas und
eines Wohlfundiertheits-Filters aus der Wissensbank.
Implementierungstheorem:
∀spec=(DD,RR,I,O):SPECIFICATIONS.
FUNCTION f (x:DD):Set(RR)
RETURNS S
WHERE I(x)
SUCH THAT S={y:RR|O(x,y)}
is satisfiable
⇐ ∃G.∃Φ. G is a GS-theory
∧
∧
Φ is a wf-filter for G
G generalizes spec
G generalizes spec
≡ let G=((DD,RR,I,O), S, J, s0, sat, split, ext)
and spec=(DD’,RR,I’,O’)
in
∀x:DD. I(x) ⇒ ∃x’:DD’. I’(x’)
∧
∀z:RR. O(x,z) ⇒ O’(x’,z)
Φ is a wf-filter for G
≡ let G=((DD,RR,I,O), S, J, s0, sat, split, ext) in
∀x:DD.∀s:S. I(x) ∧ J(x,s) ⇒ ∃k:IN. splitΦ k (x,s) = ∅
splitΦ ≡ λx,s.{t|t ∈ split(x,s) ∧ Φ(x,t)}
ZUSAMMENFASSUNG
Logisch-formale Theorie der Programmentwicklung
• Einheitliche Behandlung von Objekt- und Metalevel
• Hohes Abstraktionsniveau
• Erfaßt alle Aspekte der Programmierung
• Erweiterbar auf andere Gebiete der Deduktion
• Vollständig formal
• Ohne Modifikationen implementierbar
Ermöglicht
• Verifizierte Implementierung von Synthesestrategien
• Integration verschiedenartiger Strategien
• Integration einer Vielfalt von Komponenten
Fundament der Inferenzmaschine innerhalb einer
Umgebung für wissensbasiertes Software-Engineering
FORSCHUNGSRICHTUNGEN
• Interface zwischen Mensch und formaler Theorie
• Entwurf formaler Spezifikationen
• Darstellung von Planungs- und Beweismethoden
• Vergleich und Integration von Designstrategien
• Systematischen Optimierung von Algorithmen
• Datentyp-Verfeinerung
• Automatische Entwicklung von Standardwissen
• Rechnergestützte Synthese von Strategien