Programming Languages Week 6 Exercises

Transcription

1 Programming Languages Week 6 Exercises 1 Logic programming in Python 1.1 Unification Unification is the process of making two things the same. Unifying an unbound variable and a value makes them the same by binding the value to the variable. Unifying two unbound variables makes them the same by ensuring they always refer to the same value; if either one is bound to a value, the other is automatically bound to it too. Two values can be unified too, provided they are exactly the same value. When unifying two things, we need to know whether the unification was successful. In other words, unification is like asking the question: Can I unify these two values to make them the same? When we combine this question with complex sets of facts about the world, we can often find multiple ways to make two things the same. The question is therefore more correctly stated: In what ways can I unify these two values to make them the same? This sounds like a loop, and that is exactly how we will model it in Python. (Even though unify() only succeeds once, the facts and rules we create with unify() can succeed many times.) The generator function unify(x, Y) will try to find a way to make X and Y the same. If a way is found, it will set X and/or Y (if one or other is a variable) to the correct value(s) and then to allow a loop body to run. In our program we can therefore write: for _ in unify(x, Y): print "do something with", get(x), "and", get(y) (The variable _ is a don t care variable. It has no useful value, and we always ignore it. The strange name is intended to remind us about that.) We can pass any Python values we like as arguments for the parameters X and Y, but we cannot use normal Python variables to store values during unification. (For one thing, our unify generator has to be able to modify the values of any variables that are passed to it as arguments. We therefore have to use value holders, or wrappers, around the actual values the variables are holding.) This only slightly complicates our programs, by requiring that we write or X = var() A, B, C = var(), var(), var() to create and store logic variable objects in our Python variables. It also means we have to use get(x) to retrieve the value stored in a logic variable called X. We should never assume that it is possible to assign to a logic variable. In fact, we never even try to assign to them directly. Instead we unify() them with the value we want to assign and then run some code if the unification succeeds. X = var() for _ in unify(x, 42): print "X was successfully set to", get(x) (In this example, X will be bound to 42 while the loop body runs once. After the loop body has run once, the variable X will be unbound again.) Note the capitalisation of logic variable names. Prolog progammers tend to capitalise their variable names, so we will too. (It also reminds us to use get() to retrieve their values in Python.)

2 1.2 A small unification library For our explorations we will use a small, home-made unification library. It does not do everything a serious logic programming library would do, but it is better for our needs because it implements the core mechanism of languages like Prolog, while being small enough to understand completely. 0. Open your favorite text editor 1 and enter the following program. Save it in a file called unify.py. class var(): def init (self): self. bound = False self.value= None def _assign(v, x): # _assign to remind people to use unify instead if not v. bound: v. value = x v. bound = True v. bound = False def get(v): if isinstance(v, var) and v. bound: return get(v. value) return v def unify(l, R): Lval, Rval = get(l), get(r) if isinstance(lval, var): for _ in _assign(lval, Rval): elif isinstance(rval, var): for _ in _assign(rval, Lval): else: if Lval == Rval: Then add this line to the beginning of any Python program you write that uses unification: from unify import * (You can download an annotated version of this library, with detailed comments explaining how it works, from here: 1. Try the following examples, to get a feel for how unify() works. from unify import * for _ in unify(123, 123): print "yay it works" for _ in unify(123, 321): print "boo it broke" You can see that unify() succeeds only when it can make its two arguments mean the same thing. 1 On Mac, TextEdit.app will work fine provided you make sure it is in plain text mode. On Windows you can download the free Notepad++ editor (from for editing code. (The Microsoft Notepad application is not recommended for anything more ambitious than making a shopping list, and even for that it is borderline useless.) Of course, on any platform, Emacs is by far the best choice if you are comfortable with it. 2

3 X = var() for _ in unify(x, 66): print get(x) for _ in unify(99, X): print get(x) These two succeed because unify can just assign the unbound variable X to the other argument (a literal value) to make them the same. If you now try print get(x) you will see that X is no longer bound to any value (and when printed it reports its true nature as a unify.var ). Y = var() for _ in unify(x, 66): for _ in unify(x, Y): print get(x), get(y) for _ in unify(x, Y): for _ in unify(x, 99): print get(x), get(y) These two examples demonstrate that it does not matter which order you unify two variables and a literal. Unifying one variable with a literal and then with another variable is the same as unifying the two variables first followed by unifying one of them to the literal. Z = var() for _ in unify(x, Y): for _ in unify(y, Z): for _ in unify(x, 1): print get(x), get(y), get(z) for _ in unify(y, 2): print get(x), get(y), get(z) for _ in unify(z, 3): print get(x), get(y), get(z) This example demonstrates that any number of variables can be unified. When any one of them is finally unified with a value, all of them immediately become bound to the same value. 2. Create a generator iseven(x) that unifies X with every even number between 0 and 8. The naïve solution to this exercise looks like this: def iseven(x): for _ in unify(x, 0): for _ in unify(x, 2): for _ in unify(x, 4): for _ in unify(x, 6): for _ in unify(x, 8): But remember that you can put anything you like inside your generator functions, including a normal for loop over a range of integers that are individually unified with a logic variable. Just remember to whenever you want to succeed with a new assignment of your argument variable(s). (In other words, re-write the above naïve solution to use a for and range instead.) Test your generator like this: for _ in iseven(x): print get(x), "is even" #=> [02468] is even 3

4 3. Write a generator istriple(x) that unifies X with every multiple of 3 between 0 and 9. Test it with: def istriple(n):... # fill in the blank for _ in istriple(x): print get(x), "is a multiple of 3" 4. Define generators that check for multiples of 2 or 3, and multiples of 2 and 3. (Do not use Python s built-in operators, such as or and and.) Test your generators like this: def mult2or3(x):... # fill in the blank def mult2and3(x):... # fill in the blank for _ in mult2or3(x): print get(x), "is multiple of 2 or 3" #=> [ ] is a multiple of 2 or 3 for _ in mult2and3(x): print get(x), "is multiple of 2 and 3" #=> [06] is multiple of 2 and 3 (Note that the order of your results will probably be different, but should contain the same digits.) 1.3 Creating a knowledge base and asking questions about it A knowledge base contains facts and rules. Facts are statements about concrete things and their properties. We can make some simple factual statements about the Clinton family using unify() Write a generator isclinton(p) that generates a sequence of strings: Bill, Hillary, and Chelsea. Here is one way to do it: def isclinton(p): for _ in unify(p, "Bill") : for _ in unify(p, " Hillary") : for _ in unify(p, " Chelsea") : Test your generator: Person = var() for _ in isclinton( Person): print get( Person), "is a Clinton" Note the name isclinton suggests a predicate. This is deliberate. You can read the above example as: For all values of Person that satisfy isclinton, run the print statement. If you think of unify as being the predicate are the same thing, the following should be easy to understand: for _ in isclinton( Person): for _ in unify(person, " Hillary"): print " there is a Clinton who has the name Hillary" for _ in unify(person, " Hillary"): for _ in isclinton( Person): print "the person who has the name Hillary is a Clinton" for _ in unify(person, " George"): for _ in isclinton( Person): print " George has infiltrated the Clinton family!" 2 There are no particular reasons for choosing the Clinton family, other than their convenient family tree and the number 42. 4

5 Facts can include statements about the simple relationships between things. For example, we know that Hillary has two brothers and Bill has one. 6. Write a generator function hasbrother(person, Brother) which embodies the facts that Hillary has brothers named Tony and Hugh, and that Bill has a brother named Roger. def hasbrother(person, Brother): for _ in unify(person, "Bill"): for _ in unify(brother, " Roger"):... # fill in the missing part for Hillary Test your new facts like this: Brother = var() for _ in hasbrother(person, Brother): print get( Person), "has a brother", get( Brother) #=> Bill has a brother Roger #=> Hillary has a brother Tony #=> Hillary has a brother Hugh 7. Write a generator function hasparent(person, Parent) which embodies the fact that Hillary and Bill are the parents of Chelsea. Test your generator like this: def hasparent(person, Parent):... # fill in the blank Parent = var() for _ in hasparent(person, Parent): print get( Person), "has a parent named", get( Parent) #=> Chelsea has a parent named Hillary #=> Chelsea has a parent named Bill Rules are statements about how things can be related according to their properties. The simplest kinds of rule say that some relationship is true if two facts are true at the same time. 8. Write a generator function hasuncle(n, U) that states the following general rule: if a nephew/niece N has a parent P, and if P has a brother U, then U is the uncle of N. Use your rule to check who has an uncle in the Clinton family, like this: def hasuncle(person, Uncle):... # fill in the blank Uncle = var() for _ in hasuncle(person, Uncle): print get( Person), "has an uncle", get( Uncle) #=> Chelsea has an uncle Tony #=> Chelsea has an uncle Hugh #=> Chelsea has an uncle Roger 5

6 1.4 A more complex example Consider this partial family tree of the House of Stuart (who were, once upon a long time ago, the kings and queens of Scotland, England, Ireland, and even parts of France). James I Charles I Elizabeth Catherine Charles II James II Sophia George I 9. Create generators ismale(p) and isfemale(p) that state facts about names of the male and female Stuarts, and hasparent(child, Parent) that states facts about their lineage. def ismale(p):... # fill in the blank def isfemale(p):... # fill in the blank def hasparent(child, Parent):... # fill in the blank 10. Write a generator isperson(p) that represents the following rule: P is a (Stuart) person if they are a male Stuart or a female Stuart. def isperson(p):... # fill in the blank Test your facts and rule: X = var() for _ in isperson(x): print get(x), "is a person" #=> James I is a person #=> Charles I is a person #=> Charles II is a person #=> James II is a person #=> George I is a person #=> Elizabeth is a person #=> Catherine is a person #=> Sophia is a person 6

7 11. Write a rule hasmother(child, Mother) which states that Mother must be a female parent of Child. Write another similar rule hasfather(child, Father). Test your rules: def hasmother(child, Parent):... # fill in the blank def hasfather(child, Parent):... # fill in the blank Y = var() for _ in hasmother(x, Y): print get(x), "has mother", get(y) for _ in hasfather(x, Y): print get(x), "has father", get(y) #=> Sophia has mother Elizabeth #=> George I has mother Sophia #=> Charles I has father James I #=> Elizabeth has father James I #=> Catherine has father Charles I #=> Charles II has father Charles I #=> James II has father Charles I 12. Write a rule haschild(parent, Child). (Think how to do this in the laziest way possible. You already have all the facts you need, so this rule should be very simple.) Test your rule: def haschild(parent, Child):... # fill in the blank for _ in haschild(x, Y): print get(x), "has child", get(y) Verify your answers against the family tree diagram. 13. Write the rule hasgrandparent(grandchild, Grandparent). def hasgrandparent( Grandchild, Grandparent):... # fill in the blank for _ in hasgrandparent(x, Y): print get(x), "has grandparent", get(y) Verify your answers against the family tree diagram. 14. Write the rule hasgreatgrandparent(grandchild, Greatgrandparent). def hasgreatgrandparent(c, GGP):... # fill in the blank for _ in hasgreatgrandparent(x, Y): print get(x), "has great - grandparent", get(y) Verify your answers against the family tree diagram. 15. Write rules for hassibling(person, Sibling), hassister(person, Sister), and hasbrother (Person, Brother). (Since brothers and sisters have the same parents, you can infer the answers without stating any more facts.) def hassibling(a, B):... # fill in the blank def hassister(a, B):... # fill in the blank def hasbrother(a, B):... # fill in the blank for _ in hasbrother(x, Y): print get(x), "has a brother", get(y) for _ in hassister (X, Y): print get(x), "has a sister", get(y) for _ in hassibling(x, Y): print get(x), "has a sibling", get(y) Verify your answers against the family tree diagram. 7

8 16. Your cousin is the son or daughter of your uncle or aunt. Your uncles and aunts are the brothers and sisters of your parents. Write a rule to find all the cousins in the House of Stuart. def hasuncle(a, B):... # fill in the blank def hasaunt(a, B):... # fill in the blank def hascousin(a, B):... # fill in the blank for _ in hascousin(x, Y): #=> Sophia has cousin Catherine #=> Sophia has cousin Charles II #=> Sophia has cousin James II #=> Catherine has cousin Sophia #=> Charles II has cousin Sophia #=> James II has cousin Sophia print get(x), " has cousin", get(y) 1.5 A completely different example The following progam creates a database describing stations on train lines around Kyoto. It then states some general rules about direct and indirect journeys between train stations. Lines = { "Biwako": ["Takatsuki", "Kyoto", "Yamashina", "Otsu", "Ishiyama", "Kusatsu"], "Kosei": ["Kyoto", "Yamashina", "Otsukyo", "Karasaki", "Sakamoto", "Ogoto -onsen"] } def hasstation(l, S): for line in Lines: for _ in unify(l, line): for station in Lines[ line]: for _ in unify(s, station): def direct(a, B): L = var() for _ in hasstation(l, A): for _ in hasstation(l, B): def indirect(a, B): for _ in direct(a, B): return # fail if there is any direct train def changeat(a, B, C): for _ in direct(a, C): for _ in direct(c, B): for _ in indirect(a, B): The final part of this example asks about several journeys, printing whether there is a direct connection between the origin and destination, or the names of the stations where a change of train allows the journey to be made indirectly. Type in the above facts and rules, then run the following queries: C = var() for a, b in [ ("Takatsuki", "Kusatsu"), ("Takatsuki", "Kyoto"), ("Takatsuki", "Otsukyo"), ("Yamashina", "Sakamoto"), ("Otsukyo", "Sakamoto") ]: for _ in direct(a, b): print " from", a, " to", b, " there is a direct train" for _ in changeat(a, b, C): print " from", a, " to", b, " change at", get(c) 17. Add facts about the Keihan (Sakamoto) line, which passes through these stations: Ishiyamadera, Zeze, Hamaotsu, Ano, Sakamoto. Add a rule describing how to change trains twice to make a journey. Ask your system how to travel from Takatsuki to Hamaotsu. (There should be only two routes.) 18. At each change of train, print the names of the arrival and departure lines. 8