Stepping with SeaLion

Transcription

1 Stepping with SeaLion April 26, 2013 Contents 1 Introduction Stepping Terminology in a Nut Shell Set-up The Toy Problem The Toy Program Debugging by Stepping Starting Stepping The SeaLion Stepping Perspective The First Steps Getting Stuck and Backtracking Stratification of Aggregates Jumping Truth Assignment Finding the First Bug with Filtering Fixing the Second Bug Introduction SeaLion [7] [ref also the iclp13 paper and other tutorials!!!] is an IDE for ASP [3, 4] realised as a plugin of the Eclipse platform [1]. This tutorial describes how to use the SeaLion s primary debugging mechanism, the Stepping framework. After a brief introduction and description how to set up SeaLion, we will lead you step by step through an example debugging session. You TODO 1

2 can find more technical details in [6] that introduces Stepping for normal logic programs, in [8] that lifts the framework to DL-programs and in [5] that describes the full version implemented in SeaLion. 1.1 Stepping Terminology in a Nut Shell In the imperative programming, stepping through a program is the most common debugging method. At each step you can inspect the content of variables to understand what the program actually does. This method is simple and straightforward, because the control flow of imperative programs is fixed. In the case of ASP it is not so simple, because in the declarative paradigm there is no such thing as a control flow. SeaLion solves this problem by letting the user choose which direction should the search for an answer set proceed. Briefly, a process of stepping tries to monotonically build up an interpretation by, in each step, adding atoms derived by a rule that is active under the interpretation obtained in the previous step. Practically, a stepping state S consists of the set of rules P S already considered active, the intermediate interpretation I S of atoms already considered true, the set of atoms I S already considered false and the set of unfounded sets Υ S. (We will not concern ourselves with these in this tutorial. See [2, 8, 5] for more details.) At a step from S to its successor S, the user chooses a rule r active under I S that will be added to P S and form P S. The user also has to choose which atoms from r are considered true and which false, such that r stays active and satisfied by I S. The ones considered true added to I S form I S and the ones considered false added to I S form I S. The sets I S and I S must stay disjoint in any state S to forbid deactivation of r. A process of stepping is called computation. Each answer set of the program can be reached by some computation and each computation either reaches some answer set or gets stuck. A computation that will inevitably get stuck is called failed. 1.2 Set-up If you want to follow this tutorial step by step, please install SeaLion as described on the SeaLion Website, but choose the package titled SeaLion Package (includes all non-experimental plugins). When installed, change Context Type Preferences in Window Preferences SeaLion for Gringo File to Gringo Clasp (all AS) in order to obtain all answer sets of a program when launched. 2

3 1.3 The Toy Problem We will be debugging program that is meant to solve Nurikabe puzzles. Nurikabe is a grid of cells, some of which contain natural numbers. The goal is to colour the cells such that (i) each cell is either black or white, (ii) cells with numbers are white, (iii) there are no 2x2 blocks of black cells, (iv) all black cells are transitively connected, and (v) each maximal group of white cells that are transitively connected must contain exactly one cell with a number; this number must be the number of cells in the group, where two cells are connected if they are of the same colour and share a border. For example, this is a puzzle instance, its solution and two wrong solutions violating the condition (iii) and conditions (v): 1.4 The Toy Program Start a new SeaLion project in the menu File New Project... and then SeaLion SeaLion Project. 3

4 Name it stepping tutorial. Then right click on the project in the Project Explorer and create a new file in New File. 4

5 Name it nurikabe.lp. Open the file and insert the following code into it. % INPUT % % Having a grid of cells, some of which contain natural numbers, row(1..4). col(1..4). number(c(3,2), 3). number(c(4,4), 1). % DEFINE % cell(c(y,x)) :- row(y), col(x). maxcol(x) :- col(x), not col(x+1). maxrow(y) :- row(y), not row(y+1). 5

6 mincol(x) :- col(x), not col(x-1). minrow(y) :- row(y), not row(y-1). adjacent(c(y,x), c(y-1,x)) :- cell(c(y,x)), not minrow(y). adjacent(c(y,x), c(y,x+1)) :- cell(c(y,x)), not maxcol(x). adjacent(c(y,x), c(y+1,x)) :- cell(c(y,x)), not minrow(y). adjacent(c(y,x), c(y,x-1)) :- cell(c(y,x)), not mincol(x). % GENERATE % % (i) each cell is either black or white, {white(c) : cell(c)}. black(c) :- cell(c), not white(c). % CHECK % % (ii) cells with numbers are white, :- black(c), number(c,_). % (iii) there are no 2x2 blocks of black cells, :- black(c(y,x)), black(c(y+1,x)), black(c(y,x+1)), black(c(y+1,x+1)). % (iv) all black cells are transitively connected, black_reach(c1, C2) :- black(c1), black(c2), adjacent(c1, C2). black_reach(c1, C3) :- black_reach(c1, C2), black(c3), adjacent(c2, C3). :- black(c1), black(c2), not black_reach(c1, C2). % (v) each maximal group of white cells that are transitively connected % must contain exactly one cell with a number; % this number must be the number of cells in the group, group(c, C) :- number(c, _). group(c1, C2) :- group(c3, C2), adjacent(c3, C1), white(c1). :- number(c1, N), not N{group(C2, C1) : cell(c2)}n. in_group(c) :- group(c, _). :- white(c), not in_group(c). 1{group(C1, C2) : number(c2, _)}1 :- white(c1). The code can be downloaded from [move to more official place] here. Briefly, the program encodes a puzzle instance with facts of predicates row/1 and col/1 that enumerate row and column numbers, and atoms of form number(c(y,x),n), indicating that the cell c(y,x) contains number N. The output of the program is encoded by predicates black/1 and white/1 specifying the colouring of each cell. The DEFINE part defines all the cells and their adjacency. An output is first guessed in the GENERATE part and then checked by the constraints in the CHECK part. The encoding of the first two constraints is straightforward, but the encoding of the other two needs auxiliary definitions of reachability and white groups. Prepare a launch configuration by choosing Run Configurations... from Run As in the pop-up menu of the file, or in the pop-up menu under the Run As... button in the toolbar. TODO 6

7 Choose SeaLion in the list on the left, then click New launch configuration. Name it nurikabe and add our source code file to the Input Program Files. 7

8 All the other attributes should be set automatically. So just click the buttons Apply and Run just to find out that the program has no answer set. 2 Debugging by Stepping Generally, a bug in an answer-set program is detected when, for a particular input, the actual output differs from the intended output. This means that either (1) an intended answer set is missing from the actual output, or (2) the actual output contains an unintended answer set. A good stepping strategy in the first case is trying to reach one of the missing answer sets and see why the computation gets stuck. In the second case it is sensible to lead the stepping towards one of the unintended answer sets and observe where the computation should but does not get stuck. 8

9 Out toy program has no answer set while we expect exactly one for the exactly one solution of the puzzle instance in the program s input. This is a subcase of (1), where all intended answer sets are missing. So let us try the first strategy. 2.1 Starting Stepping You can start to step through a program by running its usual launch configuration in the debug mode. Simply choose Debug Configurations... from Debug As in the pop-up menu of the file or in the pop-up menu under the Debug As... button in the toolbar. Select the launch configuration nurikabe we defined before and click Debug. 2.2 The SeaLion Stepping Perspective The GUI of Eclipse switches to the SeaLion Stepping perspective. 9

10 [Draw the labels into the picture.] The perspective displays the source code of the program in a source editor (a). Rules with active instances are highlighted in the editor. Upon clicking on such a rule, its active instances are displayed in the Active Instances view (b). After choosing one of the instances, you need to decide in the Truth Assignment view (c) whether the atoms in it are assigned to I S or I S. While a rule selected for some step must remain active and satisfied under I S of the next state S, this assignment is usually fixed for simple rules. In such cases, SeaLion automatically assigns the atoms and enables the STEP button. Upon clicking the button, the next state is computed and displayed in the State view (d). Finally, the Computation view (e) shows all actions taken during a stepping in the form of a tree and allows for navigating between the states resulting from these actions, i.e. you can return to a previous state and start a new branch in the tree from there, while all the old branches remain intact. TODO 2.3 The First Steps Click on the first fact of the program in the source editor and the Active Instance view displays its active instances. Select the second one. Truth assignment of the atoms in this fact is fixes, so the Truth Assignment view automatically enables the STEP button. Click it. Congratulations! You have just performed your first step. The State view now displays the active instance of the fact added to P S (a), the atoms from it added to I S (b), empty I S (c) and only one empty set in Υ (d). 2.4 Getting Stuck and Backtracking Adding row(2) to I S activated further rules in the program. Select the first one of them and step through its active instance. 10

11 Now P S contains {row(2)., maxrow(2) :- row(2), not row(3).}, I S contains {row(2), maxrow(2)} and I S contains {row(3)}. Select the first fact again and its active instance row(3).. You can see that it is not possible to add it to P S, because that would add atom row(3) to I S which must stay disjoint with I S. 11

12 While row(1..4). is a fact, row(3). will always be its active instance. Even if we continue stepping, we will be never able to add this active instance to P S, because we cannot remove its atom from I S. That means we cannot reach any answer set from this state. Detecting when the computation becomes failed will point to the bug later on, but this time it happened because we made a step that does not lead to our intended answer set. So we backtrack one step by double-clicking on the previous node in the Computation view. Even though we did not detect the bug yet, you can see from this little detour why maxrow(4) is the only instance of maxrow(x) in any answer set. 2.5 Stratification of Aggregates Back on the right track, if you try to select the choice rule in the GENERATE section, SeaLion will write a warning 12

13 This is because the grounding of the choice rule depends on complete interpretation of cell/1, i.e. there is one atom of white/1 in the instance of the choice rule for each atom of cell/1 that is true. While we did not add any atom of cell/1 to I S yet, the only active instance of the choice rule is an empty choice rule {}.. If we added this instance to P S and then added some atoms of cell/1 to I S, the grounding of the choice rule would change and {}. would be a rule in P S that is not an active instance of any rule in our program. SeaLion detects such cases and prevents us from getting into inconsistent states by forbidding adding rules with active instances that may change. 2.6 Jumping In order to reach out intended answer set we need to step through all the facts of the input and all the rules in the DEFINE part. This is tedious and cumbersome. SeaLion offers the jumping feature for such cases. It allows us to jump through a number of rules into a state that would be reached after stepping through all these rules. Select text of all the facts of the input and click the Add Rules for Jump button in the Jump view. This adds the rules into the set of rules selected for jump displayed by the Jump view. You can remove all the rules from this set by clicking the Clear Rules for Jump button. Do not do it now, but add also the following five rules 13

14 and click the Jump button. You will get to the state where all active instances of the selected rules are in P S, the atoms they infer are in I S, and the negated atoms from these instances are added to I S. We want to do even less clicking, so select all the rules defining adjacent/2 and click Direct Jump on the toolbar or in the Stepping menu. 14

15 This simply directly jumps through the selected rules. Note that decisions for jumping are taken nondeterministically (technically, they depend on the first answer set that is generated in a SeaLion internal answer-set computation), e.g. if guessing rules are chosen for jumping, we cannot be sure in what state will the jump end up. If you want to determine some of the guessed values, you can step through the corresponding instances of the guessing rules before jumping. We will to do this next. 2.7 Truth Assignment Now we are going to step through the GENERATE part in a way that generates our intended answer set. So select the choice rule (no warning is issued as all the atoms of grid/1 are already in I S ). It has only one active instance, but the truth assignment of its atoms is not fixed. We have to put the atoms white(c(2,2)), white(c(2,3)), white(c(3,2)) and white(c(4,4)) to the positive column and the rest to the negative column. You can do this with drag&drop or using the arrow keys. 15

16 When the decision column is empty, the STEP button is enables. Please note that this does not happen generally, if there were some bounds of the choice rule, the number of atoms in the positive column would have to be within these bounds. Generally, the STEP button is enables when the selected active instance is active and satisfied after the choice. Finally, click the STEP button and arrive to the state where all the cells we want white/1 are in I S. Now you can simply jump through the other rule in the GENERATE part, because the outcome is determined by the previous step. 2.8 Finding the First Bug with Filtering At this point, the output predicates in I S specify the only correct solution of out puzzle instance. We know this stepping will not lead to any answer set, because the program has none. Thus we want to find out why we will get stuck. Let us start with inspecting each constraint. The first two are inactive and will not activate, because all their atoms are already derived. The constraint encoding condition (iv) is active, while no black_reach/2 is in I S yet. After we jump through the two rules defining the black reachability, the constraint should deactivate. 16

17 But it does not. You can see the instances of this constraint that stayed active in the Active Instances view. Let us focus on the first one: :- black(c(1,1)), black(c(2,1)), not black_reach(c(1,1),c(2,1)). Only way to deactivate this instance is to derive black_reach(c(1,1),c(2,1)). While c(1,1) and c(2,1) are adjacent, the rule that should derive this atom is the first rule defining the black reachability. So let us backtrack before jumping through it and inspect its active instances. It has many instances, but we want to see only the one that derives our missing atom. You can filter the instances by typing variable=value pairs separated by dot into the filters text input on the top of the Active Instances view. Type C1=c(1, 1).. 17

18 You can see that the active instance deriving black_reach(c(1,1),c(2,1)) is missing. The only possible reason for this is that adjacent(c(1,1),c(2,1)) was not derived, because the interpretation of black/1 is already fixed. Let us backtrack before adding atoms of adjacent/2 and inspect the rules deriving them. The third rule is responsible of deriving adjacent(c(1,1),c(2,1)) and after having a look on its active instances you can probably see that there is something strange. The variable Y is never substituted by 1. This points to the mistake in the boundary atom not minrow(y) which is supposed to be not maxrow(y). If you rewrite the atom while stepping, SeaLion warns that the state may be inconsistent. 18

19 So we rather stop the stepping by clicking Stop Stepping on the toolbar or in the Stepping menu and launch the program to make sure that the bug is gone. 2.9 Fixing the Second Bug The good news is that the program has an answer set. The bad news is that it has too many answer sets. While we expect only one for the only solution of the puzzle instance, this is case (2) of the ASP output difference. Thus we will step towards an answer set corresponding to one of the wrong solutions and concentrate on the part of the program that was supposed to forbid this answer set. Let us pick the following wrong solution: 19

20 We can see that this solution violates the condition (v), so the bug is probably in the program part encoding this condition. We want to examine just this part, so we will jump through the rest of the program, which we suppose is correct. Start the stepping as before and jump through all the input facts and the DEFINE part. Step through the choice rule and assign its atoms to generate the wrong solution. jump through the other rule in the GENERATE part. 20

21 You may, but do not need to, jump through the rules defining the black reachability, because the part encoding the condition (v) does not depend on them. Now we fixed the interpretation of the output predicates to encode our wrong solution, so if the program was correct, the constraints in the part (v) would stay active. But we know that this computation leads to an answer set, so it is possible to deactivate all the constraints. We will find the bug, if we find out how are the constraints that should stay active deactivated. The part (v) first defines the white groups by atoms group(g,c) saying that the cell C belongs to the group G. The first rule of the part says that the groups are identified by the cells with numbers. The second rule adds all the white cells white-reachable from a cell with a number to the group of the number cell. Jumping through these two rules is meant to be the only way to deactivate the constraints of this part. Jump through them, just to find out that the constraints are not deactivated! How are the constraints deactivated then? The first constraint is a little bit too complicated, so let us start from the second one. It ensures that each white cell is in some group. (We see that 21

22 this is not true in the wrong solution we are reaching.) Jump through the projecting rule in_group(c) :- group(c, _). and have a look at the active instances of the constraint. We fixed the interpretation of white/1 and the projecting rule is the only one defining in_group/1, so this constraint is deactivated by some other rule deriving atoms of group/2. After the search for such a rule in the program, you can see that the last rule does so. This rule was supposed to encode that each white cell must belong to exactly one group, but the programmer got confused and encoded that each white cell belongs to exactly one group. The difference is that the former is a restriction and should be encoded as a constraint, but the latter is a definition encoded by a rule that actually derives atoms of group/2. You can continue stepping and reach the unintended answer set, but you would not gain much more information. It is better idea to stop stepping, correct the last rule into the constraint :- white(c1), not 1{group(C1, C2) : number(c2, _)}1. and run the program to see that it finally gives the correct output. [A little about unfounded sets. a b. a :- b. b :- a.] TODO References [1] Eclipse Project [2] Wolfgang Faber. Unfounded sets for disjunctive logic programs with arbitrary aggregates. In Proceedings of the 8th International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR 2005), volume 3662 of Lecture Notes in Computer Science, pages Springer, [3] M. Gelfond and N. Leone. Logic programming and knowledge representation - The A-Prolog perspective. Artificial Intelligence, 138(1-2):3 38, [4] M. Gelfond and V. Lifschitz. The stable model semantics for logic programming. In Proceedings of the 5th Logic Programming Symposium, pages , Association for Logic Programming, MIT Press, Cambridge, Mass,

23 [5] J. Oetsch, J. Pührer, P. Skočovský, and H. Tompits. Stepping in answer-set programming: Handling disjunctions and aggregates, In preparation. [6] J. Oetsch, J. Pührer, and H. Tompits. Stepping through an answer-set program. In Proceedings of the 11th International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR 2011), volume 6645 of Lecture Notes in Computer Science, pages Springer, [7] Johannes Oetsch, Jörg Pührer, and Hans Tompits. The SeaLion has landed: An IDE for answer-set programming Preliminary report. In Proceedings of the 19th International Conference on Applications of Declarative Programming and Knowledge Management and the 25th Workshop on Logic Programming (INAP 2011/WLP 2011), pages , [8] Johannes Oetsch, Jörg Pührer, and Hans Tompits. Stepwise debugging of description-logic programs. In Esra Erdem, Joohyung Lee, Yuliya Lierler, and David Pearce, editors, Correct Reasoning - Essays on Logic-Based AI in Honour of Vladimir Lifschitz, volume 7265 of Lecture Notes in Computer Science, pages Springer,