CS538: Spring 2008

Assignment#3: Prolog

Handin procedure

• Your handin folder is in ~cs538-1/public/handin/proj3/login where login is your login name.
  
  
• Put your solutions in a SEPARATE FILE for each sub-part: q1.pro, q2a.pro, q2b.pro, q3.pro, q4a.pro, q4b.pro, q4c.pro, q4d.pro. You can also include a file called README with any notes about your submission. PLEASE NOTE: This is different from previous project specifications. Put all the files in the handin directory and do not make separate subdirectories for each question.
  
  
• Make each file SELF-CONTAINED. Each file should be able to execute on its own in the Prolog interpreter, independent of other files. Don't load code used in another question (e.g., do not load file q2a.pro in your solution for q2b.pro), and don't assume that your code will execute in the handin folder. To achieve this, you may need to make copies of code that is common to multiple sub-parts of the same question.
  
  
• Each file should define (at least) the Prolog predicates required by the question. Here's the complete list of definitions that need to be present in each file. Note that you can have more predicates defined, this are just the minimum definitions required in each file. Sample predicate usage is also shown below. Please make sure that your code behaves as shown. Be sure to see the
notes and hints for each question.


Question	Required definitions	Sample usage (Prolog response underlined, semicolon and <Enter> indicate user asking Prolog to continue and stop searching for a solution, respectively)
1	median(List,Median)	Note that List will always be a list with an odd number of distinct integers. ?- median([7,4,2,8,1,3,6],M). M = 4 ; no ?- median([1,2,3],2). yes ?- median([1,2,3],1). no
IMPORTANT: The assignment handout does not mention this, but you should check that the inputs to setEq are VALID SETS: they should not have repeated elements. Invalid sets (lists with repeated elements) should always cause setEq to fail.
2a	setEq(S1, S2)	Note that you should test that a list is a valid set, i.e., that it does not include duplicate elements. Invalid sets should cause the set comparison to fail. ?- setEq([1,2,3],[2,1,3]). yes ?- setEq([john,paul],[george,ringo]). no ?- setEq([john,paul,john],[paul,john,ringo]). no
2b	setEq(S1, S2)	Note that you should test that a list is a valid set, i.e., that it does not include duplicate elements. Invalid sets should cause the set comparison to fail. ?- setEq( [x,[1,2,3],y], [[2,1,3],y,x] ). yes ?- setEq( [x,[1,2,3],y], [y,[1,2,3]] ). no ?- setEq( [[1,2,3],[3,1,2]], [[1,2,3]] ). no
3	soln([D,E,M,N,O,R,S,Y])	Dots below indicate the single-digit unique solutions found by your code. ?- soln([D,E,M,N,O,R,S,Y]). D = ... E = ... M = ... N = ... O = ... R = ... S = ... Y = ... ; no
4a	subsets(S,PS)	Note that the subsets need not be listed exactly in the order shown. ?- subsets([1,2],PS). PS = [[],[1],[2],[1,2]] ; no
4b	subsets(S,PS)	Note that 4b should also behave like 4a, as the last input shows. ?- subsets([1],[[1],[]]). yes ?- subsets([1],[[1],[2]]). no ?- subsets([1,2],PS). PS = [[],[1],[2],[1,2]] ; no
4c	subsets(S,PS)	The variables used in the solution found by Prolog don't matter as long as PS is the powerset of S (the order of subsets is not important). Note that 4c should also behave like 4a and 4b, as the last inputs show. ?- subsets(S,PS). S = [] PS = [[]] ; S = [_G1] PS = [[], [_G1]] ; S = [_G1, _G2] PS = [[], [_G1], [_G2], [_G1,_G2]] <Enter> yes ?- subsets([1],[[1],[]]). yes ?- subsets([1,2],PS). PS = [[],[1],[2],[1,2]] ; no
4d	subsets(S,PS)	The order of elements in S may not be exactly as shown below, but it should be the same set, and you should only return one solution. Also note that 4d should also behave like 4a, 4b and 4c, as the last inputs show. ?- subsets(S,[[],[1],[2],[1,2]]). S = [1,2] ; no ?- subsets(S,[[],[1],[2],[1,2,3]]). no ?- subsets(S,PS). S = [] PS = [[]] ; S = [_G1] PS = [[], [_G1]] <Enter> yes ?- subsets([1],[[1],[]]). yes ?- subsets([1,2],PS). PS = [[],[1],[2],[1,2]] ; no



• Your submission must work correctly with YAP Prolog installed here in CS on Linux computers (in /s/std/bin/yap). You are free to work with your own version of Prolog which you might have downloaded and installed at home but before submission, you must make sure your code runs with our version of Prolog. If you use Prolog library predicates, please make sure that these predicates are also available in YAP Prolog installed here in CS.
  
  
• You can assume that your predicates will always be passed valid input of the right type, so you do not need to check, for example, that the input argument is a list or a number and so on. But your functions should be able to correctly handle all valid input, including boundary conditions such as empty lists.
  
  

Grading criteria

The first and foremost criteria for grading is correctness. Your programs should execute without errors and produce the correct output with our test suite. Points are awarded for each test input successfully handled by your code.

You can use any algorithms or Prolog predicates to produce the correct output, you are not restricted to following the exact path set by the questions.

No extra points for the most elegant programs but you are encouraged to write in a declarative style, making best use of Prolog's natural abstractions: declarative logic, backtracking, pattern matching and so on. These will invariably reward you with compact, natural-looking code which is easy to read and understand. Tell Prolog what you want, and not how to do it. See the lecture notes and look online for Prolog programs to get a flavor of Prolog programming.

I may penalize programs that are excessively kludgy and hard to read or understand. Don't try to write C++ or Java in Prolog. In particular, the excessive use of the extra-logical predicates and operators (the cut !, fail, assert, retract and their cousins) is frowned upon and will be penalized. Note that this does not apply when the cut operator (!) is required or is natural for controlling backtracking, as with the subsets predicate in Q.4.

Partial credit will be given for programs that seem to be on the right track.

Prolog Tips

Assignment Notes, Hints, FAQ

Q.1

• A simple declarative definition of a median is enough to let Prolog calculate the median. In particular, define what it means to partition a list with an element into two sublists (a simple refinement of the partition predicate shown in class), and then define the median as the element whose partition produces sublists of equal size. Note that the sublists of the partition do not include the partitioning element.
• If you make your code declarative enough, then you can use your predicate to both compute and check medians (as the sample usage shows).

Q.2

• First declare what it means for a set element to be equal to another, then build on that to declare membership, validity and equality predicates for sets.

Q.3

• This is an exercise in constraint satisfaction. Express the known constraints for each digit (at the very least, each variable is constrained to be a single digit; in more constrained cases, you know the actual value of a variable). Express the constraint that the variables have to be distinct. Express the constraint that SEND + MORE = MONEY.
• The goal predicate is the conjunction of all these constraints. Prolog will then search for the answer, in the search space defined by your constraints. Depending on how you define the constraints, the ordering might affect search time, so experiment with the constraint ordering, putting the tightest constraints before the more relaxed ones.

Q.4

• This question is trying to show you the fuzzy nature of inputs and outputs when expressing algorithms in declarative languages, such as Prolog. Declarative specifications of a problem can be used to compute, check, and search for solutions. Normally, one writes an algorithm that does a certain specified task, transforming input data into output data. In Prolog, one specifies the relation that exists between input data and output data but there is no real distinction between input and output. All that matters is that there is a relation between some data items, some of which might be bound to values. Prolog's main goal, at all times, is to search for values of the remaining data items such that the specified relation holds true. Thus solution computation, checking and search all fall out of a single declarative specification given to the Prolog goal seeker.
• In this question, you are led from a straightword algorithmic implementation of the subsets computation, to a declarative specification which can handle any combination of unspecified inputs and outputs. Parts 4a and 4d compute the subsets relation and its inverse, part 4b checks a solution, while part 4c searches for all data that satisfy the relation.
• As a guiding example, look at the factorial example covered in class. The structure of that solution should show you how to solve this question. In particular, the use of var/nonvar checks and the cut (!) operator.
• 4a: [Given Set, compute PowerSet] This is the most straightforward. You can tackle this part in a couple of ways.
  Given a set, express an algorithm to compute its powerset. The core subsets algorithm can be reused from the Scheme code used in class.
  Alternatively, write a declarative specification of the relation that exists between a set and its powerset.
• 4b: [Given Set and PowerSet, check] If you solved part 4a in an algorithmic way, then you might need to extend your predicate to handle checking a given powerset. This is because an algorithm will produce a powerset of a set with elements in a specific order, while the powerset being passed to you may not have the elements in the same order. If you solved part 4a in a declarative way, you might not need to do anything!
• 4c: [Given neither Set nor Powerset, generate] This should just work out of the box if you solved part 4a, with perhaps a few minor changes to remove any checks for variables being ground.
• 4d: [Given Powerset, compute Set] Unless you put a lot of thought into your initial solution, it will probably not work out of the box for this case. It might even find the solution (if there is one) but then it might waste time in searching for another, when none exists. You might have to extend your solution to part 4b, by adding a limit on the size of Set, thus limiting the search space that Prolog traverses.
• It's perfectly OK to divide the solution into special cases, so that your subsets predicate has 4 different clauses handling each of the possible combinations of input and output bindings. However, you should try to merge clauses when you can to make your code small and hopefully more readable. It would be cool to have a single Prolog predicate that handles this question without any special cases. No extra credit for this, though.