Masterarbeit Bioinformatik

Eberhard Karls Universität Tübingen Fakultät für Informations- und Kognitionswissenschaften Wilhelm-Schickard-Institut für Informatik Masterarbeit Bioinformatik Effizientes Preprocessing von Erfüllbarkeitsinstanzen mit Anwendung auf phylogenetische Probleme Christian Zielke 31. Mai 2010 Betreuer Dipl.-Inform. Stephan Kottler Wilhelm-Schickard-Institut für Informatik Universität Tübingen Gutachter Prof. Michael Kaufmann (Informatik) Wilhelm-Schickard-Institut für Informatik Universität Tübingen Dr. Kay Nieselt (Bioinformatik) Wilhelm-Schickard-Institut für Informatik Universität Tübingen

Zielke, Christian: Effizientes Preprocessing von Erfüllbarkeitsinstanzen mit Anwendung auf phylogenetische Probleme Masterarbeit Bioinformatik Eberhard Karls Universität Tübingen Bearbeitungszeitraum: Dezember 2009 - Mai 2010

i Zusammenfassung Diese Masterarbeit präsentiert neben der Entwicklung einer SAT-Kodierung für das aus der Bioinformatik bekannte Problem der Superbaum- Kompatibilität auch die Implementierung eines Preprocessors für anwendungsbasierte SAT-Instanzen. Verschiedene Techniken zum Simplifizieren von Erfüllbarkeitsproblemen werden vorgestellt, implementiert und anhand von zahlreichen Tests bewertet. Durch den Einsatz des von uns entwickelten Preprocessors ist es möglich zahlreiche neue Instanzen zu lösen und somit die Performance von aktuellen SAT- Solvern maßgeblich zu verbessern. Gleichzeitig werden die Ergebnisse für verschiedene Bioinformatik-Instanzen zeigen, dass sowohl bei der Kodierung dieser Probleme als auch bei den Preprocessortechniken noch viel Potential für Verbesserungen besteht.

ii Danksagung Zu erst möchte ich mich bei meinem Betreuer Stephan dafür bedanken, dass er mich so intensiv unterstützt hat und seine Tür für mich immer offen stand. Ohne seinen ständigen Input an neuen Ideen wäre die Arbeit in ihrer jetzigen Form nicht möglich gewesen. In den letzten Monaten durfte ich das angenehme Klima am Arbeitsbereich Paralleles Rechnen genießen und möchte mich deswegen vor allem bei Prof. Michael Kaufmann bedanken, der es mir ermöglicht hat, mich als ein Teil des Teams zu fühlen. Aber auch die restlichen Mitarbeiter möchte ich hier erwähnen. Ich hoffe mit Andi, Markus, Philip, Robert und Stephan auch in Zukunft noch den einen oder anderen Kuchen verspeisen zu können. ;-) Einen herzlichen Dank gilt es auch an Dr. Kay Nieselt zu richten, die es durch Ihre Unterstützung erst ermöglicht hat, dass die Arbeit so angefertigt werden konnte. Wie schnell doch die letzten Jahre vergangen sind... Das lag vor allem auch an der kurzweiligen Zeit mit meinen Kommilitonen, bei denen ich mich hiermit auch recht herzlich bedanken möchte. Erstaunlich, wie sicher wir die Untiefen des Bachelorstudiums umschifft haben, um uns auch im Master trotz der unterschiedlichen Planungen nicht aus den Augen zu verlieren. Zu guter Letzt möchte ich mich hier von ganzem Herzen bei meiner Familie und Freunden bedanken, die mich bei allem stets voll unterstützt haben. Danke!

Inhaltsverzeichnis Abbildungsverzeichnis Tabellenverzeichnis Abkürzungsverzeichnis vii ix xi 1 Einleitung 1 2 Grundlagen 3 2.1 Graphentheorie........................... 3 2.1.1 Graph............................ 3 2.1.2 Zusammenhangskomponente................ 4 2.1.3 Baum............................ 4 2.2 Das Erfüllbarkeitsproblem..................... 5 2.2.1 Aussagenlogik........................ 5 2.2.2 Konjunktive Normalform.................. 6 2.2.3 DIMACS-Format...................... 7 2.3 SAT-Solving............................. 8 2.3.1 Davis-Putnam-Verfahren.................. 9 2.3.2 Aus Konflikten lernen................... 12 2.3.3 Preprocessing........................ 14 3 Preprocessing 17 3.1 Motivation.............................. 18 iii

iv INHALTSVERZEICHNIS 3.2 SatELite............................... 19 3.2.1 Datenstrukturen...................... 19 3.2.2 Unit Propagation...................... 21 3.2.3 Subsumierung........................ 21 3.2.4 Selbst-Subsumierung.................... 22 3.2.5 Variableneliminierung.................... 23 3.2.6 top-level Simplifizierungsmethode............. 24 3.2.7 Veränderungen in der SatELite-Version von 2007.... 26 3.3 Selbst-Subsumierung mit Binärresolution............. 26 3.4 Eliminierung geblockter Klauseln................. 28 3.5 Literals Blocks Distance...................... 30 4 Ergebnisse 33 4.1 Industrielle Instanzen........................ 34 4.1.1 SatELite - Techniken.................... 35 4.1.2 Resolutionskriterium.................... 36 4.1.3 Entfernung geblockter Klauseln.............. 36 4.2 Bioinformatik Instanzen...................... 46 5 Das Superbaum-Kompatibilitätsproblem 49 5.1 Allgemeines zur SAT-Kodierung.................. 49 5.2 Problemdefinition.......................... 50 5.3 Gewurzelte Bäume......................... 53 5.3.1 BUILD-Algorithmus.................... 53 5.3.2 SAT-Kodierung für gewurzelte Bäume.......... 56 5.4 Ungewurzelte Bäume........................ 60 5.4.1 NP-Vollständigkeit..................... 61 5.4.2 SAT-Kodierung für ungewurzelte Bäume......... 62 5.5 Ergebnisse.............................. 75 5.5.1 Instanzgrößen........................ 75

INHALTSVERZEICHNIS v 5.5.2 Biologische Testdatensätze................. 78 5.5.3 Zufallsbäume als Testdatensätze.............. 81 5.5.4 Vergleich mit vorhandenen Implementationen...... 83 5.5.5 Laufzeit und Preprocessoreffektivität........... 84 6 Diskussion und Ausblick 95 6.1 Preprocessor............................. 95 6.2 Superbaum-Kompatibilitätsproblem................ 97 Literaturverzeichnis 99

vi INHALTSVERZEICHNIS

Abbildungsverzeichnis 2.1 DIMACS Format Beispiel..................... 8 2.2 Entscheidungsbaum......................... 11 2.3 Implikationsgraph.......................... 13 4.1 cactus plot verschiedener Implementierungen mit maximaler Berechnungszeit 1200 Sekunden.................. 44 4.2 cactus plot verschiedener Implementierungen mit maximaler Berechnungszeit 10000 Sekunden................. 45 5.1 restringierter ungewurzelter Baum................. 52 5.2 restringierter gewurzelter Baum.................. 52 5.3 Das gewurzelte Tripel ab c..................... 54 5.4 Beispiel clustering Graph...................... 55 5.5 Der von BUILD berechnete Baum T............... 55 5.6 Beispiel Abdeckungsbereiche von Knoten............. 66 5.7 DepictEdge............................. 74 vii

viii ABBILDUNGSVERZEICHNIS

Tabellenverzeichnis 4.1 Anteil an geblockten Klauseln für jede Instanzklasse, aufsteigend sortiert............................. 37 4.2 Ergebnisse Anwendungs-Instanzen................. 39 4.3 Ergebnisse Anwendungs-Instanzen mit SatELite Preprocessortechniken.............................. 39 4.4 Ergebnisse Anwendungs-Instanzen ohne Variableneliminierung. 40 4.5 Ergebnisse Anwendungs-Instanzen ohne Definitionsresolution.. 40 4.6 Ergebnisse Anwendungs-Instanzen mit anderem Resolutionskriterium................................ 41 4.7 Ergebnisse Anwendungs-Instanzen mit Eliminierung geblockter Klauseln............................... 41 4.8 Ergebnisse Anwendungs-Instanzen nach langer Berechnungszeit 42 4.9 Ergebnisse Anwendungs-Instanzen nach langer Berechnungszeit mit SatELite Preprocessortechniken................ 42 4.10 Ergebnisse Anwendungs-Instanzen nach langer Berechnungszeit mit Eliminierung geblockter Klauseln............... 43 4.11 Ergebnisse Anwendungs-Instanzen nach langer Berechnungszeit ohne Definitionsresolution..................... 43 4.12 Ergebnisse Bioinformatik-Instanzen................ 47 4.13 Ergebnisse Bioinformatik-Instanzen nach langer Berechnungszeit 48 5.1 Test des Abdeckungsbereichs.................... 73 5.2 Instanzgrößen für gewurzelte Bäume............... 77 ix

x TABELLENVERZEICHNIS 5.3 Speicherplatzbedarf für gewurzelte Bäume............ 77 5.4 Instanzgrößen für ungewurzelte Bäume.............. 79 5.5 Speicherplatzbedarf für ungewurzelte Bäume........... 79 5.6 Ergebnisse gewurzelte Bäume................... 85 5.7 Laufzeiten gewurzelte Bäume................... 85 5.8 Ergebnisse Verteilung gewurzelte Bäume............. 87 5.9 Ergebnisse Verteilung ungewurzelte Bäume............ 87 5.10 Ergebnisse ungewurzelte Bäume.................. 89 5.11 Laufzeiten ungewurzelte Bäume.................. 89 5.12 Preprocessor Ergebnisse gewurzelte Bäume............ 92 5.13 Preprocessor Effektivität gewurzelte Bäume........... 92 5.14 Preprocessor Ergebnisse ungewurzelte Bäume.......... 93 5.15 Preprocessor Effektivität ungewurzelte Bäume.......... 93

Abkürzungsverzeichnis bzw. ca. CDCL DIMACS DPLL engl. et al. LBD LCA MAX SAT o.b.d.a. SAT vgl. z.b. beziehungsweise circa Conflict Driven Clause Learning Center for Discrete Mathematics and Theoretical Computer Science, Rutgers, New Jersey Davis-Putnam-Logemann-Loveland-Verfahren englisch lateinisch für: und andere Literals Blocks Distance lowest common ancestor maximum satisfiabilty ohne Beschränkung der Allgemeinheit satisfiabilty (engl. für Erfüllbarkeit) vergleiche zum Beispiel xi

xii ABKÜRZUNGSVERZEICHNIS

Kapitel 1 Einleitung In Zeiten von Mobiltelefonen, die neben dem fast schon zu vernachlässigendem Telefonieren auch Fotografieren, Videos aufnehmen und abspielen können, entwickelte sich in den letzten Jahren der Trend möglichst komplexe Berechnungen auf möglichst kleinen und mobilen Geräten durchführen zu lassen. So entstand ein Markt für Anwendungen, die über das Internet verbreitet werden und zum Beispiel aufwändige Routenberechnungen über mehrere Staatsgrenzen hinweg in wenigen Sekunden durchführen. Dadurch kann der Eindruck entstehen, dass heutzutage jedes beliebige Problem grundsätzlich in kurzer Zeit zu lösen ist. In der Informatik gibt es jedoch Fragestellungen, für die es im Moment weder effiziente Lösungmöglichkeiten gibt, noch bekannt ist, ob es überhaupt möglich sein wird diese Probleme durch effiziente Verfahren zu lösen. Zu dieser Gruppe von Problemen gehört auch das Erfüllbarkeits-, bzw. aus dem Englischen von satisfiability abgeleitete SAT-Problem. Es beschreibt die Frage, ob eine boolsche Formel durch die Wahl von Variablenwerten wahr wird. Für Formeln geringer Größe ist die (Un-)Erfüllbarkeit noch per Hand berechenbar. So ist zum Beispiel die UND-Verknüpfung der Aussagen Deutschland steht im WM-Finale 2010, Spanien steht im WM-Finale 2010 und Deutschland wird Weltmeister durchaus erfüllbar, wenn auch aus Sicht der Fußballfans eher Wunschdenken. Eine Formel, die eine Aussage und ihre Verneinung durch ein UND verknüpft, wie z.b. Michael Ballack fährt zur Fußball-WM und Michael Ballack fährt nicht zur Fußball-WM ist jedoch nicht erfüllbar. Im schlechtesten Fall muss man alle Variablenbelegungen testen, um eine Aussage über die Erfüllbarkeit der Formel treffen zu können. Bei n Variablen, die jeweils nur die Werte wahr oder falsch annehmen können, und somit 2 n möglichen Variablenbelegungen führt dies schnell zu einer unpraktikablen Berechnungszeit. Nachdem mit Hilfe des SAT-Problems erstmals die Menge der NP-vollständi- 1

2 KAPITEL 1. EINLEITUNG gen Probleme begründet wurde, galt es lange Zeit ausschließlich als theoretisches Problem. In den letzten Jahren wurden jedoch mehr und mehr Fragestellungen aus der Praxis, deren enorme Komplexität von einem Menschen nicht mehr überschaubar sind, als SAT-Problem dargestellt. Ein Beispiel hierfür ist unter Anderem das Testen von möglichen Automobilkonfigurationen [SKK00]. Im Gegensatz zu zufällig oder von Hand erstellten Probleminstanzen, weisen SAT-Probleme, die reale Anwendungen darstellen eine Struktur [Leh06] auf, die es ermöglicht eine Lösung in einer relativ kurzen Zeit zu finden. Diese Arbeit beschäftigt sich zum Einen mit der Frage, inwiefern diese Strukturen ausgenutzt werden können um die Probleminstanzen bereits vor dem eigentlichen Lösungsprozess in ihrer Größe und ihrem Aufbau zu verändern. Gelingt es eine Vielzahl an redundanten Informationen in der SAT-Instanz zu identifizieren, so kann die Problemgröße und damit auch die Berechnungszeit erheblich verringert werden. Der zweite Schwerpunkt dieser Arbeit liegt in der Entwicklung einer SAT- Kodierung, und damit einer neuen Herangehensweise, für das Superbaum- Kompatibilitätsproblem aus der Bioinformatik. Seit dem Charles Darwin seine Evolutionstheorie im Jahr 1859 veröffentlicht hat beschäftigen sich Wissenschaftler auf der ganzen Welt mit dem Baum des Lebens, der alle evolutionären Verwandtschaftsbeziehungen von den (ehemals) existierenden Arten darstellt. Das Superbaum-Kompatibilitätsproblem hilft bei der Erstellung dieses Baumes, da es für eine Menge an Teilbäumen überprüft, ob die Gesamtheit der in diesen Bäumen vorhandenen Verwandtschaftsbeziehungen alle in einem großen Superbaum dargestellt werden können. An Hand der SAT-Instanzen des Superbaum-Kompatibilitätsproblems und anderer bereits in SAT kodierter Probleme aus der Bioinformatik soll schließlich getestet werden, ob die Techniken zum Vereinfachen von SAT- Problemen auch in gleichem Maß auf Bioinformatik-Instanzen anwendbar sind, oder ob sie über andere Strukturen verfügen, und somit andere Techniken der Simplifizierung erfordern. Die Arbeit gliedert sich dazu wie folgt: Die zum Verständnis des behandelten Themas benötigten Grundlagen werden in Kapitel 2 erarbeitet. Anschließend werden in Kapitel 3 die einzelnen Techniken zum Simplifizieren der SAT- Instanzen vorgestellt und die erzielten Ergebnisse in Kapitel 4 besprochen, bevor die SAT-Kodierung des Superbaum-Kompatibilitätsproblems in Kapitel 5 vorgestellt und an Hand von Datensätzen bewertet wird. Eine Diskussion und ein kurzer Ausblick im Kapitel 6 beschließen die Arbeit.

Kapitel 2 Grundlagen Das folgende Kapitel soll die theoretischen Grundlagen der Masterarbeit kurz vorstellen und einen Überblick über die zu behandelnden Themen geben. Zu Beginn des Kapitels werden allgemeine Definitionen der Graphentheorie wiederholt, um eine Grundlage für spätere Anwendungen und verwendete Techniken beim SAT-Solving und Preprocessing zu schaffen. Danach wird das Erfüllbarkeitsproblem definiert und mit Hilfe des DIMACS- Formates eine Grundlage zur Verarbeitung der Daten geschaffen, bevor Techniken der aktuellen SAT-Solver vorgestellt werden. In diesem Zusammenhang wird am Ende des Kapitels auch kurz auf die Möglichkeit eingegangen, die SAT-Instanzen durch einen sogenannten Preprocessor zu bearbeiten, um die Laufzeit, die für das Lösen der Erfüllbarkeitsprobleme benötigt wird, zu reduzieren und somit eine Motivation für die vorliegende Arbeit zu geben. 2.1 Graphentheorie Wie wir im weiteren Verlauf der Arbeit sehen werden, stellen graphentheoretische Probleme nicht nur mögliche Anwendungsgebiete für Erfüllbarkeitsprobleme dar. Sie spielen auch in der Technik der SAT-Solver und des Preprocessors eine wichtige Rolle. Deshalb werden in diesem Abschnitt einige grundlegende Dinge definiert. Die Definitionen sind auch in verschiedenen theoretischen Werken, z.b. [Bol98], nachzulesen. 2.1.1 Graph Als Graph G = (V, E) wird ein Tupel aus einer Menge von Knoten V (für engl. vertices) und einer Menge Kanten E (für engl. edges) bezeichnet. Dabei beschreibt die Kantenmenge E V V eine Relation zwischen Knoten. Man unterscheidet allgemein zwischen gerichteten und ungerichteten Graphen. Während im Falle eines ungerichteten Graphen die Kante e 1 = (u, v) E von 3

4 KAPITEL 2. GRUNDLAGEN der Kante e 2 = (v, u) E nicht zu unterscheiden ist, spielt die Ordnung des Knotentupels im gerichteten Graphen eine wichtige Rolle. Man bezeichnet dann z.b. für e 1 u als Quelle oder Startknoten und v als Ziel oder Endknoten der Kante. In der gesamten Arbeit werden wir nur einfache Kanten betrachten. Zwei Kanten aus dem Graphen G dürfen somit nicht sowohl die identische Quelle als auch das identische Ziel besitzen. Außerdem sind die in der vorliegenden Arbeit verwendeten Kanten stets ungewichtet. Die Adjazenz zweier Knoten u und v ist dann gegeben, wenn es eine Kante e = (u, v) E gibt. Diese Kante e ist darüber hinaus inzident zu den Knoten u und v. Als Pfad p = (u, v), der von Knoten u V ausgeht und bei dem Knoten v V endet, wird die Menge von Kanten {(u, x 1 ), (x 1, x 2 ),..., (x i 1, x i ), (x i, v)} E mit x i x j i j bezeichnet. Die Länge eines Pfades ist die Anzahl an Kanten, die dieser Pfad abdeckt. Existiert in einem Graphen für jeden Knoten u V kein Pfad p = (u, u) der Länge > 0, so ist dieser Graph azyklisch. 2.1.2 Zusammenhangskomponente Eine Zusammenhangskomponente Z = {v i,..., v j } ist definiert als eine Menge von Knoten für die gilt: v i, v j Z : p 1 = (v i, v j ) p 2 = (v j, v i ). Diese Menge muss maximal sein, also es darf kein Knoten v V \Z existieren, für den Z = Z v ebenfalls eine Zusammenhangskomponente darstellt. Jeder Graph kann in seine disjunkten Zusammenhangskomponenten ZSK = Z 1... Z k zerlegt werden. Die Komponenten bilden dann eine Partition von Knoten, das heißt: Z i, Z j ZSK : Z i Z j = und 1 i k Z i = V. Ist ZSK = 1, so ist der Graph zusammenhängend. Ein gerichteter Graph ist schwach zusammenhängend, falls der dazugehörige ungerichtete Graph (jede gerichtete Kante wird durch eine ungerichtete ersetzt) zusammenhängend ist. 2.1.3 Baum Ist ein Graph (schwach) zusammenhängend und darüberhinaus noch azyklisch, so ist es ein Baum. In den meisten Fällen handelt es sich bei Bäumen um gerichtete Graphen. In diesem Fall nimmt der sogenannte Wurzelknoten r (für engl. root) eine besondere Rolle ein. Er ist der einzige Knoten ohne eingehende Kanten:

2.2. DAS ERFÜLLBARKEITSPROBLEM 5 e = (v i, r) E v i V. Alle anderen Knoten des Graphen können aber von diesem Knoten aus erreicht werden: p = (r, v i ) v i V \ r. Die Länge des Pfades p = (r, v i ) wird gleichzeitig auch als Tiefe des Knotens v i bezeichnet. Die Tiefe des Baumes definiert man infolgedessen als die Länge des längsten möglichen Pfades von der Wurzel zu einem beliebigen anderen Knoten im Baum. Die Knoten, die keine ausgehenden Kanten besitzen, nennt man Blätter. Knoten, die weder Blatt noch Wurzel sind, bezeichnet man als innere Knoten. In Kapitel 5 gehen wir auf phylogenetische Bäume genauer ein. Diese Bäume sind Anwendungen aus der Bioinformatik, mit denen Verwandtschaftsbeziehungen z.b. zwischen einzelnen Spezien, Individuen oder auch Genen dargestellt werden. Es ist also nicht verwunderlich, dass für ein Knotenpaar (u, v) E des Baumes folgende Bezeichnungen üblich sind: Knoten u ist Vorgänger, oder Vater von v und v ist Nachfolger, bzw. Kind von u. Im Spezialfall des binären Baumes besitzt jeder Knoten maximal zwei Kinder. 2.2 Das Erfüllbarkeitsproblem Das Erfüllbarkeitsproblem der Aussagenlogik (SAT, von engl. satisfiability) ist eine wichtige Problemstellung der Theoretischen Informatik, hat aber auch viele praktische Anwendungen, wie z.b. die Ablaufplanung (engl. scheduling) [Sch88], Testen von Software [KM04], künstliche Intelligenz [SK92] und viele weitere [MS08]. Im Folgenden werden einige grundlegende Begriffe definiert. 2.2.1 Aussagenlogik Im menschlichen Sprachgebrauch sind Aussagen Sätze, bei denen entschieden werden kann, ob sie wahr oder falsch sind. Ähnlich funktioniert das auch in der Aussagenlogik. Das Alphabet der Sprache der Aussagenlogik besteht aus folgenden Elementen: Menge der Variablen V die Konstanten true (1) und false (0) die Junktoren Negation ( ), Konjunktion ( ) und Disjunktion ( ) Hilfssymbole, z.b. Klammern

6 KAPITEL 2. GRUNDLAGEN Wir betrachten nur die Junktoren, und, da Implikation ( ), Äquivalenz ( ), Antivalenz ( ) usw. mit Hilfe der drei erstgenannten ausgedrückt werden können. Eine Formel ϕ der Aussagenlogik kann mit Hilfe des Alphabets und folgenden Regeln gebildet werden: 1. Jede Variable v der gegebenen Menge V und jede Konstante ist eine Formel. 2. Wenn α eine Formel ist, so ist auch (α) eine Formel. 3. Wenn α und β jeweils Formeln sind, so sind auch (α β) und (α β) jeweils Formeln. Die eindeutige Zuordnung ψ : v {0, 1}, v V von Variablen zu Wahrheitswerten wird Variablenbelegung genannt. Sei Φ die Menge aller möglichen Formeln. Dann kann mit einer gegebenen Variablenbelegung ψ und der Funktion inter ψ : ϕ {0, 1}, ϕ Φ jede Formel interpretiert (ausgewertet) werden. Die Funktion inter ψ definieren wir rekursiv durch folgende Regeln: inter ψ (v) = ψ(v), falls v V inter ψ (c) = c, falls c Konstante inter ψ ( ϕ) = 1 inter ψ (ϕ), falls ϕ Φ inter ψ (ϕ 1 ϕ 2 ) = min(inter ψ (ϕ 1 ), inter ψ (ϕ 2 )), falls ϕ 1, ϕ 2 Φ inter ψ (ϕ 1 ϕ 2 ) = max(inter ψ (ϕ 1 ), inter ψ (ϕ 2 )), falls ϕ 1, ϕ 2 Φ Eine Variablenbelegung ψ x für eine Formel φ, für die inter ψx (φ) = 1 gilt, heißt Modell. Das Erfüllbarkeitsproblem entscheidet somit für eine gegebene Formel φ, ob sie ein Modell besitzt - also ob sie erfüllbar ist. 2.2.2 Konjunktive Normalform Jede geschlossene Klammerung stellt eine sogenannte Klausel dar. Die einzelnen aussagenlogischen Formeln, die innerhalb einer Klausel durch Disjunktionen oder Konjunktionen miteinander verbunden sind, bezeichnen wir als Terme. Sind alle Terme einer Klausel mittels Disjunktionen verbunden, so ist die Klausel disjunktiv. Dementsprechend ist die Klausel konjunktiv, sofern alle enthaltenen Terme durch Konjunktionen miteinander verbunden sind.

2.2. DAS ERFÜLLBARKEITSPROBLEM 7 Mittels folgender Regeln zur Klammerersparnis lassen sich Formeln vereinfachen: 1. ((α β) γ) = (α β γ) 2. ((α β) γ) = (α β γ) 3. Durch die höhere Priorität der Konjunktion ( ) gegenüber der Disjunktion ( ) ergibt sich ebenfalls: ((α β) γ) = (α β γ) Eine Formel φ ist in konjunktiver Normalform (CNF) genau dann, wenn alle ihre Klauseln C i disjunktiv sind, das heißt C i = (l i1 l i2 l ik ) und die einzelnen Klauseln der Formel konjunktiv miteinander verbunden sind, also φ = C 1 C 2 C n. Literale werden hier durch l ij bezeichnet, wobei ein Literal mit positiver Polarität eine Variable (l pos = var(l) = x) darstellt, und ein Literal mit negativer Polarität die Negation einer Variable (l neg = var(l) = x) symbolisiert. Jede Formel der Aussagenlogik kann in diese Normalform überführt werden [DP60]. Im weiteren Verlauf der Arbeit werden ausschließlich Formeln in konjunktiver Normalform betrachtet. Eine Formel in CNF ist erfüllbar, wenn es eine Variablenbelegung gibt, so dass in jeder Klausel mindestens ein Literal zu true ausgewertet werden kann. Werden mit einer Variablenbelegung ψ partiell nur eine Teilmenge S V Wahrheitswerte zugewiesen, so spricht man von einer partiellen Belegung. Durch diese partielle Belegung entsteht eine Instanz φ ψ partiell des ursprünglichen Problems φ mit V ψ partiell = V \ S und den durch die partielle Belegung nicht erfüllten Klauseln: C ψ partiell i = {l ij var(l ij ) V ψ partiell } : l ij C i mit ψ partiell (l ij ) = 1 Als Unit Klauseln bezüglich einer Variablenzuweisung bezeichnet man Klauseln, für die gilt: C ψ partiell i = 1 2.2.3 DIMACS-Format Die meisten verfügbaren Benchmarks liegen in einem Dateiformat vor, das speziell zur Speicherung von SAT-Instanzen in konjunktiver Normalform für die DIMACS Challenge entwickelt wurde [DIM93]. Die Formatdefinition sieht vor, dass am Anfang der Datei beliebig viele Kommentarzeilen auftreten können. Diese Zeilen müssen mit dem Buchstaben c beginnen. Nach den Kommentarzeilen folgt die Problemzeile. Ihr Format ist

8 KAPITEL 2. GRUNDLAGEN aus vier Elementen aufgebaut: p <Problemfall> <Anzahl an Variablen> <Anzahl an Klauseln>. In unserem Fall ist <Problemfall> immer CNF, die beiden anderen Elemente geben die Anzahl an Variablen bzw. Klauseln der zu bearbeitenden Instanz an. Nach dieser Problemzeile schließen sich die Beschreibungen der einzelnen Klauseln an. Jede Klausel wird durch eine mittels beliebiger whitespaces (Leerzeichen, Tabulator, line feed, etc.) getrennte Liste von Ganzen Zahlen zuzüglich abschließender 0 dargestellt. Jede Ganze Zahl x 0 gibt dabei ein Literal x an, für das gilt: var(x) = x. Ist das Vorzeichen der Zahl x negativ, so hat das Literal negative Polarität, andernfalls positive Polarität. Die Nummerierung der Variablen muss dabei weder bei eins beginnen, noch fortlaufend sein. Ein Beispiel für die Kodierung der Formel φ = (x 1 x 3 ) (x 2 x 3 ) (x 4 ) ist in Abbildung 2.1 dargestellt. c ein kleines Beispiel für eine Kodierung c einer SAT-Instanz im DIMACS-Format p cnf 4 3 1 3 0 2-3 0 4 0 Abbildung 2.1: DIMACS Format Beispiel Die abschließende 0 der letzten aufgeführten Klausel kann laut Definition des Formats auch weggelassen werden. Das EOF terminiert somit sowohl die Datei, als auch die letzte Klausel. 2.3 SAT-Solving Stephen Cook definierte 1971 die Klasse der NP-vollständigen Probleme anhand des satisfiability Problems [Coo71]. Ein Jahr darauf veröffentlichte Richard Karp insgesamt 21 Probleme, z.b. KNAPSACK und CLIQUE, die ebenfalls in dieser Klasse liegen [Kar72] und begründete damit eine Menge von Problemen, über die man bis heute nicht sagen kann, ob es effiziente Verfahren gibt, mit deren Hilfe sich diese schwierigen Probleme lösen lassen.

2.3. SAT-SOLVING 9 2.3.1 Davis-Putnam-Verfahren Bereits über 10 Jahre bevor Stephen Cook die NP-vollständigen Probleme zum ersten Mal beschrieb, wurde von Martin Davis und Hilary Putnam 1960 ein Verfahren entwickelt, mit dem man erstmals die Erfüllbarkeit von SAT- Instanzen in konjunktiver Normalform überprüfen konnte [DP60]. Das Verfahren basiert auf den folgenden drei grundlegenden Regeln: Unit Propagation Seien F, A, B, C Formeln in CNF und a, b, c, p Literale. So gelten folgende Regeln: F = A p B p C F = 0 (2.1) F = p (p a) ( p b c) F = (b c) (2.2) F = p (p a) ( p b c) F = a (2.3) falls F = F = 1 (2.4) Enthält eine Formel F eine Unit Klausel C = (p), so ist F nur erfüllbar, wenn p wahr ist. Aus diesem Grund können alle Klauseln, die p enthalten, aus der Formel entfernt werden. Außerdem können alle Vorkommen des Literals p aus den entsprechenden Klauseln gestrichen werden. Dadurch können neue Unit Klauseln entstehen. Positiv-Negativ-Regel (pure literal rule) Kommt ein Literal p in einer CNF F nur in einer Polarität vor, so bezeichnet man dieses Literal als pure. Der Wahrheitswert der dazugehörgien Variable kann in der entstehenden partiellen Variablenbelegung ψ partiell dann entsprechend der Polarität gesetzt werden. Alle Klauseln, die p enthalten, werden aus der Instanz entfernt (subsumiert). Für die entstandene Instanz F ψ partiell gilt: F ψ partiell = 0 F = 0 (2.5) F ψ partiell = F = 1 (2.6) Regel zum Eliminieren von Literalen (Resolution) Seien F, A, B, C Formeln in CNF und p Literal / A, B, C. So gilt folgende Regel: F = (A p) (B p) C F = 0 ((A B) C) = 0 (2.7) Diese Regel beschreibt die Eliminierung einer Variable p mitsamt aller vorkommenden Literale. Sei α die Menge aller Klauseln der Formel, in der das Literal p vorkommt, β die Menge der Klauseln, in der das Literal p vorkommt und γ die restlichen Klauseln: γ = F \ (α + β).

10 KAPITEL 2. GRUNDLAGEN α p C i α C i ψ p 1 β p C i β C i ψ p 1 Aus der Beobachtung heraus, dass die Klauselmenge α nur erfüllt ist, wenn entweder p = true ist, oder aber die Konjunktion aller Klauseln in α nach Entfernung des Literals p zu true ausgewertet werden kann und analoger Betrachtung für β ergibt sich dann mit der Umbennung der Konjunktionen zu A, bzw. B die Regel 2.7. Die Regeln der Unit Propagation sowie die pure literal rule werden in dieser Form auch heute noch als Propagieren bezeichnet und so lange ausgeführt, bis beide Regeln nicht mehr anwendbar sind. Die benötigte Laufzeit für diese Operationen ist linear abhängig von der Größe der Formel: O( F ) (vgl. [Val00]) mit F = C F C. Die hier beschriebene Resolution kann zu einer exponentiell anwachsenden Anzahl an neuen Klauseln führen, da die durch Regel 2.7 entstandene Formel, um wieder in CNF vorzuliegen, noch ausmultipliziert werden muss. Dieses Speicherplatz- und Laufzeitproblem wurde zwei Jahre später durch den Algorithmus von Davis, Logemann und Loveland [DLL62] verbessert. In der Literatur wird dieses Verfahren daher oftmals als Davis-Putman-Logemann- Loveland-Verfahren, oder kurz DPLL, betitelt. Andere übliche Bezeichnungen sind DLL und Davis-Putnam-Verfahren. Die ursprüngliche dritte Regel wurde durch folgende logisch äquivalente, aber besser zu implementierende ersetzt: Branching (splitting rule) Seien F, A, B, C Formeln in CNF und p Literal / A, B, C. So gilt folgende Regel: F = (A p) (B p) C F = 0 (A C) = 0 und (B C) = 0 (2.8) Mit anderen Worten: Ist p = true, so muss B C gelten, ist p = false, so muss A C erfüllt sein. Mit Hilfe der neuen Regel 2.8 lässt sich nun über einen sogenannten binären Entscheidungsbaum der gesamte Suchraum an Variablenzuweisungen traversieren. Die Kanten des Baumes werden dabei üblicherweise mit der hinzugefügten Variablenbelegung markiert, die Knoten beinhalten die durch Resolution entstandene Formel. Es kann vorkommen, dass mehrere Knoten die gleiche Klauselmenge darstellen. Jeder Knoten repräsentiert dabei aber eine andere partielle Variablenbelegung, die durch Ablaufen des Pfades ausgehend von der Wurzel des Baumes bis zu dem entsprechenden Knoten über die Benennung der Kanten abgelesen werden kann.

2.3. SAT-SOLVING 11 {(a b) (a b) (a b)} a = true a = false {(b)} {(b) (b)} b = true b = false b = true b = false {} {()} {()} {()} Abbildung 2.2: Entscheidungsbaum Ein Modell ist gefunden, wenn in einem Blatt des Entscheidungsbaumes eine leere Formelmenge dargestellt wird. Für das in Abbildung 2.2 angegebene Beispiel F = {(a b) (a b) (a b)} ergibt also die Variablenbelegung, in der jeweils a und b true zugewiesen wird, dass die Formel erfüllbar ist. Eine mögliche Implementierung des DPLL-Algorithmus ist in Algorithmus 1 geschildert. In der dort gezeigten rekursiven Ausführung werden in Zeile 1 die Regeln der Unit Propagation, bzw. pure literal rule, auf die Formel so oft wie möglich angewendet. Wenn dadurch alle Klauseln der Formel entfernt wurden, so ist die Klausel nach Regel 2.6 erfüllbar (SAT). Die Variablenbelegung V bildet dann das Modell. Ist allerdings durch die Propagation eine leere Klausel in der Formel entstanden, so ist die Formel nicht erfüllbar (UNSAT). Tritt keiner der beiden genannten Fälle ein, so wird das Branching angewendet. Es wird eine in der aktuellen Formel ungebundene Variable var gewählt (Algorithmus 1, Zeile 7), auf true gesetzt und die Funktion rekursiv gestartet. Ist die Formel mit dieser und in eventuell weiteren Rekursionsstufen getroffenen Variablenbelegungen erfüllbar, so wird dieses an die nächst höhere Rekursionsstufe weitergegeben. Führt die auf true gesetzte Variable var allerdings zu einem Konflikt, der sich als Rückgabewert UNSAT äußert, so wird var auf false gesetzt und die Funktion rekursiv gestartet. Das Ergebnis dieser Rekursion wird direkt in die nächst höhere Rekursionsstufe zurückgegeben, da alle möglichen Variablenbelegungen für var nun durchgetestet wurden. Der binäre Entscheidungsbaum wird also, sollte vorher kein Modell gefunden werden, vollständig durchlaufen. Für die Wahl einer geeigneten ungebundenen Variable var der Formel gibt es verschiedene Heuristiken, die hier aber nicht vollständig besprochen werden, da sie nicht das zentrale Thema der Arbeit bedienen. Lediglich die Heuristik VSIDS wird in Abschnitt 2.3.2 kurz erläutert.

12 KAPITEL 2. GRUNDLAGEN Algorithmus 1 DPLL(F, V ) Eingabe: Eine Formel F in CNF. Eingabe: Eine (partielle) Variablenbelegung V für v i C F. Ausgabe: SAT oder UNSAT. 1: var belegung = propagiere(f,v) 2: if F = then 3: return SAT 4: else 5: if F enthält C i = then 6: return UNSAT 7: var = wähle ungebundene variable(f,v) 8: V = V (var true) 9: if DPLL(F, V ) == SAT then 10: return SAT 11: else 12: V = V \ (var true) 13: V = V (var false) 14: return DPLL(F, V ) 2.3.2 Aus Konflikten lernen Mit der Entwicklung des SAT-Solvers Chaff wurde im Jahr 2000 eine neuartige Variablenheuristik vorgestellt [MMZ + 01]. Die Technik des VSIDS (Variable State Independent Decaying Sum) bewertet die einzelnen Literale dabei anhand ihrer Häufigkeit in Konflikten. Auch in aktuellen SAT-Solvern wie MiniSAT [ES03] wird die im folgenden kurz vorgestellte Idee noch verfolgt: Jedes Literal verfügt über einen Aktivitätszähler. Dieser ist zu Beginn des SAT-Solvings auf 0 initialisiert. Führt eine partielle Variablenbelegung zu einem Konflikt, so wird der Zähler für alle Literale, die an dieser Belegung teilhaben, um 1 erhöht. Nähere Erläuterungen zum Entstehen und Entdecken von Konflikten folgen im Anschluss. Die Variable des Literals mit der höchsten Aktivität wird als Entscheidungsvariable gewählt. Nach einer festen Anzahl an Iterationen werden alle Aktivitäten mit einer Konstanten c < 1 multipliziert, um späteren Konflikten eine höhere Gewichtung bei Berechnung der Aktivität zu gewähren. Durch diese Wahl der Entscheidungsvariable konnte vor allem für nicht erfüllbare Instanzen ein großer Laufzeitgewinn erzielt werden. (vgl. [MFM04])

2.3. SAT-SOLVING 13 Die Idee, aus auftretenden Konflikten während des SAT-Solvings zu lernen, wurde schon durch die Entwicklung von CDCL (conflict driven clause learning) bekräftigt. Der SAT-Solver GRASP[MSS99], entwickelt von Marques-Silva und Sakallah, setzte als einer der ersten das Generieren von Konfliktklauseln ein, um die während des Lösungsprozesses gewonnenen Informationen wiederverwenden zu können. Die dieser Technik zugrundeliegende Idee soll im Folgenden kurz erläutert werden. Um aus Konflikten lernen zu können müssen diese, das liegt in der Natur der Sache, zunächst entdeckt werden. Eine typische Strategie zur Erkennung dieser durch partielle Variablenbelegungen auftretenden Konflikte verwendet einen Implikationsgraphen. Mit Hilfe des Beispiels aus Abbildung 2.3 soll die Idee kurz vorgestellt werden. x 1 0@1 x 3 0@2 C 5 C 2 C 4 C1 x 5 0@1 C 2 C 4 x 2 1@2 C 3 x 4 1@2 x 6 0@2 x 4 0@2 Abbildung 2.3: Implikationsgraph Betrachten wir die Formel F, welche unter anderem folgende Klauseln enthält: C 1 = (x 3 x 4 ) C 2 = (x 2 x 3 x 5 ) C 3 = (x 4 x 6 ) C 4 = (x 2 x 3 x 6 ) C 5 = (x 1 x 5 ) Im bisherigen Lösungsprozess wurde auf der ersten Entscheidungsebene x 1 false zugewiesen. Diese Zuweisung in Verbindung mit der Klausel C 5 = (x 1 x 5 ) ergibt, dass x 5 somit ebenfalls auf false gesetzt werden muss, damit die Klausel C 5 erfüllt wird. Es entsteht eine direkte Implikation auf der ersten Entscheidungsebene, die auch im Graphen aus Abbildung 2.3 zu sehen ist. Jeder Knoten stellt eine Variablenzuweisung dar. Während die Ziffer nach dem @ in der Bezeichnung des Knotens der Entscheidungsebene entspricht, geben die eingehenden Kanten des Knotens die Ursache für die Belegung an:

14 KAPITEL 2. GRUNDLAGEN Variablenzuweisungen, die Quellknoten der Kanten, und daraus resultierende Unit Klausel als Beschriftung der eingehenden Kanten. Eventuelle weitere Variablenzuweisungen der ersten Entscheidungsebene sind in diesem Teilgraph nicht dargestellt. Mit der Zuweisung x 3 = false auf Entscheidungsebene 2 folgt dann direkt mit Klausel C 1, dass x 4 = false, mit Klausel C 2 und der Variablenbelegung aus Entscheidungsebene 1 ergibt sich x 2 = true. Über eine direkte Implikation, begründet durch Klausel C 4, ergibt sich x 6 = false, womit sich wiederum mit Klausel C 3 ergibt, dass x 4 = true. Da x 4 aber bereits false sein soll, ist an dieser Stelle ein Konflikt aufgetreten. Aus dieser Beobachtung heraus wissen wir nun, dass die Variablenbelegung x 1 = false und x 3 = false nie in einem Modell auftreten kann, und fügen deshalb die Klausel C neu = (x 1 x 3 ) in die Formel ein. Dadurch wird gefordert, dass mindestens eine der beiden Variablen mit true belegt werden muss, und haben die Information des Konfliktes gelernt. In einem anderen Teil des Suchbaumes wird diese partielle Variablenbelegung, da sie zu keinem Modell führen kann, frühzeitig verhindert. An welcher Stelle des Entscheidungsbaums nach Auftreten des Konflikts die Berechnung weitergeführt werden soll, wird mittels Backtracking, bzw. Backjumping entschieden. Da diese Techniken allerdings im weiteren Verlauf der Arbeit keine Rolle spielen, gehen wir hier nicht weiter darauf ein. 2.3.3 Preprocessing Wie wir im weiteren Verlauf der Arbeit sehen werden, kann man nur durch Betrachten der Instanzgröße keine Aussage darüber treffen, wie lange der SAT- Solver benötigen wird, um eine Lösung zu finden. Wir werden Instanzen kennenlernen, die mit wenigen 10.000 Klauseln auch nach über zweieinhalb Stunden nicht gelöst werden können. Andere Instanzen wiederum, die mehrere Millionen Klauseln umfassen, können in weniger als 1 Minute gelöst werden. Nimmt man allerdings die Instanzgröße als Maßstab innerhalb einer festen Problemklasse, so kann man auf Grund der gleichen Kodierung davon ausgehen, dass Instanzen mit einer höheren Klauselanzahl eine längere Laufzeit zur Berechnung der Erfüllbarkeit in Anspruch nehmen werden. SAT-Instanzen, die Anwendungsprobleme aus der realen Welt darstellen, enthalten oftmals redundante Informationen, wodurch die Formelgröße anwächst, ohne dass zusätzliche Information in den zusätzlichen Klauseln kodiert ist. Mit Hilfe von so genannten Preprocessors, die vor dem eigentlichen SAT-Solving ausgeführt werden, wird versucht, die Formelgröße durch verschiedene Techniken zu reduzieren und somit die Laufzeit des SAT-Solvers zu verkürzen. Grundlegende Techniken, auf die wir in Kapitel 3 noch genauer eingehen, sind neben dem schon erwähnten Propagieren das von Subbarayan und Pradhan

2.3. SAT-SOLVING 15 entwickelte NiVER [SP04] (non increasing variable elimination resolution) aber auch sämtliche Techniken des in MiniSAT integrierten Präprozessors SatELite [EB05]. Beim Entwickeln neuer Techniken muss dabei immer auf eine Ausgewogenheit von Aufwand und Nutzen geachtet werden. Die cleverste Idee nutzt nichts, wenn der Mehraufwand des Präprozessors die während des SAT-solvens gesparte Zeit (um ein vielfaches) übersteigt. Im Optimalfall benötigt der Präprozessor nur wenige Sekunden, verringert die Anzahl in der Formel enthaltener Klauseln um einen erheblichen Anteil von 25 % oder mehr, damit am Ende eine signifikante Verbesserung der Gesamtlaufzeit erreicht werden kann.

16 KAPITEL 2. GRUNDLAGEN

Kapitel 3 Preprocessing Ein typischer Lösungsansatz eines Erfüllbarkeitsproblems besteht aus folgenden drei Schritten: 1. SAT-Kodierung Das Problem muss in eine bestimmte Form der Aussagenlogik gebracht werden. Diese Form ist oft die konjunktive Normalform. Erfüllt eine Variablenbelegung eine Formel in CNF, so muss mindestens ein Literal jeder Klausel zu true ausgewertet werden. 2. Preprocessing Durch die Anwendung bestimmter Techniken soll die zu bearbeitende Formel vereinfacht werden, damit der anschließende Schritt zur Lösungsfindung eine geringere Zeit in Anspruch nimmt. 3. SAT-Solving Mittels CDCL, lokaler Suche oder look ahead-techniken wird für die gegebene Formel der Aussagenlogik eine erfüllende Belegung gefunden. CDCL und die look ahead Techniken können auch beweisen, dass eine solche Belegung nicht existiert. Wir beschränken uns in dieser Arbeit darauf, die ersten beiden Schritte des Lösungsansatzes zu behandeln. Bevor eine von uns neu entwickelte SAT- Kodierung in Kapitel 5 vorgestellt wird, thematisieren wir zunächst einige Techniken des Preprocessing. Als Grundlage für unsere Arbeit verwenden wir den in dem SAT-Solver Mini- SAT [ES03] integrierten Preprocessor SatELite [EB05]. Nachdem die von ihm implementierten Techniken erläutert wurden, erweitern wir den Preprocessor und analysieren die Effektivität der einzelnen Techniken in verschiedenen Kombinationen. 17

18 KAPITEL 3. PREPROCESSING 3.1 Motivation SAT-Instanzen, die Probleme aus der realen Welt kodieren weisen oftmals andere Strukturen als zufällig oder von Hand erstellte Instanzen auf. Solche Strukturen können unter Anderem Backbones [DD01], Backdoors [WGS03], Äquivalenzen [Lib02] oder funktionale Abhängigkeiten [LJHM07] sein. Im Allgemeinen scheinen viele SAT-Instanzen redundante Informationen zu besitzen. Diese Klauseln können ohne Einfluss auf die Erfüllbarkeit der Instanz entfernt werden. Es entstehen erfüllbarkeitsäquivalente Probleme, die aber möglicherweise einfacher zu lösen sind. Da der Test auf Vorhandensein redundanter Information ebenfalls NP-vollständig ist [Lib02], können entsprechende Techniken nur unvollständig sein, wenn sie in Polynomzeit berechenbar sind. Obwohl man davon ausgeht, dass das Entfernen redundanter Information zu einer Verbesserung der Laufzeit führt, gibt es Fälle (vergleiche [WS02][KRA + 01]), bei denen solche Informationen dem SAT-Solver bei der lokalen Suche helfen aus lokalen Minima zu entkommen. Die Erstellung von SAT-Instanzen in konjunktiver Normalform erfolgt oft durch Umwandlung von aussagenlogischen Formeln, die in einer anderen Form vorliegen. Um dabei das mögliche exponentielle Wachstum der Formel durch Anwenden des Distributivgesetzes zu vermeiden, entwickelte Tseitin 1968 [Tse68] die nach ihm benannte Transformation einer beliebigen Formel der Aussagenlogik in konjunktive Normalform. Die Idee der Tseitin-Transformation ist, für jede Subformel eine neue Variable einzufügen, die den Wahrheitswert dieser Subformel darstellt. Mittels Axiomen wird die korrekte Variablenbelegung der neuen Variable sichergestellt. Beispiele für neu eingefügte Variablen x und assoziierte Subformeln sind: Negation Disjunktion Konjunktion x y (x y) (y x) (x y) (x y) x (y z) (y x) (z x) (x (y z)) (y x) (z x) (x y z) x (y z) (x y) (x z) ((y z) x) (x y) (x z) ((y z) x) (x y) (x z) (y z x)

3.2. SATELITE 19 Durch Anwenden der Transformation wird das möglicherweise exponentielle Wachstum der Formel auf Kosten neuer Variablen vermieden. Das Ergebnis der Transformation, eine Formel in CNF, ist erfüllbarkeitsäquivalent zur Ausgangsformel. Durch die zusätzlichen Variablen ist die neue Formel aber nicht äquivalent zur Ausgangsformel. Die hinzugefügten Variablen vergrößern den von dem SAT-Solver zu testenden Suchraum und beeinflussen damit auch die Laufzeit. 3.2 SatELite Der Preprocessor SatELite wurde 2005 von Niklas Éen und Armin Biere entwickelt [EB05]. Neben der Verwendung bereits bestehender Techniken, z.b. von NiVER [SP04] und [Bie04], entwickelten die Autoren neue Möglichkeiten zur Simplifizierung von SAT-Instanzen. Im Folgenden sollen nun die umgesetzten Ideen und Implementierungen von SatELite vorgestellt und erläutert werden. Als Grundlage wählen wir hier die Implementierung aus dem Jahr 2005, da dort die in [EB05] veröffentlichten Techniken komplett vorhanden sind. Die Veränderungen in späteren Versionen des Preprocessors werden am Ende des Abschnitts behandelt. 3.2.1 Datenstrukturen Auf eine genaue Beschreibung der zugrundeliegenden Klassenstruktur soll hier verzichtet und lediglich die für die folgenden Betrachtungen benutzten Eigenschaften vorgestellt werden: Jede Variable und die dazugehörigen Literale bekommen eine eindeutige ID > 0. Die ID eines Literals l berechnet sich als ID der dazugehörigen Variable * 2. Sollte das Literal negativer Polarität sein, wird die ID zusätzlich noch um 1 inkrementiert. Wir führen außerdem noch für jede Klausel der Formel eine eindeutige ID > 0 ein. Wird eine Klausel während der Berechnung des Preprocessors aus der Formel entfernt, wird die ID auf 0 gesetzt. Inaktive Klauseln können so anhand ihrer ID identifiziert werden. Weitere Strukturen, die von SatELite verwendet werden und die effiziente Implementierung der Simplifizierungsmethoden ermöglichen, sind: Signatur Die Signatur abstrahiert die in einer Klausel vorkommenden Literale über eine Hash-Funktion h, die jedem Literal eine natürliche Zahl zuweist.

20 KAPITEL 3. PREPROCESSING Der Bereich der Zielwerte der Hash-Funktion hängt von der verwendeten Architektur ab. Da wir eine 32 Bit-Signatur benutzen, werden die Literale auf die Zahlen [0... 31] abgebildet. Die Signatur einer Klausel C i = (l j,..., l k ) wird dann als bitweises OR von 2 h(lx) l x C i berechnet. Da jedes Literal über eine eindeutige ID verfügt, benutzen wir als Hash-Funktion h(l) = l.id % 32. Occurrence-Listen Für jedes Literal l speichern wir Referenzen auf Klauseln C i der zu bearbeitenden Formel F für die gilt: l C i C i F. Listen, die auf veränderte Elemente der Formel verweisen Die einzelnen Simplifizierungsmethoden, die miteinander interagieren, sollen solange ausgeführt werden, bis keine weiteren Veränderungen der Formel auftreten. Die Interaktion der Simplifizierungsmethoden führt dazu, dass nachdem eine Klausel aus der Formel gelöscht wurde, nun eventuell die Variableneliminierung oder andere Simplifizierungen anwendbar sind. Aus diesem Grund werden in verschiedenen Listen die in der Formel veränderten Klauseln und Variablen gespeichert, um den Suchraum in der nächsten Iteration an Simplifizierungen nur auf die veränderten Bereiche der Formel einzuschränken. Unveränderte Bereiche der Formel können, da sie zuvor schon getestet wurden, nicht weiter vereinfacht werden und müssen daher in der nächsten Iteration der Simplifizierungen nicht betrachtet werden. Touched-Menge (Menge von Variablen) Eine Variable wird zu dieser Menge hinzugefügt, wenn sie sich in einer Klausel befindet, die durch den Preprocessor gelöscht, hinzugefügt oder gestärkt wurde. Zu Beginn der Simplifizierung sind alle Variablen der Formel in dieser Menge vorhanden. Added-Menge (Menge von Klauseln) Wenn eine Klausel durch Eliminierung einer Variablen in die Formel eingefügt wurde, so wird sie zu dieser Menge hinzugefügt. Zu Beginn der Simplifizierung werden alle Klauseln als added aufgefasst. Strengthened-Menge (Menge von Klauseln) Wird ein Literal aus einer Klausel entfernt (z.b. durch Unit Propagation), so wird die Klausel in die Menge eingefügt. Zu Beginn der ersten Iteration ist diese Menge leer. Sind alle diese Mengen leer, so sind in der vergangenen Iteration keine weiteren Veränderungen an der Formel vorgenommen worden. Die Simplifizierung wird abgebrochen.

3.2. SATELITE 21 3.2.2 Unit Propagation Während des Preprocessing wird nur die sogenannte top-level Unit Propagation durchgeführt. Das heißt, sollte im Verlauf der Vereinfacherungen eine Klausel C i der Formel nur noch ein Literal l aufweisen, so wird dieses auf den Wahrheitswert gesetzt, der die Klausel C i erfüllt. Die Formel wird dann wie in Abschnitt 2.3.1 vorgestellt entsprechend bearbeitet. 3.2.3 Subsumierung Durch Anwendung der noch einzuführenden Clause Distribution während der Variableneliminierung entstehen viele subsumierte Klauseln [Bie04]. Eine Klausel C 1 subsumiert eine Klausel C 2 falls C 1 C 2. Die subsumierte Klausel C 2 ist redundant und kann aus der SAT-Instanz entfernt werden. Die in Algorithmus 2 dargestellte Methode identifiziert die von C subsumierten Klauseln. Algorithmus 2 Bestimmung der von C subsumierten Klauseln Eingabe: C - eine Klausel F. Ausgabe: result - Menge der von C subsumierten Klauseln. 1: Literal l = Literal aus C mit kürzester Occurrence-Liste 2: for all C occur(l) do 3: if C.id C.id then 4: if C <= C then 5: if (C.signature & C.signature) = 0 then 6: if C C then 7: result += C ; 8: return result Die verschiedenen IF-Abfragen filtern nach und nach Klauseln heraus, die nicht subsumiert werden können. In Zeile 4 werden die Klauseln C herausgefiltert, die kleiner sind als C. Da C aber eine Teilmenge von C sein muss, gilt auch C C. In Zeile 5 benutzen wir das bitweise UND, dargestellt durch &, sowie die bitweise Negation, dargestellt durch. Anhand der Signaturen werden hier die Klauseln C herausgefiltert, die nicht von C subsumiert sein können. Angenommen, die in der Klausel C enthaltenen Literale besitzen die IDs {1, 6, 10} und seien {3, 6, 10} die IDs der Literale C. Sei ferner die Signatur eine 8 Bit- Zahl für die in einer Klausel C enthaltenen Literale, gebildet durch bitweises OR von 2 l.id%8 l C. Dann ergibt sich: C.signature: 01000110 C.signature: 01001100

22 KAPITEL 3. PREPROCESSING Der Test aus Zeile 5 liefert somit false, wenn es ein Bit in der Signatur von C gibt, dass nicht in der Signatur von C gesetzt ist. Die Klausel C besitzt dann ein Literal, dessen Hash-Wert mit keinem Literal aus der Klausel C übereinstimmt. Somit kann C keine Teilmenge von C sein, und wir können uns den in Zeile 6 angewandten Test auf Teilmengeneigenschaft sparen. Dieser Test auf Teilmengeneigenschaft überprüft, ob jedes Literal l C auch in C vorkommt. Sollte dies für ein Literal l i nicht eintreten, so kann zu diesem Zeitpunkt false zurückgegeben werden. Um diesen aufwendigen Test in möglichst kurzer Zeit durchführen zu können, haben wir uns dazu entschlossen alle Literale einer Klausel gemäß ihrer ID aufsteigend zu sortieren. Der Test benötigt so die Laufzeit O(n + m) mit n = C und m = C. 3.2.4 Selbst-Subsumierung Eine weitere Beobachtung der Autoren von SatELite war, dass folgender Fall oft eintrat: Eine Klausel C 1 subsumiert beinahe die Klausel C 2, mit der Ausnahme, dass ein Literal aus C 1 in der anderen Polarität in C 2 vorkommt. Sei zum Beispiel C 1 = (x, a, b) und C 2 = (x, a), so würde die Resolution von x die Klausel C 1 = (a, b) ergeben. Diese Klausel subsumiert C 1. Man könnte also nachdem man C 1 zur Formel hinzugefügt hat C 1 löschen, bzw. das Literal x aus C 1 entfernen. Wir sagen C 1 wird gestärkt durch Selbst-Subsumierung unter Verwendung von C 2. Der Algorithmus 3 setzt diese Idee um. Algorithmus 3 Identifikation der von C mittels Selbst-Subsumierung zu stärkenden Klauseln Eingabe: C - eine Klausel F. 1: for all Literal l C do 2: C.flipLiteral(l); 3: sub = findsubsumed(c); 4: for all C sub do 5: C = C \ l; 6: C.flipLiteralBack(l); In Zeile 2 wird die Klausel einschließlich ihrer Signatur so verändert, dass anstatt dem Literal l nun l in der Klausel C vorkommt. Dieser Schritt wird in Zeile 6 wieder rückgängig gemacht, um die Ausgangssituation wiederherzustellen. Die durch die veränderte Klausel C subsumierten Klauseln sub werden in Zeile 5 gestärkt. Das geflippte Literal l wird aus allen in der Menge sub enthaltenen Klauseln C entfernt.

3.2. SATELITE 23 3.2.5 Variableneliminierung Die Variableneliminierung erfolgt in SatELite entweder durch Resolution, wie in NiVER [SP04] beschrieben, oder mit Hilfe einer Methode, die sogenannte Definitionen von Variablen entdeckt. Resolution Seien C 1 = {x, a 1, a 2,..., a n } und C 2 = {x, b 1, b 2,..., b m } zwei Klauseln. Die implizierte Klausel C = {a 1, a 2,..., a n, b 1, b 2,... b, } ist das Ergebnis der Resolution der Klauseln C 1 und C 2 mit Hilfe der Variable x. Wir schreiben C = C 1 C 2. Diese Definition kann auch auf eine Menge von Klauseln erweitert werden: Sei S x die Menge an Klauseln, die das Literal x enthalten und S x entsprechend die Klauseln, die das Literal x enthalten. Dann ist S x S x definiert als S x S x = {C 1 C 2 C 1 S x, C 2 S x } Das Anwenden der Resolution auf alle Klauseln von S x und S x ermöglicht es uns, die Variable x für den weiteren Verlauf der Berechnung zu eliminieren. So werden S x + S x Klauseln aus der Formel entfernt, gleichzeitig aber auch S x S x neue Klauseln erstellt. In vielen Fällen ist ein Großteil der neuen Klauseln redundant. Diese Klauseln können dann aus der Menge der hinzuzufügenden Klauseln entfernt werden. NiVER führt die Resolution einer bestimmten Variable dann durch, wenn die entstehende Formel in der Summe kleiner ist als vorher. Die Anzahl an Literalen in den neuen Klauseln muss also der Anzahl an Literalen in S x S x sein. In dem Preprocessor SatELite wird dieses Kriterium ein wenig abgeändert. Sollte die Anzahl an erstellten Klauseln geringer sein als S x + S x, so wird die Resolution der Variablen x durchgeführt. In unserer Implementierung testen wir darüberhinaus welche Ergebnisse erzielt werden, falls die Resolution der Variable x dann durchgeführt wird, wenn die durschnittliche Klauselgröße von S x S x nicht größer ist als in S x S x. Die Gesamtanzahl an Klauseln kann in der Formel zunehmen, aber es werden nur kleine Klauseln hinzugefügt. Mit dem Wissen, dass das Erfüllbarkeitsproblem in polynomieller Zeit lösbar ist, wenn alle Klauseln der Formel maximal zwei Literale besitzen, erhoffen wir uns durch dieses Kriterium eine verkürzte Laufzeit des Lösungsprozesses. Eine weitere Möglichkeit der Variableneliminierung wurde von SatELite auf Grund des Wissens entwickelt, dass durch die Verwendung der Tseitin-