Solving Constraint Satisfaction Problems in Java Nico van Hanxleden Houwert nhouwert@iprofs.nl

Topics Wat zijn Constraint Satisfaction Problems? Wat maakt CSP’s zo lastig? Hoe los je ze op? Java CSP frameworks Demonstratie en code

Wat zijn CSP’s? ‘Normale’ problemen: reguliere algoritmes B.v.: omrekenen graden Celcius → Fahrenheit Lage complexiteit, eenduidig algoritme Input → berekening → output Stapje verder: zoekprobleem: legpuzzel Niet eenduidig Ietwat zoeken Maar: niet complex En: probleem kan in stukken gehakt worden

Planning Commerciële Haven Variabelen: 10 schepen, 5 aanlegplaatsen Welk schip wanneer op welke aanlegplaats? Veel constraints (voorwaarden) Opstellen van goed of optimaal rooster ‘Puzzelprobleem’, geen eenduidig algoritme Hoge complexiteit / veel afhankelijkheden Niet deelbaar Grote zoekruimte 5^10 ≈ 10.000.000 mogelijkheden Oplossingmogelijkheid: brute-force ≈ 3u rekentijd

10 Jaar Later… Dit is een CSP 20 schepen en 10 aanlegplaatsen 10^20 mogelijkheden -> 3.000.000.000 jaar 100x krachtigere processor aanschaffen? Probleem in stukken hakken: 2x 3u = 6u? Dit is een CSP Zoekprobleem; geen eenduidig algoritme Hoge complexiteit / veel afhankelijkheden / constraints Zeer grote zoekruimte Combinatorische explosie

Andere voorbeelden van CSP’s Opstellen van vluchtroosters op Schiphol Opstellen treinroosters bij de NS Opstellen rooster voor de J-Fall Puzzels (schaken, dammen, Sudoku, kruiswoordpuzzels, GO, etc.) Logistieke problemen Resource allocation Elektronica (circuit design) …

Wat maakt CSP’s zo lastig? Zoek-/‘puzzel’-problemen Niet oplosbaar middels reguliere algoritmes Clay Mathematics Institute biedt $1.000.000,- Hoge mate van complexiteit Veel afhankelijkheden Zeer grote zoekruimten Combinatorische explosie

N-Queens

N-Queens N-queens is een CSP Zoekruimte: mogelijkheden 8-queens: 64x63x62x61x60x59x58x57 / 8! = 4.426.165.368 mogelijkheden Slechts 92 oplossingen, waarvan slechts 12 uniek (speld in hooiberg) 1 mogelijkheid/msec = 51 dagen rekentijd 20-queens: 88.418.346.767.849.338.466.287 jaar ≈ 88,5 triljard jaar (combinatorische explosie)

Algoritmiek voor CSP’s ‘Recht-toe/recht-aan’ algoritmes zijn er niet Brute-force algoritmes werken niet Zoekalgoritmes?

Backtracking - Backtracking (depth- first search) - Efficiënter dan brute- force, maar niet voldoende - Constant op fouten stuiten en moeten backtracken is duur - Supercomputer komt momenteel tot +/- n=25 binnen enkele uren

Hoe los je CSP’s dan wel op? Allereerst, formele definitie CSP: Verzameling variabelen: V = {x1, ..., xn} Verzameling domeinen: D = {d1, …, dn} Verzameling constraints: C = {c1, …, cm} B.v.: V = {x, y, z} Dx = Dy = Dz = {0…10}, C1 = [x == 4], C2 = [x < y], C3 = [y > z]

Weergave Middels CSP-Graaf 3 variabelen, 3 domeinen, 3 constraints 1 unaire constraint, 2 binaire constraints Oplossing (b.v.): x = 4, y = 6, z = 5

Hoe los je CSP’s dan wel op? Basis: systematic search: backtracking Maar, verrijkt met een aantal technieken Consistency techniques Deze worden uitgevoerd voordat gezocht wordt Node-consistency: verwijdert alle unaire constraints & werkt de domains bij Arc-consistency: een binaire constraint tussen 2 variabelen X en Y is arc consistent indien alle waarden in beide domeinen consistent zijn met de constraint. Een arc consistency algoritme verwijdert alle waarden uit de domeinen waarvoor dit niet geldt

Constraint Propagation ‘Intelligente’ vorm van backtracking Gewone backtracking instantieert variabelen incrementeel, en herstelt van ongeldige instantiaties nadat deze gedetecteerd zijn Constraint propagation voorkomt ongeldige instantiaties door deze van tevoren te detecteren en ze over te slaan Dit door de constraints te integreren (propageren) in het zoekproces

Constraint Propagation Instantieer een variabele Kijk naar de andere variabelen die middels een constraint hiermee verbonden zijn Verwijder uit de domains van die andere variabelen alle waarden die in conflict zijn met de huidige variabele (n.a.v. de constraints) Zodra de domain(s) leeg zijn weet je dat je niet verder hoeft te zoeken in die richting -> backtrack

Backtracking vs. Constraint Prop. Backtracking: Constraint prop.:

Variable Ordering In welke volgorde variabelen bezoeken? Statische & dynamische ordering algoritmes MRV (Minimum Remaining Values) Heuristiek: Fail First Principle – “To succeed, try first where you are most likely to fail” Variabele met de minst resterende waarden (kleinste domein) Hiermee: doodlopende takken in de zoekboom z.s.m. detecteren, en hiermee de grootte van de zoekboom minimaliseren

Value Ordering Zodra de volgende te bezoeken variabele bepaald is: in welke volgorde de mogelijke waarden toekennen? Populair algoritme: LCV (Least Constraining Value) Heuristiek: kies de waarde die de minste waarden uit de domeinen van de andere variabelen elimineert

Hoe los je CSP’s dan wel op? Samenvattend: Kunnen we CSP’s efficiënter oplossen? Yes we can Node-consistency & arc-consistency Constraint propagation (‘intelligente’ backtracking) Dynamic variable ordering & dynamic value ordering Echter - als developer wil je je focussen op het probleem, en niet op alle algoritmen (en varianten erop)

Java CSP Frameworks Commerciële en open-source frameworks beschikbaar Voordelen: Off-the-shelf algoritmes Abstractielaag waarmee CSPs eenvoudiger gemodelleerd kunnen worden O.a.: ILOG en CREAM

CREAM

N-Queens in CREAM Eerst: n-queens als CSP modelleren n variabelen representatie: Qi = {Q1, …, Qn} index is kolom, waarde = rij n domeinen ({1…n}) constraints: 4 typen: 1. i ≠ j ≠ …(automatisch) 1. ongelijke kolommen 2. Qi ≠ Qj ≠ … ≠ Qn 2. ongelijke rijen 3. ongelijke diagonalen \ 3. Qi+i ≠ Qj+j ≠ … ≠ Qn+n 4. ongelijke diagonalen / 4. Qi-i ≠ Qj-j ≠ … ≠ Qn-n {1, 2, 6, 5, 7, 3, 8, 4}

N-Queens in CREAM public class QueensCSPSolver { // Declare Network, Solver, Solution and Variables IntVariable[] queens; Network net; Solver solver; Solution sol; ... void solveQueens(int nrQueens) { queens = new IntVariable[nrQueens]; // Initialise Variables with their Domains for (int i = 0; i < nrQueens; i++) { queens[i] = new IntVariable(net, 1, nrQueens); }

N-Queens in CREAM // Add the first set of Constraints // (Queens must be on different rows) new NotEquals(net, queens); ... // Initialise the solver solver = new DefaultSolver(net); // Solve the problem & iterate through all solutions for (solver.start(); solver.waitNext(); solver.resume()) { // Get a solution solution = solver.getSolution();

N-Queens in CREAM Korte demonstratie // Print the solution // Uses solution.getIntValue(queens[i]); printBoard(); } // Stop the solver solver.stop(); Korte demonstratie Backtracking: n = 8 ok, n = 20 ok, n = 30 nok CSP/CREAM: n = 8 ok, n = 20 ok, n = 50 ok, n = 70 ok, n = 100 ok, …

Enkele Statistieken

Afsluiting Samenvattend Q & A Meer informatie en whitepapers: www.iprofs.nl