1. Prolog for Linguists Symbolic Systems 139P/239P John Dowding Week 4, October 29, 2001 jdowding@stanford.edu

2. Office Hours We have reserved 4 workstations in the Unix Cluster in Meyer library, fables 1-4 Skipping 4:30-5:30 on Thursday this week Friday 3:30-4:30, after NLP Reading Group this week If not, contact me and we can make other arrangements

3. Course Schedule 1. Oct. 8 2. Oct. 15 3. Oct. 22 4. Oct. 29 5. Nov. 5 (double up) 6. Nov. 12 7. Nov. 26 (double up) 8. Dec. 3 No class on Nov. 19

4. Homework By now, we have covered most of Chapters 3 and 4 of Clocksin and Mellish. Read them and let me know if you have any questions. Homework to be handed in by noon on the 29 th.

5. subterm/2 % subterm(+SubTerm, +Term) subterm(Term1, Term2):- Term1 == Term2, !. subterm(SubTerm, Term):- compound(Term), functor(Term, _Functor, Arity), subterm_helper(Arity, SubTerm, Term).

6. subterm_helper/3 % subterm_helper(+Index, +SubTerm, +Term) subterm_helper(Index, SubTerm, Term):- Index > 0, arg(Index, Term, Arg), subterm(SubTerm, Arg), !. subterm_helper(Index, SubTerm, Term):- Index > 0, NextIndex is Index - 1, subterm_helper(NextIndex, SubTerm, Term).

7. occurs_in/2 % occurs_in(-Var, +Term) occurs_in(Var, Term):- var(Var), Var == Term, !. occurs_in(Var, Term):- compound(Term), functor(Term, _Functor, Arity), occurs_in_helper(Arity, Var, Term).

8. occurs_in_helper/3 %occurs_in_helper(+Index, -Var, +Term) occurs_in_helper(Index, Var, Term):- Index > 0, arg(Index, Term, Arg), occurs_in(Var, Arg). occurs_in_helper(Index, Var, Term):- Index > 0, NextIndex is Index - 1, occurs_in_helper(NextIndex, Var, Term).

9. (Or) occurs_in/2 % occurs_in(-Var, +Term):- occurs_in(Var, Term):- var(Var), subterm(Var, Term).

10. replace_all/4 % replace_all(+Element, +Term, +NewElement, -ResultTerm) replace_all(Element, Term, NewElement, NewElement):- Element == Term, !. replace_all(_Element, Term, _NewElement, Term):- atomic(Term). replace_all(_Element, Term, _NewElement, Term):- var(Term). replace_all(Element, Term, NewElement, ResultTerm):- compound(Term), functor(Term, Functor, Arity), functor(ResultTerm, Functor, Arity), replace_all_helper(Arity, Element, Term, NewElement, ResultTerm).

11. replace_all_helper/5 replace_all_helper(0, _Element, _Term, _NewElement, _ResultTerm):- !. replace_all_helper(Index, Element, Term, NewElement, ResultTerm):- arg(Index, Term, Arg), arg(Index, ResultTerm, ResultArg), replace_all(Element, Arg, NewElement, ResultArg), NextIndex is Index - 1, replace_all_helper(NextIndex, Element, Term, NewElement, ResultTerm).

12. flatten/2 % flatten(+List, -ListOfAtoms). flatten([], []) :- !. flatten(Atomic, [Atomic]):- atomic(Atomic). flatten([Head|Tail], ListOfAtoms):- flatten(Head, ListOfAtoms1), flatten(Tail, ListOfAtoms2), append(ListOfAtoms1, ListOfAtoms2, ListOfAtoms).

13. flatten_dl/2 % flatten_dl(+List, -ListOfAtoms) flatten_dl(List, ListOfAtoms):- flatten_dl_helper(List, (ListOfAtoms-[])). % flatten_dl_helper(+List, +DelayList) flatten_dl_helper([], (Empty-Empty)):- !. flatten_dl_helper(Atomic, ([Atomic|Back]-Back)):- atomic(Atomic). flatten_dl_helper([Head|Tail], (Front-Back)):- flatten_dl_helper(Head, (Front-NextBack)), flatten_dl_helper(Tail, (NextBack-Back)).

14. Could have written subterm/2 as: %subterm(+SubTerm, +Term) subterm(SubTerm, Term):- replace_all(SubTerm, Term, _AnyThing, NewTerm), \+ Term == NewTerm. But this would be slower

15. Accumulators Build up partial results to return at the end list_length([], 0). list_length([_Head|Tail], Result):- list_length(Tail, N), Result is N +1. list_length(List, Result) :- list_length_helper(List, 0, Result). list_length_helper([], Result, Result). list_length_helper([_Head|Tail], Partial, Result):- NextPartial is Partial + 1, list_length_helper(Tail, NextPartial, Result).

16. flatten/2 with an accumulator %flatten_acc(+ListOfLists, -ListOfAtoms) flatten_acc(List, ListOfAtoms):- flatten_acc_helper(List, [], ListOfAtoms). %flatten_acc_help(+ListOfLists, +PartialResult, -FinalResult) flatten_acc_helper([], PartialResult, PartialResult):- !. flatten_acc_helper(Atomic, Partial, [Atomic|Partial]):- atomic(Atomic), !. flatten_acc_helper([Head|Tail], PartialResult, FinalResult):- flatten_acc_helper(Tail, PartialResult, NextResult), flatten_acc_helper(Head, NextResult, FinalResult).

17. Difference Lists Use two logical variables that point to different portions of the same list. Compare stacks with queues:

18. Queues Queue represented as a pair of lists (Front-Back) Back is always a variable %empty_queue(?Queue) – true if the queue is empty empty_queue(Queue-Queue). %add_to_queue(+Element, +Queue, -NewQueue) add_to_queue(Element, (Front-[Element| Back]), (Front-Back)). %remove_from_queue(+Queue, -Element, -NewQueue) remove_from_queue(([Element|Front]-Back), Element, (Front-Back)).

19. Generate-and-Test Popular (and sometimes efficient) way to write a program. Goal :- Generator, - generates candidate solutions Tester. - verifies correct answers

20. One more generate and test example N-Queens Problem

21. Unification Two terms unify iff there is a set of substitutions of variables with terms that makes the terms identical True unification disallows cyclic terms: X=f(X) ought to fail because there is no finite term that can substitute for X to make those terms identical. This is called the occurs check. Prolog unification does not enforce the occurs check, and may create cyclic terms Occurs check is expensive O(n) – n is the size of the smaller of the two terms O(n+m) – n and m are the sizes of the two terms In Prolog, it is quite typical to unify a variable with a larger term

22. unify_woc/2 (with occurs check) %unify_woc(?Term1, ?Term2) unify_woc(Var1, Term2):- var(Var1), !, \+ occurs_in(Var1, Term2), Var1 = Term2. unify_woc(Term1, Var2):- var(Var2), !, \+ occurs_in(Var2, Term1), Var2 = Term1. unify_woc(Atomic1,Atomic2):- atomic(Atomic1), atomic(Atomic2), !, Atomic1 == Atomic2. unify_woc(Term1, Term2):- compound(Term1), compound(Term2), functor(Term1, Functor, Arity), functor(Term2, Functor, Arity), unify_woc_helper(Arity, Term1, Term2).

23. unify_woc_helper/3 % unify_woc_helper(+Index, +Term1, +Term2) unify_woc_helper(0, _Term1, _Term2):- !. unify_woc_helper(Index, Term1, Term2):- arg(Index, Term1, Arg1), arg(Index, Term2, Arg2), unify_woc(Arg1, Arg2), NextIndex is Index - 1, unify_woc_helper(NextIndex, Term1, Term2).

24. More about cut! Common to distinguish between red cuts and green cuts Red cuts change the solutions of a predicate Green cuts do not change the solutions, but effect the efficiency Most of the cuts we have used so far are all red cuts %delete_all(+Element, +List, -NewList) delete_all(_Element, [], []). delete_all(Element, [Element|List], NewList) :- !, delete_all(Element, List, NewList). delete_all(Element, [Head|List], [Head|NewList]) :- delete_all(Element, List, NewList).

25. Green cuts Green cuts can be used to avoid unproductive backtracking % identical(?Term1, ?Term2) identical(Var1, Var2):- var(Var1), var(Var2), !, Var1 == Var2. identical(Atomic1,Atomic2):- atomic(Atomic1), atomic(Atomic2), !, Atomic1 == Atomic2. identical(Term1, Term2):- compound(Term1), compound(Term2), functor(Term1, Functor, Arity), functor(Term2, Functor, Arity), identical_helper(Arity, Term1, Term2).

26. Technique: moving unifications after the cut % parent(+Person, -NumParents) parent(adam, 0):- !. parent(eve, 0):- !. parent(_EverybodyElse, 2). The goal parent(eve, 2). Succeeds % parent(+Person, ?NumParents). parent(adam, NumParent):- !, NumParents = 0. parent(eve, NumParent):- !, NumParent = 0. parent(_EverybodyElse, 2).

27. Last Call Optimization Generalization of Tail-Recursion Optimization Turns recursions into iteration by reusing stackframe When about to execute last Goal in a clause, If there are no more choices points for the predicate, And no choice points from earlier Goals in clause delete_all(_Element, [], []). delete_all(Element, [Element|List], NewList) :- !, delete_all(Element, List, NewList). delete_all(Element, [Head|List], [Head|NewList]) :- delete_all(Element, List, NewList).

28. Advice on cuts Dangerous, easy to misuse Rules of thumb: Use sparingly Use with as narrow scope as possible Know which choice points you are removing Green cuts may be unnecessary, sometimes the compiler can figure it out.

29. Input/Output of Terms Input and Output in Prolog takes place on Streams By default, input comes from the keyboard, and output goes to the screen. Three special streams: user_input user_output user_error read(-Term) write(+Term) nl

30. Example: Input/Output repeat/0 is a built-in predicate that will always resucceed % classifing terms classify_term :- repeat, write('What term should I classify? '), nl, read(Term), process_term(Term), Term == end_of_file.

31. I/O Example (cont) process_term(Atomic):- atomic(Atomic), !, write(Atomic), write(' is atomic.'), nl. process_term(Variable):- var(Variable), !, write(Variable), write(' is a variable.'), nl. process_term(Term):- compound(Term), write(Term), write(' is a compound term.‘), nl.

32. Streams You can create streams with open/3 open(+FileName, +Mode, -Stream) Mode is one of read, write, or append. When finished reading or writing from a Stream, it should be closed with close(+Stream) There are Stream-versions of other Input/Output predicates read(+Stream, -Term) write(+Stream, +Term) nl(+Stream)

33. Characters and character I/O Prolog represents characters in two ways: Single character atoms ‘a’, ‘b’, ‘c’ Character codes Numbers that represent the character in some character encoding scheme (like ASCII) By default, the character encoding scheme is ASCII, but others are possible for handling international character sets. Input and Output predicates for characters follow a naming convention: If the predicate deals with single character atoms, it’s name ends in _char. If the predicate deals with character codes, it’s name ends in _code. Characters are character codes is traditional “Edinburgh” Prolog, but single character atoms were introduced in the ISO Prolog Standard.

34. Special Syntax I Prolog has a special syntax for typing character codes: 0’a is a expression that means the character codc that represents the character a in the current character encoding scheme.

35. Special Syntax II A sequence of characters enclosed in double quote marks is a shorthand for a list containing those character codes. “abc” = [97, 98, 99] It is possible to change this default behavior to one in which uses single character atoms instead of character codes, but we won’t do that here.

36. Built-in Predicates: atom_chars(Atom, CharacterCodes) Converts an Atom to it’s corresponding list of character codes, Or, converts a list of CharacterCodes to an Atom. put_code(Code) and put_code(Stream, Code) Write the character represented by Code get_code(Code) and get_code(Stream, Code) Read a character, and return it’s corresponding Code Checking the status of a Stream: at_end_of_file(Stream) at_end_of_line(Stream)

37. Tokenizer A token is a sequence of characters that constitute a single unit What counts as a token will vary A token for a programming language may be different from a token for, say, English. We will start to write a tokenizer for English, and build on it in further classes

38. Tokenizer for English Most tokens are consecutive alphabetic characters, separated by white space Except for some characters that always form a single token on their own:. ‘ ! ? -

39. Homework Read section in SICTus Prolog manual on Input/Output This material corresponds to Ch. 5 in Clocksin and Mellish, but the Prolog manual is more up to date and consistent with the ISO Prolog Standard Improve the tokenizer by adding support for contractions can’t., won’t haven’t, etc. would’ve, should’ve I’ll, she’ll, he’ll He’s, She’s, (contracted is and contracted has, and possessive) Don’t hand this in, but hold on to it, you’ll need it later.