Differences

This shows you the differences between two versions of the page.

--- uni:6:fsv:start [2014-07-10 21:06] – [BDD] skrupellos
+++ uni:6:fsv:start [2020-11-18 18:11] (current) – external edit 127.0.0.1
@@ Line 35: / Line 35: @@
 ==== Tseitin Übersetzung ====
+**Nur erfüllungsäquivalent**
   * Rekursive Funktion //KNF//
     * Rein
@@ Line 113: / Line 115: @@
 BDDs sind //eindeutig//: Gleiche Funktion => isomorphe BDDs
-Shannon-Zerlegung: $f = (x \wedge f[x := \top]) \vee (\neg x \wedge f[X := ])$
+Shannon-Zerlegung: $f = (x \wedge f[x := \top]) \vee (\neg x \wedge f[x := \perp])$
+Negation: //True// und //False// vertauschen
+Variable setzen:
+  - ersetzen/umlenken
+  - reduzieren
+Zweistellige Operationen: Rekursiv $(x \wedge (f[x := \top] \oplus g[x := \top])) \vee (\neg x (\wedge f[X := \perp] \oplus g[x := \perp]))$
+(Gehe die Variablen der reihe nach durch. Ersetze die Nachfolger durch $\oplus$ aus den //True//-Zweigen und durch $\oplus$ aus den //False//-Zweigen.)
+Alle möglichkeiten einer Variablen probieren: $\exists x: f := f[x := \top] \vee f[x :=\perp]$
+Optiomierungen
+  * Umordnen (extremfall: explonential)
+  * Teilographen wiederverwenden (Hash-Funktion zum finden)
+<WRAP center round important 60%>
+Es fehlen nebenläufige Systeme!!!
+</WRAP>
+===== Model checking =====
+Arten
+  * Bounded (Beschränkt durch die Symulationszeit)
+    * SAT Solver
+  * Symbolic
+    * BDDs
+Dinge die Interessieren
+  * Safty: Keine verbotenen Zustände erreichbar
+  * Liveness: Reset-Zustand immer erreichbar? Kein verklemmen $AG(EF\bigwedge_p q_{p,sleep})$
+  * Fairness: "Gute Eigenschaft" gilt für alle fairen Abläufe
+==== CTL ====
+^ Propositionale Variablen | $p, q, \ldots$ | Jedes Aussgenlogische Formel ist CTL! |
+^ Junktoren | $\neg, \wedge, \vee, \Rightarrow, \Leftrightarrow$ | ::: |
+^ Formel | $\phi, \psi, \ldots$ | ::: |
+^ Konstanten | $\top, \perp$ | ::: |
+^ Foo | $AX, EX, A[\phi U \psi], E[\phi U \psi], AG \phi, AF \phi, EG \phi, EF \phi$ | |
+$AG \Leftrightarrow \neg EF(\neg \phi)$
+<WRAP second column>
+^A|Auf allen Pfaden gilt ...|
+^E|Auf (mindestens) einem Pfad gilt ...|
+</WRAP>
+<WRAP second column>
+...in...
+</WRAP>
+<WRAP second column>
+^X|Ne**x**t|... (mindestens) einem unmittelbar folgenden Zustand|
+^F|**F**inal|... (mindestens) einem folgenden/selben Zustand|
+^G|**G**lobaly|... allen folgenden/selben Zuständen|
+^U|**U**ntil|... allen folgenden/selben Zuständen $\phi$, bis $\psi$ gilt. \\ $\psi$ kann bereits im selben gelten|
+</WRAP>
+=== Transitinssystem ===
+$(S, \rightarrow)$
+  * Zustands//menge//: $\{(False, True), (True, False), (True, True)\}$
+  * Transitionsrealtion: $\{\left(\left(Fals, True\right), \left(True, False\right)\right), \ldots\}$
+===Interpretationen===
+^ $Tr(\mathcal{I})$ | $(S, \rightarrow)$ | Transitionsystem | Durch $\mathcal{I}$ festgelegt |
+^ $\mathcal{I}(p)$  | $\subseteq S$ | Zustände in denen $p$ gilt | ::: |
+^ $s \models \mathcal{I} p$ | $\{True, False\}$ | Aussage: $p$ ist in Zustand $s$ gesetzt | ::: |
+^ $\mathcal{I}(\phi)$  | $\subseteq S$ | Zustände in denen $\phi$ gilt | Ableitbar |
+^ $s \models \mathcal{I} \phi$ | $\{True, False\}$ | Aussage: $\phi$ ist in Zustand $s$ gesetzt | ::: |
+Interpretation enthält keine Formel.
+===Äquivalenz ===
+  * (AE)(GF) vertauschen und 2xnegieren
+    * $AG(\phi) \Longleftrightarrow \neg EF(\neg \phi)$
+    * $AF(\phi) \Longleftrightarrow \neg EG(\neg \phi)$
+    * $EF(\phi) \Longleftrightarrow \neg AG(\neg \phi)$
+    * $EG(\phi) \Longleftrightarrow \neg AF(\neg \phi)$
+  * $AG(\phi \wedge \psi) \Longleftrightarrow AG(\phi) \wedge AG(\psi)$
+  * $AF(\phi) \Longleftrightarrow A[\top U \phi]$
+  * $EF(\phi) \Longleftrightarrow E[\top U \phi]$
+  * $A\[\phi U \psi\] \Longleftrightarrow \neg (E[\neg \phi U (\neg \phi \wedge \neg \psi)] \vee EG(\neg \phi))$
+=== Labeling Algorithmus ===
+  - Formel umformen (nur noch $\neg, \wedge, \perp, AF, E[\cdot U \cdot ]$)
+  - Teilformeln bis auf Variablen-Ebene finden
+  - Teilformeln Bottom-up durchgehen, bis nichts mehr geht
+    - Graph mit geltenden Teilformeln markieren, bis nichts mehr geht (dabei auf bereits markiertes berufen)
+Markiere mit ..
+  * $AF(\phi)$, wo ..
+    * $\phi$
+    * Alle Nachfolger sind $AF(\phi)$
+  * $E[\phi U \psi]$, wo ..
+    * $\psi$
+    * $\phi$ und Folgezustand mit $E[\phi U \psi]$
+Effizienter: $EG(\phi)$ anstatt $AF(\phi)$
+  - $\neg\phi$ für Ausblenden/Ignorieren/Streichen
+  - Starke Zusammenhangskomponenten markieren (Ring-Pfad durch Knoten)
+  - Markiere Knoten, die in eine  //echte// starke Zusammenhangskomponenten zeigen
+Zeitkomplexität: Linear zu Transitionen
+Aber //state-explosion-problem//: Exponentiell mit Anzahl zu modelierender Prozesse \\ => BDDs verhindern das (es kann optimiert werden)
+=== Fairnes ===
+Alle interessierenden Zustände können immer unendlich offt erreicht werden.
+  * D.h. für ''E?'', es Existiert ein fairer Pfad in dem ...
+  * D.h. für ''A?'', in allen fairen Pfaden gild ...
+Abwandlung des Labeling Algorithmuses:
+  * Starke Zusammenhangskomponente ist fair, wenn ein Zustand Fairnesbedingung erfüllt
+  * Zustand ist fair, wenn ein (längerer) Pfad zu fairen starken Zusamenhangskomponente existiert
+=== Encoding of CTL in BDD ===
+BDD ist ein Bitvektor und daher kann ich ein Transitionsystem eincodieren, sowie ein $\phi$.
+http://nicta.com.au/__data/assets/pdf_file/0018/14814/lecture4-mc2.pdf
+<WRAP center round important 60%>
+ToDo
+</WRAP>
+==== LTL ====
+^ Propositionale Variablen | $p, q, \ldots$ | **eingeschränktes** CTL! |
+^ Junktoren | $\neg, \wedge$ | ::: |
+^ Formel | $\phi, \psi, \ldots$ | ::: |
+^ Konstanten | $\top$ | ::: |
+^ Foo | $X \phi, F \phi, G \phi, \phi U \psi$ | |
+  * Fairness direkt angebbar: ''**(GF** p1.state=running**) =>** ...''
+  * CTL ist ausdrucksstärker
+  * Für **alle** Pfade muss ... gelten
+==== Büchi Automat ====
+$(\Sigma, T, I, E, \delta)$
+| $\Sigma$ | Menge | Alphabet |
+| $Z$ | Menge | Zustände |
+| $I$ | Menge | Anfangszustände |
+| $E$ | Menge | Endzustände |
+| $\delta$ | Relation | Zustandsübergänge |
+  * Nichtdeterministisch
+  * Unendliche Wörter
+  * Akzeptiert: Wenn mindestens ein Lauf //existiert//, der immer zu einem Endzustand kommen (unendlich offt)
+$L = (b^{*}a)^\omega$ (wenn ''a'' immer wieder vorkommen muss)
+| $\omega$ | FG | Unendlich offt vorkommen |
+| $*$      | GF | Endlich offt vorkommen   |
+===== Typanalyse =====
+==== While Programm ====
+  * ''**while [**...**] do **...''
+  * ''**if [**...**] then **...** else **...''
+  * ''**true**''
+  * ''**false**''
+  * ''**not **...''
+  * ''... **:= **...''
+  * Aritmetische Ausdrücke
+  * Boolsche Ausdrücke
+==== Datenflussgleichung ====
+"Erreichbare Definitionen" (Reachable Definitions)
+  * $RD_{{\color{ForestGreen}entry}}(\ell) = \bigcup_{{\color{red}\ell'}:{\color{red}\ell'}\rightarrow\ell}RD_{exit}({\color{red}\ell'})$
+  * $RD_{exit}(\ell) = (RD_{{\color{ForestGreen}entry}}(\ell) \setminus \text{"Entwertete Zuweisungen"}) \cup \text{ "Neue Zuweisungen"}$
+  * Zu beginn werden //alle// Variablen mit "$(X, \ell)$" initialisiert.
+"Verfügbare Ausdrücke" (Available Expressions)
+  * $AE_{{\color{ForestGreen}entry}}(\ell) = {\color{blue}\bigcap}_{{\color{red}\ell'}:{\color{red}\ell'}\rightarrow\ell}AE_{exit}({\color{red}\ell'})$
+  * $AE_{exit}(\ell) = (AE_{{\color{ForestGreen}entry}}(\ell) \setminus kill_{AE}(B^\ell)) \cup gen_{AE}(B^\ell)$
+  * $kill_{AE}([x:=a]^\ell) = \{\text{Formeln, die }x\text{ enthalten}\}$
+  * $gen_{AE}([x := a]) = \{\text{Teilausdrücke von }a\text{ ohne }x\}$
+  * $gen_{AE}([bool\ exp]) = \{\text{Teilausdrücke von }bool\ exp\}$
+  * Zu beginn werden //alle// Variablen mit "$\emptyset$" initialisiert.
+  * //Nur// Arithmetische Ausdrücke
+"Lebendige Variablen" (Live Variables)
+  * $LV_{exit}(\ell) = \bigcup_{{\color{red}\ell'}:\ell\rightarrow{\color{red}\ell'}}LV_{{\color{ForestGreen}entry}}({\color{red}\ell'})$
+  * $LV_{{\color{ForestGreen}entry}}(\ell) = (LV_{exit}(\ell) \setminus kill_{LV}(B^\ell)) \cup gen_{LV}(B^\ell)$
+  * $kill_{LV}([x:=a]^\ell) = \{x\}$
+  * $gen_{LV}([x := a]) = \{\text{Variablen in }a\}$
+  * $gen_{LV}([bool\ exp]) = \{\text{Variablen in }bool\ exp\}$
+  * Zu beginn werden //alle// Variablen mit "$\emptyset$" initialisiert.
+^ $\ell$ ^ $RD_{entry}(\ell)$ ^ $RD_{exit}(\ell)$ ^
+| 1 | (x, ?), (y, ?) | ... |
+| 2 | ... | ... |
+| 3 | ... | ... |
+So lange ausfüllen, bis nichts mehr geht.
+Das geht, weil //Fixpunkte// und //Knaster-Tarski-Theorem//
+==== SMV ====
+Teile
+  - MODULE
+  - VAR
+  - ASSIGN
+  - INIT
+  - TRANS
+  - SPEC
+  - JUSTICE/FAIRNESS
+  * Case sensitive
+  * Wenn uterspezifiziert: Deterministisch
+  * Wenn Block mehrfach: Konjunktion
+  * Nur einzelnes Zeichen: **''&''** bzw. **''|''**
+  * Nur Einfacher Strich: **''%%->%%''** für =>
+  * Negieren, um Lösung als Gegenbeispiel zu bekommen
+=== MODULE ===
+<code>
+MODULE main
+</code>
+-- oder --
+<code>
+MODULE p(x, y, z)
+</code>
+  * Keine Typ angaben
+=== VAR ===
+<code>
+VAR
+  a : boolean;
+  b : {foo, bar};
+  c : process otherModule(foo, bar);
+</code>
+  * ''... **:** ... **;**''
+  * ''boolean''
+  * Set: ''{}''
+=== ASSIGN ===
+<code>
+ASSIGN
+  init(b) := foo;
+  next(b) := {foo, bar};
+  next(b) := case
+               foo  : bar;
+               TRUE : {foo, bar};
+             esac;
+  c := !b
+</code>
+  * ''... **:=** ...**;**''
+  * ''init()''
+  * ''next()''
+  * Invarianten
+  * ''case ... esac''
+  * Ersetzt ''INIT'', ''TRANS'' und ''INVAR''
+Bei ''case'': ''Boolscher Test: Wert/Set;''
+=== INIT ===
+<code>
+INIT
+  b = foo;
+</code>
+  * ''... **=** ... **;**''
+=== TRANS ===
+<code>
+TRANS
+    b = foo & next(b) = bar
+  | b = bar & next(b) = foo
+  | b = bar & next(b) = bar
+</code>
+  * Transition, wenn Formel erfüllt
+=== INVAR ===
+<code>
+INVAR
+  Ziege.pos = Wolf.pos -> Bauer.pos = Ziege.pos
+</code>
+  * Invariante
+=== SPEC ===
+<code>
+SPEC
+  AG(a -> AF b = foo)
+</code>
+=== DEFINE ===
+<code>
+DEFINE
+  foo := myVar = foo & myOtherVAr = bar;
+</code>
+  * ''... **:=** ... **;**''
+=== JUSTICE/FAIRNESS ===
+<code>
+JUSTICE/FAIRNESS
+  p1.status = running
+</code>
+===== Beweise =====
+==== Vollständiger Verband ====
+Verband $(L, \sqsubseteq)$
+  * **reflexiv** \\ $\forall_{x \in L} : x \sqsubseteq x$
+  * **transitiv** \\ $\forall_{x, y, z \in L} : x \sqsubseteq y \wedge y \sqsubseteq z \Rightarrow x \sqsubseteq z$
+  * **antisymetrisch** \\ $\forall_{x, y \in L} : x \sqsubseteq y \wedge y \sqsubseteq x \Rightarrow x = y$
+  * **Jede Teilmenge hat ein Supremum** \\ Jedes $U \subseteq L$ hat ein $\bigsqcup U$
+==== Supremum ====
+$s = \bigsqcup U$
+  * **Ist obere Schranke** \\ $\forall_{x \in U} : x \sqsubseteq s$
+  * **Ist //kleinste// obere Schranke** \\ $s' \text{ ist obere Schranke } \Rightarrow s \sqsubseteq s'$
+==== Monotonie ====
+  * $x \sqsubseteq y \Rightarrow F(x) \sqsubseteq F(y)$
+==== Fixpunkt ====
+  * $\exists x: F(x) = x$
+Dazu muss $F(x)$ monoton sein.
+===== Probleme =====
+==== Semaphor ====
+==== Alternating Bit Protocol ====
+  * Zwei Kommunikationspartner
+  * Bidirektionaler Kanal
+  * Nachricht: OK/Defekt
+  * So lange wiederholen bis es klapt
+OK
+^ Kontrollbit: 0 ^ Nachricht | -> ^  | OK |
+^ || <- ^ 0 | ::: |
+^ Kontrollbit: 1 ^ Nachricht | -> ^  | OK |
+^ || <- ^ 1 | ::: |
+Fehler
+^ Kontrollbit: 0 ^ Nachricht | -> ^ ✘ | Fehler beim Empfänger \\ => Unerwartetes Kontrollbit zurück senden |
+^ || <- ^ 1 | ::: |
+^ Kontrollbit: 0 ^ Nachricht | -> ^  | Fehler beim Sender |
+^ ✘ || <- ^ 0 | ::: |
+^ Kontrollbit: 0 ^ Nachricht | -> ^  | OK |
+^ || <- ^ 0 | ::: |
+^ Kontrollbit: 1 ^ Nachricht | -> ^ ✘ | Fehler beim Empfänger \\ => Unerwartetes Kontrollbit zurück senden |
+^ || <- ^ 0 | ::: |
+^ Kontrollbit: 1 ^ Nachricht | -> ^  | Fehler beim Sender |
+^ ✘ || <- ^ 1 | ::: |
+^ Kontrollbit: 1 ^ Nachricht | -> ^  | OK |
+^ || <- ^ 1 | ::: |