Manipulating atomics and clauses

Transcription

1 Manipulating atomics and clauses This lecture revisits recursion, showing how to read input. Then it introduces type testing predicates, atomic term processing term creation and decomposition and clause retrieval and information. Examples used are morphological processing and pretty printing.

2 Type testing predicates Prolog includes a number of type testing predicates. All are evil in the sense that they are less to do with the declarative meaning of the program and more to process of getting a program to work. Some examples are: compound/1 compound(foo(a,b,2)) atomic/1 atomic(foo) var/1 var(a_variable) 5 - Manipulating atomics and clauses 1

3 Atomic term processing - 1 ISO Standard Prolog includes several predicates for doing things to atomics. Finding the length of an atom: atom_length/2 atom_length(foo,length) Constructing/deconstructing atoms: atom_concat/3 atom_concat(abc,xyz,atm) atom_concat(a1, A2, xyz) 5 - Manipulating atomics and clauses 2

4 Atomic term processing - 2 Finding sub-atoms in an atom: sub_atom/5 sub_atom(abcde, X, Y, Z, Sub) sub_atom(abcde, 0, 3, 2, Sub) Length of presub-atom Length of sub-atom Length of postsub-atom 5 - Manipulating atomics and clauses 3

5 Atomic term processing - 3 Breaking atomics into characters: atom_chars/2 atom_codes/2 number_chars/2 number_codes/2 These all run atom_chars(abc, [a,b,c]) both ways atom_codes(abc, [97,98,99]) number_chars(12.3, ['1','2','.','3']) number_codes(12.3, [49,50,46,51]) 5 - Manipulating atomics and clauses 4

6 Reading input from the keyboard Suppose we want to read input from the keyboard until we type a stopping symbol. Thoughts: This will have to be recursive; It is similar to the operation of an while loop stop when a certain input is reached; We should write the terminating clause before the recursive clause. 5 - Manipulating atomics and clauses 5

7 Always write the base (terminating) case first. read_text('.'). (That s all that is needed.) Terminating 5 - Manipulating atomics and clauses 6

8 Recursive The input is the parameter; We need to process the current input; We need to get the next input; We carry on (recursively). read_text(current_word) :- look_up(current_word), read(next_word), read_text(next_word). 5 - Manipulating atomics and clauses 7

9 But where does the first input come from? This procedure assumes that there is always some input in the parameter. Where does the first input come from? start_read_text :- write('enter text: end with ''.'''), nl, read(word), read_text(word). 5 - Manipulating atomics and clauses 8

10 What does look_up/1 do? In the following slides, look_up/1 will be developed into something more ambitious: 1. simple dictionary look-up/unknown word detection; 2. simple-minded morphological analyser. 5 - Manipulating atomics and clauses 9

11 Simple dictionary look-up - 1 First we need a dictionary: lexical_entry(plays, pos(verb), number(singular), person('3rd'), Part-of-speech tense(present)). Grammatical person Grammatical number Tense (of verbs) 5 - Manipulating atomics and clauses 10

12 Simple dictionary look-up - 2 Second the word is found: look_up(word) :- lexical_entry(word, pos(syntactic_category), _Number, _Person, _Tense), write_message(message('word is: ', Word)), write_message(message('pos is: ', Syntactic_Category)), nl. 5 - Manipulating atomics and clauses 11

13 Simple dictionary look-up - 3 Third the word is not found: look_up(word) :- \+ lexical_entry(word, pos(syntactic_category), _Number, _Person, _Tense), write('the word '), write_message(message(word, 'hasn''t been found.')), nl. 5 - Manipulating atomics and clauses 12

14 Introducing morphology But it is very wasteful to have to write dictionary entries for each form of a word. We can use morphological processing to reduce the number of entries. Regular English verbs have standard ending: play plays playing - played A language like Bulgarian can have up to 1,000-3,000 verb forms (depending how you count them). 5 - Manipulating atomics and clauses 13

15 Morphology the idea 1. Have a dictionary of base forms (lemmas) of words. 2. Have a much smaller dictionary of suffixes (morphological endings). 3. Process words by taking off any suffix. Using sub_atom/5 4. Look-up the stem word in the dictionary. 5 - Manipulating atomics and clauses 14

16 The morphological dictionary This looks much the same as the normal dictionary except that the word is now a suffix. morphology(s, pos(noun), number(plural), person('3rd'), tense(_tense)). morphology(s, pos(verb), number(singular) person('3rd'),tense(present)). 5 - Manipulating atomics and clauses 15

17 Morphological matching - 1 The first step is to look-up the word in the dictionary in case the word is not inflected or is a special case. % 1 - word is in the dictionary look_up(word) :- the same code as in the previous example 5 - Manipulating atomics and clauses 16

18 Morphological matching - 2 If the word is not there: look_up(word) :- morphology(suffix, pos(syntactic_category), number(number1), person(person1), tense(tense1)), sub_atom(word, Lemma_Length, Suffix_Length, 0, Suffix), 5 - Manipulating atomics and clauses 17

19 Morphological matching - 3 The end of the word matches a suffix, so look-up the beginning of the word in the dictionary: lexical_entry(lemma, pos(syntactic_category), _Number1, _Person1, _Tense1), write_messages and unknown word code is the same as last time. 5 - Manipulating atomics and clauses 18

20 Making code more readable This query is not like normal Prolog:?- X is 3-2 * / 8. This is the query in normal Prolog:?- X is +(-(3,*(2,4)), /(1,8)). This is not a natural way of writing arithmetic. 5 - Manipulating atomics and clauses 19

21 Making code more readable Sometimes we want to make our code more readable to users. Here, we ll write the sub-category information: pos(noun), number(plural) as: pos : noun, number : plural But Prolog won t like this 5 - Manipulating atomics and clauses 20

22 Operator notation Directives are code that is executed as soon as the compiler reads and compiles it. We need to add a directive to the program: :- op(500, xfy, :). The new operator s functor. Ranking of the operator (1200 is highest) Associativity (Term, Functor More Terms) 5 - Manipulating atomics and clauses 21

23 The dictionary reformatted Now we can rewrite all the dictionary and morphological entries (and the rules that use them) using the new notation: morphology(s, pos : noun, number : plural, person : '3rd', tense : _Tense ). 5 - Manipulating atomics and clauses 22

24 Pretty printing The idea of pretty printing is to output a program in some format that is visually useful. It s easy to write pretty printers in languages like LISP and Prolog because there is a very close relationship between program and data. :- dynamic offset_increment/1, pp_clause/0, etc. offset_increment(5). 5 - Manipulating atomics and clauses 23

25 Displaying terms We need to be able to display terms: pp_term(term, Offset) :- atomic(term), writenl_offset(term, Offset). pp_term(variable, Offset) :- var(variable), writenl_offset(variable, Offset). pp_term(structure, Offset) :- compound(structure), pp_compound(structure,offset). 5 - Manipulating atomics and clauses 24

26 functor/3 and arg/3 functor/3 and arg/3 Decompose a term into parts or build a term from parts:?- functor(foo(a,b), Functor, Arity). Arity = 2, Functor = foo? ;?- functor(term,foo,1), arg(1,term, z). Term = foo(z)? ; 5 - Manipulating atomics and clauses 25

27 Displaying a compound structure Display the head and then the arguments: pp_compound(structure, Offset) :- functor(structure, Functor, Arity), pp_term(functor, Offset), offset_increment(increment), Offset1 is Offset + Increment, writenl_offset('(', Offset1), pp_args(structure, 0,Arity,Offset1), writenl_offset(')', Offset1). 5 - Manipulating atomics and clauses 26

28 Displaying the arguments Display the first then display the rest (like finding friends): pp_args(_structure, Arity,Arity,_Offset). % 2 - recursive pp_args(structure, Count,Arity,Offset) :- Count < Arity, Count1 is Count + 1, arg(count1, Structure, Argument), pp_term(argument, Offset), pp_args(structure, Count1, Arity, Offset). 5 - Manipulating atomics and clauses 27

29 Displaying the whole clause We can develop the search using a stack: clause/2 retrieves a pp_clause(head) :- clause from the program clause(head, Body), pp_compound(head, 0), offset_increment(offset), writenl_offset(' :-', Offset), writenl_offset('(', Offset), pp_body(body, Offset). 5 - Manipulating atomics and clauses 28

30 All that is left is the bodies Recursive clause before terminating here! pp_body((subgoal, Subgoals), Offset) :- pp_compound(subgoal, Offset), pp_body(subgoals, Offset). pp_body(subgoal, Offset) :- Subgoal \= (_,_), pp_compound(subgoal, Offset), writenl_offset(')', Offset). 5 - Manipulating atomics and clauses 29

31 Try the code You should download the code from the module WWW page and run it. Here are some examples:?- pp_clause(offset_increment(_)).?- pp_clause(pp_body(_, _)).?- pp_clause(pp_clause(_)). 5 - Manipulating atomics and clauses 30

32 What this has been about - 1 Type testing predicates Prolog has several: var/1, atomic/1, compound/1 (and others) Not theoretically elegant but useful in getting programs to work efficiently. 5 - Manipulating atomics and clauses 31

33 What this has been about - 2 Atomic term processing Atomics can be manipulated in several ways. Dividing atomics into chars and codes or building them from chars and codes atom_codes/2, number_chars/2, Finding sub atoms: sub_atom/5 5 - Manipulating atomics and clauses 32

34 What this has been about - 3 Clause retrieval and information Clauses can be retrieved from the program database and manipulated, using: clause/2 5 - Manipulating atomics and clauses 33

35 Recursion What this has been about - 4 More of the basic pattern: pp_args/3 Specialized ways of writing recursion when reading input: read_text/1 5 - Manipulating atomics and clauses 34

36 For next time Revise your knowledge of: propositional calculus. 5 - Manipulating atomics and clauses 35