Beyond Prolog: Constraint Logic Programming

Size: px

Start display at page:

Download "Beyond Prolog: Constraint Logic Programming"

Alannah Bennett
5 years ago
Views:

1 Beyond Prolog: Constraint Logic Programming This lecture will cover: generate and test as a problem solving approach in Prolog introduction to programming with CLP(FD) using constraints to solve a puzzle applications of CLP(FD)

2 Solving the puzzle in Prolog (revision) Place the digits 1 to 6 in each row, column and marked shape. How could this puzzle be: represented solved in Prolog? 10 - Beyond Prolog: Constraint Logic Programming 1

3 General technique of search Prolog can be described as using a: generate and test search technique. This means: generate a possible solution to a problem test to see if the possible solution is acceptable Beyond Prolog: Constraint Logic Programming 2

4 Search Beyond Prolog: Constraint Logic Programming 3

5 Search Beyond Prolog: Constraint Logic Programming 4

6 Representation We need to be able to represent that individual squares are instantiated: A1 = 1, B3 = 1, B6 = 3, C3 = 2, D6 = 2, E1 = 3, E2 = 6, F3 = 4, F5 = Beyond Prolog: Constraint Logic Programming 5

7 Generating solutions - 1 In the first version, the program was very short: Step 1: Define the values that can fill a square: candidates([1,2,3,4,5,6]). Step 2: Go through the list of squares and put a candidate number in each square Beyond Prolog: Constraint Logic Programming 6

8 Generating solutions - 2 This is the code that puts all the candidates into the list of squares: % 1 - terminating generate([], _Candidates). % 2 - recursive generate([square Squares], Candidates) :- member(square, Candidates), generate(squares, Candidates) Beyond Prolog: Constraint Logic Programming 7

9 Testing solutions - 1 This involved testing each row, column and group to ensure that they have 6 unique numerical values. First the individual rows/columns/ groups were selected from the representation: % 1 - terminating test([]). % 2 - recursive test([six Sixes]) :- test_six(six), test(sixes) Beyond Prolog: Constraint Logic Programming 8

10 Testing solutions - 2 Then testing each combination of squares to ensure uniqueness: test_six(six(sq1, Sq2, Sq3, Sq4, Sq5, Sq6)) :- Sq1 =\= Sq2, Sq1 =\= Sq3, Sq1 =\= Sq4,, Sq4 =\= Sq6, Sq5 =\= Sq Beyond Prolog: Constraint Logic Programming 9

11 Running the program run :- % pick up the board and candidates board(display_square, square(square), sixes(sixes)), candidates(candidates), % generate a solution generate(square, Candidates), % test the solution test(sixes), % display successful solutions display_square(display_square) Beyond Prolog: Constraint Logic Programming 10

12 Analysing the program This program is correct, but it has to do a lot of work. Why? There are 6 ways of filling the first square, 6 ways of filling the second square,, 6 ways of filling the last square. = 10,314,424,798,490,535,546,171,949,056 possible solutions to be tested (if starting with an empty board) Beyond Prolog: Constraint Logic Programming 11

13 Too large a search space That program could be made more sophisticated. We could introduce heuristics earlier. Heuristic = rule of thumb Usually some insight into the search space that allows us to trim ( prune ) it in some way Beyond Prolog: Constraint Logic Programming 12

14 Too large a search space Ensure that a number has a different value from the squares immediately before it: Beyond Prolog: Constraint Logic Programming 13

15 Too large a search space Ensure each row is OK before filling the next row: But still many alternatives will be generated before being tested Beyond Prolog: Constraint Logic Programming 14

16 Too large a search space It also makes the program more complicated: % 3 - recursive - <6 previous squares generate([square Squares], [Sq1 Rest], Candidates) :- len_list(rest, Len), Len < 5, memb(square, Candidates), Square \== Sq1, generate(squares, [Square, Sq1 Rest], Candidates) Beyond Prolog: Constraint Logic Programming 15

17 Too large a search space This still takes a very long time, but If we assign numbers to the first row, then to the first column, then to the second row, then to the second column the solution is found much faster but still not quick enough Demo Beyond Prolog: Constraint Logic Programming 16

18 Programming with CLP(FD) In Constraint Logic Programming over Finite Domains, variables are constrained to take their values from a finite set. In the puzzle example, the values will be the finite set of integers {1,2,3,4,5,6}. Computation proceeds essentially by removing values from sets that cannot possible be part of the (partial) solution Beyond Prolog: Constraint Logic Programming 17

19 Programming with CLP(FD) This square is constrained to be 2 or 6. This square is constrained to be 1 or Beyond Prolog: Constraint Logic Programming 18

20 Structuring the program Instead of generate and test, we use constrain and generate. The structure is fairly standard: define the domains of the variables impose constraints on the variables generate the solutions by labelling 10 - Beyond Prolog: Constraint Logic Programming 19

21 Defining the board Defining the board is much easier than in the Prolog version: board(square(a1, A2, A3, A4, A5, A6, B1, B2, B3, B4, B5, B6, C1, C2, C3, C4, C5, C6, D1, D2, D3, D4, D5, D6, E1, E2, E3, E4, E5, E6, F1, F2, F3, F4, F5, F6)) :- A1 #= 1,, F5 #= 5, 10 - Beyond Prolog: Constraint Logic Programming 20

22 Defining the domains of the variables We give a set of variables and the lower and upper range of their domain: % rows domain([a1, A2, A3, A4, A5, A6, B1, B2, B3, B4, B5, B6, C1, C2, C3, C4, C5, C6, D1, D2, D3, D4, D5, D6, E1, E2, E3, E4, E5, E6, F1, F2, F3, F4, F5, F6], 1, 6), 10 - Beyond Prolog: Constraint Logic Programming 21

23 Imposing constraints on the variables Here are two alternative ways of imposing constraints: Rows and columns are constrained to have different values: all_different([a1, A2, A3, A4, A5, A6]), all_different([a1, B1, C1, D1, E1, F1]), An alternative way of achieving the same is used for groups: A1 #\= A2, A1 #\= A3, A1 #\= A4, A1 #\= B2, A1 #\= C2, 10 - Beyond Prolog: Constraint Logic Programming 22

24 Generating the solutions by labelling Solutions are generated using labelling : labeling([], [A1, A2, A3, A4, A5, A6]), labeling([], [B1, B2, B3, B4, B5, B6]), labeling([], [C1, C2, C3, C4, C5, C6]), labeling([], [D1, D2, D3, D4, D5, D6]), labeling([], [E1, E2, E3, E4, E5, E6]), labeling([], [F1, F2, F3, F4, F5, F6]). Note: alternatives are generated using backtracking Beyond Prolog: Constraint Logic Programming 23

25 Does this work more effectively than the LP version? Yes run the demo program! 10 - Beyond Prolog: Constraint Logic Programming 24

26 What can CLP(FD) be used for? CLP(FD) is used for: optimization planning layout configuration Examples include: optimizing containers in harbours; planning car production plants; layout of wireless network components university timetabling Beyond Prolog: Constraint Logic Programming 25

Writing and debugging programs

Writing and debugging programs Programs should be designed top-down and built bottom-up. Style and presentation are aids to producing correct programs. Once written, programs should be tested analytically.