proof through refutation

Transcription

1 Prolog's logic; resolution grammars & parsing 1 proof through refutation we saw that Prolog uses the strategy: test the claim that a query is false by (1) finding it is immediately true (matches a fact or chain of rules) or (2) by finding values for its variables which makes it true 2

2 refutation as "cancellation" P, ~Q will refute P implies Q ~P v Q P Q ~Q_ [] = false (why?) this "cancellation" process is called resolution in computational logic covered in detail in Ch resolution as inference modus ponens P and P implies Q resolves to Q modus tollens P implies Q and ~Q resolves to ~P: ~P v Q ~Q ~P 4

3 answers as "resolvents" Prolog answers a query by resolving the query against the database recursively until all subgoals are eliminated :- G1, G2. = ~(G1 & G2) = ~G1 v ~G2 suppose G1 can be unified with a fact F 'cancel' ~G1 resolvent = (~G2)s, where s is the unifier: (Fs and ~G1s v ~G2s) =~G2s because Fs = G1s * Xs means the same as s(x) = X with substitutions for variables 5 recursive resolution suppose G2s can be unified with the head of a rule H :- H1, H2. (G2s)t = Ht resolve ~(G2s)t against ~H1t v ~H2t v Ht yielding ~H1t v~h2t take ~H1t as a new query. if it can be refuted by resolution against the database, see if ~H2t can be refuted if so, the query G1, G2 succeeds with unifier st 6

4 recap :- G1, G2,.. Gn. = ~(G1 and G2... and Gn) = ~G1 or ~G2.. or ~Gn to refute this, we need to prove each disjunct is false; if each goal Gi can be cancelled (using the database), then resolvent = [] = false, and refutation succeeds 7 grammars and parsing 8

5 character processing text = list of characters in Prolog: a list of ASCII values to manipulate text in a procedural language involves complex coding, using substring extraction, searching for character sequences, construction using concatenation and append functions requires low-level memory management to hold variable-length data; complex flow of control 9 prolog & text-processing Prolog is well-suited for analyzing and generating text: parsing involves pattern-matching recursion parse-trees are recursive data structures backtracking text patterns involve many interrelated alternatives non-determinate goals 10

6 grammars grammatical rules used for analysis = parsing & synthesis = generation; fits Prolog's "invertibility" of predicates parsing = checking if list fits pattern; generation = binding variable to list which fits a pattern grammars as rules are main descriptive tool for linguists as well as language designers called generative grammars in linguistics 11 definite clause grammars 12

7 DCGs Prolog provides a special notation for grammar rules DCGs = definite clause grammars Prolog rules are definite clauses head = single (definite) goal as opposed to a disjunction can't write G1 ; G2 :- conditions. can't represent "conditions imply either G1 or G2". 13 DCG rules DCG rules are written goal --> subgoal, subgoal,.. the goal represents a pattern to be satisfied by a list the subgoals are patterns, concatenated together by,, does not mean logical and 14

8 useful example break([], Stop) --> Stop. break([c Rest], Stop) --> [C], break(rest, Stop). break(seq, ".") binds Seq to a sequence of characters up to the first "." fails if no "." in the list to which the rule is applied. 15 how to invoke a DCG pattern head -->... represents the Prolog rule head(.., List, Tail) :-... with two hidden arguments: (1) list to which the pattern is applied as a prefix, (2) portion of the list left unmatched if the pattern succeeds?- break(words, ".", "Two words.", LeftOver). 16

9 ?- break(words, ".", "Two words.", []), string_to_list(string, Words). Words = [84, 119, 111, 32, 119, 111, 114, 100, 115] String = "Two words" 17 examples rules to parse entries in a Web log: [06/Oct/2005:08:52: ] "GET/Courses/3402/course-desc.html HTTP/1.0" date(date) --> "[", break(date, ":"). oper(oper) --> break(_, """"), break(oper, "/"). 18

10 preprocessing DCG rules are translated into regular Prolog clauses when they are consulted:?- listing(break/4). break([], A, B, C) :- phrase(a, B, C). % same as break([], A) --> A. % phrase(a, B, C) = A(B, C). break([a B], C, D, E) :- 'C'(D, A, F), break(b, C, F, E). % same as break([a B], C) --> [A], break(b, C). % D is the matched portion, E is the left-over?- listing('c'/3). 'C'([A B], A, B). % [A B] = A concatenated with B 19 the basic concatenation relation 'C' = concatenation relation defined by the general fact: 'C'([X Y], X, Y). 'C'(A, B, C) means "A is analyzable into an element B concatenated with a list C." 'C'(A,109,C), 'C'(C,97,D),'C'(D,116,E) says "A is the concatenation of 109, 97, 116 with E." 20

11 analogy to macro Prolog's preprocessing capability is roughly analogous to Lisp's DEFMACRO; extends the language by applying a program to a piece of program to translate it into the underlying notation; but not as convenient as macros 21