Introduction

On Monday, we continued to discuss Prolog.
We looked at lists in Prolog and showed how we could come up with rules for an append predicate that could be used to concatenate two lists.
We looked at various built-in predicates in Prolog, including those for input and output such as read, get0, tell, etc, and predicates for meta-programming, such as assert, retract, call, clause, functor, etc.
We then talked about !, called cut, which, when crossed in the body of Prolog rule, prevents backtracking for the goal in the head of the rule.
We showed how not(X) could be defined using cut, and call.
We also gave a use-case situation involving heads of state where cut could be used to prevent backtracking for situations where we know in advance there will be only one solution.
Today, we begin by investigating more of the properties of cut.

Using Cut With Recursion

Consider the program:

sum_up(1,1) :-!.
sum_up(N,X) :- N1 is N-1,
               sum_up(N1,X1),
               X is X1+N.

This program is supposed to sum_up the the numbers from 1 to N. So sum_up(4,X) return X=10.
Using sum_up(1,1). rather than sum_up(1,1) :-!., could lead to problems if we ever attempted to resatisfy the goal sum_up(4,X).
If we try to resatisfy sum_up(4,X), it would first try to resatisfy sum_up(1,1) using the second sum_up clause causing an infinite loop.
Just like Scheme compilers/interpreters, many Prolog compiler/interpreters support tail-recursion optimization. As the last goal in the body of the rule above is not sum_up, the above code is not tail recursive.

One last example of the use of cut is the following:

repeat.
repeat :-repeat.

some_predicate :- initialize,
                  repeat,
                  do_action,
                  again?,
                  !,
                  shut_down.
.../*code of rest of program */

The predicate repeat is actually built-in but we give its definition for clarity sake.
Because of the repeat clause, we would keep doing do_action until the again? clause was satisfied.
At this point some_predicate does whatever it needs to shut down and then can no longer be satisfied.

Generate and Test

The use of repeat followed by a check followed by a cut on the previous slide shows how we can fake while like loops using Prolog.
To simulate for-loops, we first create a predicate that generates the values of the for-loop. For example:
```
natural(0).
natural(N) :- natural(M), N is M+1.
```
We then use a second predicate that has a test-cut combination to check the boundary condition of the for-loop:
```
my_for_loop(N) :- natural(I),
                  write(I), nl,
                  I = N, !.
```
This approach of using an unbounded generator together with a test-cut is known as the generate-and-test idiom.

Green versus Red Cuts

Prolog is supposed to be a declarative language - our programs declare what we know about the world. We use our program to ask for answers to queries about the world where we are not concerned the details about how the interpreter of our program finds those answers.
Some uses of cut match this paradigm. For example, we can define a minimum function with the rules:
```
min(X,Y,X) := X <= Y, !.
min(X,Y,Y) := X > Y, !.
```
A cut which doesn't affect the solutions found by a Prolog program is called a green cut. Otherwise, a cut is red.

For example, consider:

hd_of_state(bob,elbonia) :- !.
hd_of_state(anne,outland) :- !.
hd_of_state(gilbert,mordor) :- !.
hd_of_state(sally,frisia) :- !.

The query hd_of_state(X,Y) would have a different meaning with the cuts versus without. So these cuts are red. When we originally gave this example, we said we assume we'd never query these rules with both arguments variables, if we could somehow guarantee this the cuts would have been green.
More generally, if to understand the output behaviors of a program with cut, we have to reason about the operations the Prolog Interpreter would perform (look at the operational semantics), we can view the cut as red .
So a cut like:
```
my_for_loop(N) :- natural(I),
                  write(I), nl,
                  I < N, !.
```
is red. With the cut, after returning one solution, it will terminate, without the cut it won't, so the output behaviors are different.

In-Class Exercise

Write a Prolog program using the generate and test idiom that outputs on a new line every prime less that 100.
Post your solution to the Dec 1 In-Class Exercise Thread.

Compilers in Prolog

In writing a compiler for a language or a program to reason about a natural language it is useful to write a grammar for that language and then write parsers for this grammars.
Prolog makes it easy to write parsers for such grammars.

First we given an example of how to write a grammar without using any of Prolog's built-in facilities.

sentence(Input,AfterS) :- noun_phrase(Input,AfterNP),
                          verb_phrase(AfterNP,AfterS).

noun_phrase(Input,AfterNP) :- determiner(Input,AfterDet),
                               noun(AfterDet,AfterNP).

verb_phrase(Input,AfterVP) :- verb(Input,AfterVP).
verb_phrase(Input,AfterVP) :- verb(Input,AfterVerb),
                               noun_phrase(AfterVerb,AfterVP).

determiner([the|AfterDet],AfterDet).
determiner([a|AfterDet],AfterDet).

noun([cat|AfterN],AfterN).
noun([milk|AfterN],AfterN).

verb([drinks|AfterV],AfterV).
verb([licks|AfterV],AfterV).

We could use the above program to check if the list [the, cat, licks] is a sentence by entering the query | ?-sentence([the, cat, licks],[]).
Prolog would then try to satisfy the goal noun_phrase([the,cat,licks], AfterNP) which would invoke the goal determiner([the,cat,licks],AfterDet).
Using the first fact concerning the predicate determiner, Prolog would set AfterDet=[cat,licks] and the determiner goal would be satisfied.
Prolog would then try to satisfy the goal noun([cat,licks],AfterNP).
Using the first fact concerning the predicate noun, Prolog would satisfy this goal by setting AfterN=AfterNP=[licks]. So the noun_phrase goal of the sentence rule is satisfied.
Prolog would then try to satisfy verb_phrase([licks],[]). It's not too hard to see it can do this. So Prolog would answer this query yes.
It is interesting the query | ?-sentence(X,[]) can be used to generate all sentences which satisfy the above set of rules.

Prolog's Built-in Grammar Facilities

The above program can be rewritten using Prolog's built-in grammar facilities as:

sentence --> noun_phrase, verb_phrase.

noun_phrase --> determiner, noun.

verb_phrase --> verb.
verb_phrase --> verb, noun_phrase.

determiner --> [the].
determiner --> [a].

noun --> [cat].
noun --> [milk].

verb --> [drinks].
verb --> [licks].

Prolog will internally translate the above list of grammar rules into the Prolog clauses we had earlier.
So we could check if [the, cat, licks] satisfies the predicate sentence by doing the the query: | ?-sentence([the, cat, licks],[]).
Alternatively, we could use the built-in predicate phrase and the query | ?- phrase(sentence,[the,cat,licks]).
We can use the query phrase(sentence, X) to list out all the lists which could be generated by our grammar. We could have abbreviated the two lines :
```
verb_phrase --> verb.
verb_phrase --> verb, noun_phrase.
```
as
```
verb_phrase --> verb | verb, noun_phrase.
```

Definite Clause Grammars

The grammar of the previous slide is of a type known as a context-free grammar, a CFG's.

A CFG has rules all of the form:

[non-terminal] --> list of [non-terminal]s and [terminal]s.

Here sentence is a [non-terminal] and [cat] is a [terminal].

In general, a grammar can have rules of the form:

list of [terminal]s and [non-terminal]s -> list of [terminal]s and [non-terminal]s.

Definite Clause Grammars (DCG's)

A DCG is a grammar with rules of the form:

[non-terminal] -->list of [terminal]s, [non-terminal]s,

and Prolog rules or of the form:

[non-terminal],[terminal] --> list of [terminal]s, [non-terminal]s, and Prolog goals.

Non-terminals are allowed to be Prolog predicates.
After the internal translation is done a k-ary predicate in a DCG will become a k+2-ary Prolog predicate.

Definite Clause Grammar Example

As an example of a program that exploits Prolog goals, we give a program that can be used to convert a number less than 100 into its English equivalents.
Notice the Prolog goal is put in braces. This is how the translator knows not to convert this predicate into a predicate of arity 2 greater.

num(0) --> [zero].
num(N) --> xx(N).

xx(N) --> digit(N).
xx(N) --> teens(N).
xx(N) --> tens(T), digit(N1), {N is T+N1}.

digit(0) --> [].
digit(1) --> [one].
digit(2) --> [two].
digit(3) --> [three].
digit(4) --> [four].
digit(5) --> [five].
digit(6) --> [six].
digit(7) --> [seven].
digit(8) --> [eight].
digit(9) --> [nine].

teens(10) --> [ten].
teens(11) --> [eleven].
teens(12) --> [twelve].
teens(13) --> [thirteen].
teens(14) --> [fourteen].
teens(15) --> [fifteen].
teens(16) --> [sixteen].
teens(17) --> [seventeen].
teens(18) --> [eighteen].
teens(19) --> [nineteen].


tens(20) --> [twenty].
tens(30) --> [thirty].
tens(40) --> [forty].
tens(50) --> [fifty].
tens(60) --> [sixty].
tens(70) --> [seventy].
tens(80) --> [eighty].
tens(90) --> [ninety].

Notice digit(0) --> []. would be called only if we had a two-digit number ending in 0.
To convert say the number 55 we could enter the query | ?- phrase(num(55),X). This would return the answer X=[fifty, five].

More on Cut, Definite Clause Grammars

Outline