Practicumopgave 3: SAT-solver

Transcriptie

1 Practicumopgave 3: SAT-solver Modelleren en Programmeren 2015/2016 Deadline: donderdag 7 januari 2016, 23:59 Introductie In het vak Inleiding Logica is onder andere de propositielogica behandeld. Veel problemen en vraagstukken kunnen als formule in propositielogica worden uitgedrukt, waardoor het beantwoorden van het vraagstuk is gereduceerd tot de vraag of de formule vervulbaar is (en zo ja, onder welke valuatie). Een voorbeeld daarvan is het oplossen van een sudoku. In deze opgave gaan jullie formules uit de propositielogica representeren en een SAT-solver schrijven die bovenstaande vraag oplost. De invoer van een SAT-solver is dus een formule, en de uitvoer is het antwoord op de vraag of de formule vervulbaar is, en indien ja een valuatie die de formule waar maakt. Als er meerdere valuaties zijn die de formule waar maken, bijvoorbeeld omdat de formule een tautologie is, mag een SAT-solver een willekeurige valuatie geven. Uiteindelijk zullen jullie deze gebruiken om een sudoku op te lossen met jullie eigen SAT-solver! We gaan in deze opgave kijken naar formules met 3 connectieven: negatie (niet), conjunctie (en) en disjunctie (of). Omdat de standaard tekenset waar we mee werken de gebruikelijke symbolen niet bevat, gebruiken we - (minteken) voor negatie, /\ (slash en backslash) voor conjuctie en \/ (backslash en slash) voor disjunctie. Ook schrijven we rond elke formule met een disjunctie of conjuctie haakjes. Een voorbeeld van zo n formule is: (p /\ (-p \/ -q)) In woorden zouden we dit uitspreken als p en (korte stilte) niet p of niet q. Deze formule is waar onder de valuatie waarbij p waar is en q onwaar is. Startpakket Om te beginnen krijg je een deel van de code erbij, dit bestaat uit de volgende bestanden. Parser.java: Helper klasse om vanuit een String of bestand een formuleobject te maken. De code is nog net niet helemaal af en zal in opdracht 2 compleet gemaakt moeten worden zodat deze werkt. 1

2 Valuatie.java: Klasse om een valuatie als object te representeren. De implementatie hoef je verder niet te begrijpen, maar het is wel belangrijk om goed te kijken welke methoden deze klasse heeft en waar die voor gebruikt kunnen worden. Sudoku.java: Code om de formules te genereren voor onze SAT-solver vanuit sudoku s, aangepast naar het formaat dat wij gebruiken, zodat we deze kunnen gebruiken als invoer. LegeSudoku.txt: Formule voor de lege sudoku. MakkelijkeSudoku.txt: Formule voor een vrij makkelijke sudoku, die aan het einde van de opdracht door je code opgelost zou moeten kunnen worden. MoeilijkeSudoku.txt: Formule voor de een moeilijke sudoku die we met de standaard opdrachten uit deze opgave niet (snel) kunnen oplossen (maar misschien met de bonus wel). Opdrachten Lees eerst de gehele opgave goed door zodat je een overzicht hebt van wat er verwacht wordt. Maak daarna de volgende opdrachten en voeg een main toe om te testen of het allemaal nog werkt. Als je (tijdelijk) vastloopt zouden de opdrachten 2, 3 en 4 eventueel andere volgorde gemaakt kunnen worden omdat ze niet van elkaar afhangen 1. Representatie Als eerste zul je code moeten toevoegen om formules te representeren. Deze bestaat om te beginnen uit een interface Formule, waar je later methoden aan toe kunt voegen maar die je nu nog even leeg kunt laten. Voeg klassen toe om de verschillende formules als object te kunnen representeren en zorg dat deze de Formule interface implementeren. Denk goed na over de velden die elke klasse moet hebben; een conjuctie bestaat bijvoorbeeld uit twee andere formules. En wat is de meest simpele formule die je kunt bedenken? Ook daarvoor zul je een losse klasse moeten hebben. Zorg ook dat je klassen handige constructors hebben om nieuwe instanties aan te kunnen maken. Vul dan in de main de code in om een representatie van de voorbeeldformule te maken. Als je de constructors en klassenamen handig hebt gekozen zou dit niet zo moeilijk moeten zijn! Voeg ook een tostring-methode toe om je formule weer naar een String om te zetten, en zorg dat de uitvoer exact gelijk is aan het voorbeeld. 2. Parser Maak de Parser implementatie compleet door de vier methoden onderaan in te vullen. Als dit gedaan is hoef je niet meer handmatig de representatie voor elke formule te programmeren maar kun je deze automatisch door de Parser laten genereren. Dit is wel zo makkelijk, 2

3 zeker voor grotere formules. Je kunt deze testen door een van de gegeven tekst-bestanden te parsen en de verkregen formule naar het scherm te printen. Dit is een hele grote formule, maar als dit succesvol is dan is de code waarschijnlijk correct! 3. Variabelen verzamelen De aanpak die we nemen om uiteindelijk een valuatie te vinden, komt neer op het een voor een proberen van waardes voor de variabelen. Om dit voor elkaar te krijgen zullen we eerst van een gegeven formule moeten uitvinden welke variabelen er eigenlijk in zitten. Voeg een methode verzamel toe aan de Formule interface, die als argument een TreeSet<String> neemt. Deze methode heeft geen resultaat, maar voegt alle variabelen uit de formule toe aan de gegeven set. Omdat het argument een object is wordt call-by-reference gebruikt en heeft het toevoegen van een variabele aan die set dus gevolgen buiten de functie. Hierdoor zullen, als het goed is, na aanroep van deze methode alle variabelen die formule voorkomen aan de set zijn toegevoegd. Maar door het gebruik van TreeSet zit elk er precies één keer, wat we graag willen. Voeg ook code toe aan de main om dit te testen. Je zult dan dus eerst een nieuwe TreeSet<String> moeten aanmaken, dan de verzamel-methode moeten aanroepen met de set als argument (voor een bepaalde formule), en dan de elementen in de set moeten printen. Je kunt dan zelf controleren of alle variabelen uit de formule inderdaad voorkomen. 4. Kan formule waar/onwaar zijn Een slimme truc die we toepassen om straks snel een valuatie te kunnen vinden die de formule waar maakt is om tussendoor een controle te doen waarmee we, in sommige gevallen, met zekerheid kunnen vaststellen dat we op een dood spoor zitten. In andere woorden, als we in een geval zitten waarin we nog niet voor alle variabelen een waarde hebben gekozen, kan het zijn dat we zeker weten dat we de formule nooit meer vervullen, en dus heeft het dan ook geen zin meer om nog waarden voor de rest van de variabelen te proberen; we zullen onze eerdere keuzes moeten herzien. Als voorbeeld, voor de formule uit de introductie weten we bijvoorbeeld zeker dat als we p als onwaar kiezen de formule nooit meer waar kan zijn, ongeacht de waarde van q. Dit weten we doordat een conjunctie alleen waar kan zijn als beide kanten waar zijn, en de linkerkant (de formule p) kan nooit meer waar zijn. Maar het is een benadering (om het simpel te houden): als deze methode waar teruggeeft betekent dat niet per se dat de formule vervulbaar is. Bijvoorbeeld als we voor de formule uit de introductie testen voor q is waar, dan kan zowel de linkerkant van de conjunctie waar zijn (wanneer p waar is) als de rechterkant (wanneer p onwaar is), dus we zeggen dat de formule nog waar kan zijn, terwijl voor geen van de opties voor p de formule waar is. Voeg twee methoden toe aan de Formule interface die controleert of een formule nog waar (respectievelijk onwaar) zou kunnen zijn, en implementeer deze voor alle klassen die Formule implementeren. Voor variabelen 3

4 hangt deze waarde dus af van de valuatie; als de variabele in de valuatie voorkomt weten we zeker of de formule waar (onwaar) kan zijn, en zo niet kunnen beide opties nog. Voor elk van de drie connectieven hangt deze waarde af van het resultaat van deze methoden van de formule(s) waaruit deze is opgebouwd. 5. SAT-solver Deze opdracht, die de kern is van de hele opgave, gaat erom om met behulp van de eerdere opdrachten een valuatie te vinden die de gegeven formule waar maakt, oftewel de SAT-solving. Het idee is dat we met behulp van recursie alle mogelijkheden afgaan: we proberen voor elke variabele true en false en gaan zo alle mogelijkheden af. Er zijn alleen heel erg veel mogelijkheden: in een formule met n verschillende variabelen zijn er 2 n mogelijkheden. Dat is voor een formule met maar 10 verschillende variabelen al meer dan 1000 mogelijkheden! Om te zorgen dat onze code niet alle mogelijkheden hoeft te proberen gebruiken we de slimme truc uit opdracht 4. Elke keer als we een waarde voor een variabele kiezen controleren we of de formule in principe nog vervuld zou kunnen worden. Zo niet, dan weten we dat de keuzes die we tot nu toe gemaakt hebben in combinatie nooit een oplossing gaan opleveren, en dus hoeven we alle combinaties van waarden die we nog niet gekozen hebben niet meer te proberen. Dit kan een heel groot verschil maken! Het algoritme dat we gebruiken voor de SAT-solving wordt hieronder beschreven. We beginnen met eerst één keer alle variabelen te verzamelen, en daarna recursief voor elke variabele beide opties te proberen en door te gaan, net zo lang tot we voor elke variabele een keuze hebben gemaakt en de formule nog steeds vervulbaar kan zijn. Het mooie van de code uit opdracht 4 is dat in het geval dat de valuatie wel alle variabelen bevat, dat de methode voor die valuatie de waarheidswaarde oplevert. In dat geval hebben we dus een oplossing gevonden. Programmeer dit als volgt, informeel beschreven in wat ook wel pseudocode wordt genoemd: vervulbaar(f): vars = alle variabelen uit f return vervulbaarrecursief(f, vars, lege valuatie) vervulbaarrecursief(f, vars, val): if(vars is leeg): // Dit is een oplossing return val var = kies variabele uit vars verwijder var uit vars // Probeer var = true 4

5 voeg var = true toe aan val if(f kan nog waar zijn voor val): resultaat = vervulbaarrecursief(f, vars, val) if(resultaat!= null): return resultaat verwijder var uit val // Probeer var = false voeg var = false toe aan val if(f kan nog waar zijn voor val): resultaat = vervulbaarrecursief(f, vars, val) if(resultaat!= null): return resultaat verwijder var uit val // Geen oplossing gevonden voeg var weer toe aan vars return null De methode vervulbaar geeft nu een valuatie terug als er een oplossing gevonden is, en anders null. Als dit gelukt is, probeer dan eerst of je code werkt voor de voorbeeldformule. Als dat werkt kun je door met de sudoku s: hoe snel je code is hangt sterk af van de volgorde waarop de variabelen gekozen worden. Als je de variabelen met een TreeSet verzameld hebt en je elke keer het eerste element kiest als volgende variabele, dan zullen de variabelen op alfabetische volgorde geprobeerd worden wat voor de lege sudoku erg efficient is. Deze zou dan ook binnen enkele seconde een resultaat moeten geven. Voor de makkelijke sudoku zal dit wat langer duren, maar met bovenstaande methode toch niet meer dan enkele minuten. Dat lijkt misschien wat traag, maar bedenk dat je dus een hele algemene SAT-solver hebt geschreven die nog veel meer kan oplossen, en die ook nog eens zo snel is dat hij sudoku s kan oplossen sneller dan dat jij dat met de hand kunt! Een behoorlijk goede prestatie. En bedenk ook dat er maarliefst 729 variabelen in de formule voor deze sudoku zitten, waardoor het aantal mogelijke valuaties voor deze formule een getal is dat uit 220 cijfers bestaat... Er is ook nog een moeilijke sudoku gegeven, maar die duurt waarschijnlijk veel (maar dan ook echt veel) langer met de code die je tot nu toe hebt. Als bonusopgave kun je proberen om je code zo te optimaliseren dat ook deze snel kan worden opgelost, maar het is de vraag of dat lukt. 5

6 Bonusopdrachten Voor de wat meer gevorderde studenten zijn er nog twee bonusopgaven te doen om het cijfer te verhogen. Zonder deze opdrachten te maken is het mogelijk om een 10 te halen, maar de bonusopdrachten kunnen gebruikt worden om kleine fouten in de overige opgaven te compenseren. Daarnaast is het een goede oefening om je Javakennis te vergroten. Sudoku-constructie De Sudoku klasse bouwt nu een String op die we later weer parsen, maar het zou natuurlijk beter zijn om direct een object aan te maken dat de formule representeert. Pas de code van de Sudokuklasse zo aan dat dit op die manier gedaan wordt. Slimmere zoekstrategie Zoals gezegd maar de volgorde van keuze van variabelen in de recursieve zoekstrategie heel erg veel uit. Veel onderzoek binnen de SAT-solving gaat dan ook over het slim kiezen van de volgende variabele. Een van de trucs is de volgende: in sommige gevallen zijn er variabelen die nog niet in je valuatie zitten die nog maar één mogelijke waarde kunnen hebben, en in dat geval is het altijd slim om die variabelen vast te leggen. Probeer dit te implementeren om je code in veel gevallen een stuk efficienter te maken. Maar andere slimme trucs die goed werken worden ook aangemoedigd! Als je een bonusopdracht maakt, meldt dit dan in het commentaar. Inleveren De opgave dient alleen of in tweetallen gemaakt te worden. Code van andere(n) (tweetallen) bekijken of overnemen of code delen met andere(n) (tweetallen) is uitdrukkelijk niet toegestaan. Het programma moet worden geschreven in Java en moet draaien op de practicummachines. De code moet worden ingeleverd via Submit, zie de practicumpagina 1 op de vakwebsite voor meer informatie. De code wordt beoordeeld op de volgnde criteria: leesbaarheid (maximaal 5 punten aftrek) correctheid (maximaal 10 punten aftrek) runbaarheid (niet runbaar, niet hoger dan een 5) stijl (bv redundantie) correctheid voor randgevallen motiveer steeds, in het commentaar, ontwerpbeslissingen die je neemt 1 6