IDP : conga/minisat(id)

Transcription

1 IDP : conga/minisat(id)

2 What is conga? Grounder developed here at the University of Kentucky that implements a subset of the IDP language Creates output for MinisatID to solve 2 7/28/2011

3 What is IDP? IDP is a subset of the FO(.) logic It extends first order logic with inductive definitions It enforces some declaration rules for entities used within logic programs It allows strong typing in logic programs (and other syntactic sugar) 3 7/28/2011

4 Which leads to More readable logic programs More manageable logic programs (at least, in theory) 4 7/28/2011

5 So why is this important? It is an effective tool for describing solutions to problems And then we let the solver, Minisat(ID), due the heavy lifting The problems we throw at it tend to be difficult (or, at least, non-trivial) to solve, but have commonalities

6 Advantages? We describe the problem, and then let a (hopefully highly!) optimized program do the model searches for us These programs are fast; they have annual competitions for speed And this means that we can take advantage of work done in the field optimizing these types of problems without having to re-implement complex algorithms as the state of the art is advanced And as you ll see, we can describe pretty interesting problems very quickly compared to using a procedural approach

7 So what does it actually look like? Input files separated into blocks Blocks determine how declarations are interpreted Implication and For each/there exists semantics Let s get to a simple example 7 7/28/2011

8 A puzzle Does this look familiar? x y t Location x, y, t. x t y Location x, y, t. y t x Location x, y, t. x y t 0 t 1 Location x, y, t 0 Location x, y, t 1 t 0 = t 1

9 Latin Square Given: Find: type int Size = {1..8} Initial(Size, Size, Size) Location(Size, Size, Size) Satisfying:! x :! y :? t : Location(x, y, t).! x :! t :? y : Location(x, y, t).! y :! t :? x : Location(x, y, t).! x y t1 t2 : Location(x,y,t1) & Location(x,y,t2) => t1 = t2.! x y t : Initial(x, y, t) => Location(x, y, t). Data: Initial = { }

10 Input files are divided into blocks Sixish of them Given Declare Find Satisfying Data Maximize/Minimize

11 Given block Begins with Given: NOTE: Lines in the Given block are newline delimited. No, I don t know why they are newline delimited. From the Latin Square problem: Given: type int Size = {1..8}

12 Given (cont d) The block is used to declare types, predicates (predetermined only), and some other values. type int Size = {1..8} tells us: We have a type called Size we use in the program It is an integer (although this only really matters if we re doing math on it) It has values that range from 1 to 8

13 Given (cont d) Anything in the block is treated as fixed. We can only modify values here in the Data block (which we ll get to much later) But, basically, it s just here to tell the program what types to use and what constant values to expect in the program

14 Declare & Find These blocks have the same syntax. Again, they are newline delimited There is only one difference between the two: visibility. Anything declared in the Declare block is known to the program, but will not be shown as part of the output While anything in the Find block will be shown as output

15 Declare & Find (cont d) From the Latin Square problem: Find: Location(Size, Size, Size) This declares (and it s in the Find block, so it will show up on output) a predicate called Size which accepts three parameters, all of which are of the type Size.

16 Declare & Find (cont d) These blocks just declare the values It s still up to us to actually define them, this is what the Satisfying block is for

17 Satisfying This is where the real logic happens. From our Latin Square implementation: Satisfying:! x :! y :? t : Location(x, y, t).! x :! t :? y : Location(x, y, t).! y :! t :? x : Location(x, y, t).! x y t0 t1 : Location(x,y,t0) & Location(x,y,t1) => t0 = t1.! x y t : Initial(x, y, t) => Location(x, y, t).

18 Basic semantics Most IDP statements are very easily translated from a standard representation of logic But since our inputs are plain ASCII files, we don t have fancy rotated A s and E s So we make do with! s and? s

19 A note on case You might have noticed by now that all predicates (relations) and types (Location, Size) start with capital letters and all quantified variables (x, y, t) start with lower case letters. This is more than a convention, it is a requirement predicates and types start with upper case letters, and quantified variables start with lower case letters.

20 Satisfying (cont d) Does this look familiar? x y t Location x, y, t. x t y Location x, y, t. y t x Location x, y, t. x y t 0 t 1 Location x, y, t 0 Location x, y, t 1 t 0 = t 1

21 Satisfying (cont d) In IDP:! x :! y :? t : Location(x, y, t).! x :! t :? y : Location(x, y, t).! y :! t :? x : Location(x, y, t).! x y t0 t1 : Location(x,y,t0) & Location(x,y,t1) => t0 = t1.

22 Encoding logic 22 7/28/2011

23 Furthermore Some more conversions from formal logic to IDP: x! x : ( for all x ) x? x : ( there exists at least one x )

24 Which gives you x y t Location x, y, t. For all x, for all y, there exists at least one t such that Location(x,y,t) holds.! x :! y :? t : Location(x, y, t). This is pretty neat.

25 An important line in the program! x y t : Initial(x, y, t) => Location(x, y, t). Literally, For all x, y, t, Initial(x,y,t) holding implies Location(x,y,t) holds. This is how we load initial state data into the problem we define Location as a given predicate, define it in the data block

26 A modified program Given: Find: type int Size Initial(Size, Size, Size) Location(Size, Size, Size) Satisfying:! x :! y :? t : Location(x, y, t).! x :! t :? y : Location(x, y, t).! y :! t :? x : Location(x, y, t).! x y t0 t1 : Location(x,y,t0) & Location(x,y,t1) => t0 = t1.! x y t : Initial(x, y, t) => Location(x, y, t). Data: Size = {1..8} Initial = { 1,1,1; 1,2,2; 1,3,3; 1,4,4; 1,5,5; 1,6,6; 1,7,7; 1,8,8; }

27 Two things to note type int Size in the Given, instead of type int Size = {1..8} This lets us define Size in the data block Initial = { 1,1,1; 1,2,2; This explicitly defines the Initial predicate as the listed tuples Individual values separated by commas, tuples separated by semicolons, nothing exciting here.

28 Rules vs. Data The Data block allows us to separate the rules and declaration from our program from the data set This means we can have the same program easily run on multiple data sets conga can take multiple files as input, so we can have the rules and data in separate files This is useful for your homework!

29 For example Given: Find: Satisfying: type int Size Initial(Size, Size, Size) Location(Size, Size, Size)! x :! y :? t : Location(x, y, t).! x :! t :? y : Location(x, y, t).! y :! t :? x : Location(x, y, t).! x y t0 t1 : Location(x,y,t0) & Location(x,y,t1) => t0 = t1.! x y t : Initial(x, y, t) => Location(x, y, t). latin.cng Data: Size = {1..8} Initial = { 1,1,1; 1,2,2; 1,3,3; 1,4,4; 1,5,5; 1,6,6; 1,7,7; 1,8,8; } latin.dat

30 And then To run both of these files through conga and minisatid: conga latin.cng latin.dat minisatid And, of course, you can have multiple data files working with the same rules file (Again, this is going to be helpful for your homework )

31 Some more semantics Sometimes, especially if you are using mathematical operators, conga will complain about being unable to find the bounds of variables The way to get around this is explicitly declaring the type of quantified variables:! x :! y :? t : Location(x, y, t). Becomes:! x [Size] :! y [Size] :? t [Size] : Location(x, y, t). This is not needed in most cases, as conga can infer types from the statement, but using math (especially with equivalence) can confuse it

32 Implication vs. Equivalence IDP supports both implication (=>) and equivalence (<=>). It s important to know when one or the other is needed Equivalence, of course, is a stronger relationship We use implication to move knowledge from our data set (the Initial predicate in the example) to our solution set (the Location predicate in the example) But if we re using something like a formula where one statement defines a predicate exactly we want to use equivalence Like, say, if we were using a predicate to test if two squares on a chess board were diagonal to each other