CASL - Tool(s) Methoden und Modelle des Systementwurfs WS 07/08

Präsentation zum Thema: "CASL - Tool(s) Methoden und Modelle des Systementwurfs WS 07/08"—  Präsentation transkript:

1 CASL - Tool(s) Methoden und Modelle des Systementwurfs WS 07/08
Andre Waloszek, Johannes Starlinger CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

2 Inhalt Die CASL – Landschaft und Ihre Tool(s) HETS
CASL – Partielle Funktionen CASL – Sub-Sorten CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

3 Die CASL – Landschaft und Ihre Tools
Hauptanlaufstelle: CoFi: Tools: CATS (CASL Tool Set) HOL-CASL CCC (CASL consistency checker) HETS (Heterogenous Toolset) outdated prototype CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

4 HETS – Heterogenous Toolset (Was ist das?)
Gegeben: CASL – Spezifikation Aufgaben: Parsen Statische Analyse Beweis der Korrektheit (Proofs) Verschiedene Proover: Isabelle (Höherwertige Logik) SPASS (Logik erster Stufe) Andere (Vampire, MathServe) CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

5 HETS (Was ist das genau?)
CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

6 CASL-Tool(s) – Andre Waloszek, Johannes Starlinger
HETS (Haben wollen) Link auf CoFi Website Verfügbar für: Linux x86, Intel Mac, PPC Mac, Solaris on Sparc Java .jar Installer verwenden (recommended!!!) Depends: tcl/tk, alles andere wird automatisch installiert (Isabelle, SPASS, uDrawGraph) CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

7 HETS – ein Beispiel spec Strict_Partial_Order = sort Elem
pred __<__ : Elem * Elem forall x, y, z:Elem . not (x < x) %(strict)% . (x < y) => not (y < x) %(asymmetric)% . (x < y) /\ (y < z) => (x < z) %(transitive)% end spec Partial_Order = Strict_Partial_Order then pred __<=__ : Elem * Elem forall x, y :Elem . (x <= y) <=> (x < y) \/ x = y %(newax)% spec Partial_Order_1 = Partial_Order then %implies . (x <= y) /\ (y <= z) => (x <= z) %(trans)% HETS – ein Beispiel

8 HETS – Der Graph, Die Knoten, Die Kanten
Rote: haben offene Beweiselemente Grüne: erfüllen alle Beweispflichten Kanten Schwarze: nach Spez. definierende Kanten Sonst: Theoremkante Rote: entsprechen offenen Beweispflichten Grüne: entsprechen bewiesenen Elementen CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

9 CASL – Partielle Funktionen (1)
Deklaration: spec Set_Partial_Choose [ sort Elem ] = Generated_Set [ sort Elem ] then op choose : Set →? Elem end Definitionsbereiche: spec Set_Partial_Choose_1 [ sort Elem ] = Set_Partial_Choose [ sort Elem ] then • ¬ def choose(empty) ∀S : Set • def choose(S) ⇒ choose(S) is in S spec Set_Partial_Choose_2 [ sort Elem ] = Set_Partial_Choose [ sort Elem ] then ∀S : Set • def choose(S) ⇔ ¬(S = empty) ∀S : Set • def choose(S) ⇒ choose(S) is in S end CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

10 CASL – Partielle Funktionen (2)
Caveats: Undefiniertheit wird weitergereicht, auch an totale Funktionen Relationen auf undefinierte Werte halten nicht stand Gleichheit gilt auch für undefinierte Werte! → Benutzung von existenzieller Gleichheit (kommt gleich) Axiome können zu Totalität führen insert(choose(S), S) = S %% insert ist totale Funktion oder choose(S) is_in S 'same name, same thing' Prinzip → Besondere Vorsicht bei der Deklaration und Definition von partiellen Funktionen! Meistens besser Definitionsbereich exact anzugeben CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

11 CASL – Partielle Funktionen (3)
Beispiele: spec Natural_Partial_Pre = Natural_Arithmetic then op pre : Nat →? Nat • ¬ def pre(0) ∀x : Nat • pre(suc(x)) = x end spec Natural_Partial_Subtraction = Natural_Partial_Pre then op __−__ : Nat × Nat →? Nat ∀x , y : Nat • def (x − y) ⇔ (y < x ∨ y = x) • x − 0 = x • x − suc(y) = pre(x − y) spec Natural = free type Nat ::= 0 | suc(Nat ) spec Natural_Order = Natural then free { pred __<__ : Nat × Nat ∀x , y : Nat • 0 < suc(x ) • x < y ⇒ suc(x ) < suc(y) } end spec Natural_Arithmetic = Natural_Order then ops 1 : Nat = suc(0); __+__ : Nat × Nat → Nat , assoc, comm, unit 0; __∗__ : Nat × Nat → Nat , assoc, comm, unit 1 • x + suc(y) = suc(x + y) • x ∗ 0 = 0 • x ∗ suc(y) = (x ∗ y) + x CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

12 CASL – Existenzielle Gleichheit
Motivation: Bei 'normaler' Gleichheit ist undef=undef wahr Das gilt nicht bei existenzieller Gleichheit spec Natural_Partial_Subtraction_2 = Natural_Partial_Subtraction then ∀x , y, z : Nat • y − x =e= z − x ⇒ y = z %{ y − x = z − x ⇒ y = z wäre falsch, def (y − x) ∧ def (z − x) ∧ y − x = z − x ⇒ y = z ist richtig, aber die obige Abkürzung ist besser lesbar }% end → Bei bedingenden Gleichheiten in Axiomen partieller Funktionen besser existenzielle Gleichheit verwenden CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

13 CASL-Tool(s) – Andre Waloszek, Johannes Starlinger
Sub-Sorten ohne Subsorts: 1. spec Generic_Monoid [sort Elem] = 2. sort Monoid 3. ops inj : Elem -> Monoid; : Monoid; __*__ : Monoid * Monoid -> Monoid, assoc, unit 1 6. forall x, y : Elem . inj (x) = inj (y) => x = y 7. end mit Subsorts: 1. spec Generic_Monoid [sort Elem] = 2. sort Elem < Monoid 3. ops 1 : Monoid; __*__ : Monoid * Monoid -> Monoid, assoc, unit 1 5. end Ausdruck von Beziehungen zwischen Sorten CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

14 Sub-Sorten & Vererbung
1. spec Vehicle = Natural 2. then sorts Car, Bicycle < Vehicle 3. ops max_speed : Vehicle -> Nat; weight : Vehicle -> Nat; engine_capacity : Car -> Nat 6. end Auf Sorten deklarierte Operationen werden an die Sub-Sorten vererbt 7. spec More_Vehicle = Vehicle 8. then sort Boat < Vehicle 9. end Dies gilt auch für nachträglich deklarierte Sub-Sorten CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

15 Sub-Sorten & Überladung
Manchmal kann es nützlich sein bereits deklarierte Operationen mit Hilfe neu eingeführter Sub-Sorten zu überladen. 1. spec Positive = Natural_Partial_Pre 2. then sort Pos = {x : Nat . not x = 0} 3. end 4. spec Positive_Arithmetic = Positive 5. then ops : Pos; suc : Nat -> Pos; __+__, __*__ : Pos * Pos -> Pos; __+__ : Pos * Nat -> Pos; __+__ : Nat * Pos -> Pos 10. end CASL-Tool(s) – Andre Waloszek, Johannes Starlinger

16 Sub-Sorten & partielle Funktionen
Eine Sub-Sorten kann dem Definitionsbereich einer partiellen Funktion entsprechen. 1. spec Positive_Pre = Positive_Arithmetic 2. then op pre: Pos -> Nat Mit der Hilfe von Sub-Sorten können partielle Funktionen vermieden werden. 1. spec Natural_Positive_Arithmetic = 2. free types Nat ::= 0 | sort Pos Pos ::= suc(pre : Nat) CASL-Tool(s) – Andre Waloszek, Johannes Starlinger