Create a list from a Prolog DCG - list

Question

I can't figure out how to create a list containing the elements that have been used to form a sentence using a defined DCG.
Suppose we have the following DCGs:
father --> [Peter].
mother --> [Isabel].
child --> [Guido].
child --> [Claudia].
verb --> [is].
relation --> [father, of].
relation --> [mother, of].
pronoun --> [he].
pronoun --> [she].
adjective --> [a, male].
adjective --> [a, female].
s --> father, verb, relation, child.
s --> mother, verb, relation, child.
s --> pronoun, verb, adjective.
Sentences can be queried as follows:
phrase(s, [peter, is, father, of, guido]), phrase(s, [he, is, a, male]). which returns true.
How can I create and maintain a list of the elements of this executed sentences in order to get false when executing the following sentences (because Peter is a male, notice the she instead of he):
phrase(s, [peter, is, father, of, guido]), phrase(s, [she, is, a, female]).
This question uses the same example as here.

Answer 1

The proper interface to DCGs is via phrase/2, a simplified version of phrase/3:
?- phrase(s, X).
X = [_8304, is, father, of, _8328] ;
X = [_8304, is, father, of, _8328] ;
X = [_8304, is, mother, of, _8328] ;
% etc
The _8404 variables come from rules like father --> [Peter]. because Peter in there is also a variable (variables start with _ or an upper case letter. You can fix this by escaping the atom as 'Peter' - see also the other question you asked).
The first name of phrase is the DCG rule, the second argument is the list. When you use a particular list as the second argument, the answer substitution is empty and Prolog just reports that it could derive the list. In my example, I used the variable X and obtained possible substitutions for it, that can be derived.
Constraints can be added as goals enclosed in curly brackets:
dupnum(X) -->
{ member(X, [0,1,2,3,4,5,6,7,8,9]) },
[X,X].
leads to
?- phrase(dupnum(X), Y).
X = 0,
Y = [0, 0] ;
X = 1,
Y = [1, 1] ;
% etc
The example also shows that DCG productions can have arguments which you could use to propagate a parse tree or some general parsing context.

Answer 2

To address the extra question that was added later: you can pass information around by adding additional arguments but you need to describe the sequence of sentences. The example phrase(s, [peter, is, father, of, guido]), phrase(s, [he, is, a, male]) should succeed, what should not succeed is uttering the two sentences after each other phrase(ss, [peter, is, father, of, guido, '.', he, is, a, male,'.']) (Or it might succeed, leaving "he" as a reference to someone we do not know. It all depends on how strict we are with the context. ).
To do this properly, we need to jump quite a number of hoops. First we need to add parsing information to the DCG rules. For example, np(np([A,O],object)) --> %... will parse an article followed by an object into a structure np([A,O],object). Let's parse ['a', 'male'] and [guido] with it:
?- phrase(np(NP), [a, male]).
NP = np([article(a), object(male, male)], object) ;
false.
?- phrase(np(NP), [guido]).
NP = np([name(guido, male)], name) ;
false.
The first argument of np is a list because other np rules have only on component. Note that we added the gender as an attribute to name and object. In other languages, for example French, the article also has a gender that needs to agree with the object but in English we can set this aside. More sophisticated implementations would also take into account if the object is in singular or plural (the same goes for the different modes of a verb).
For verbs, we need to distinguish how many object noun phrases they need. This is done by the checks is_transitive/1, is_intransitive/1 and is_bitransitive/1.
Finding a good solution for demonstrative pronouns is hard: the pronoun does not need to refer to the previous subject, for example in "Gaile is married to Peter. He is older than her.". It doesn't even need to refer to the last sentence at all, for example in "Peter is where he wants to be.". This means that a) you should decide beforehand, which cases you actually want to cover and b) it is best to make these decisions in a second parsing run, when you have the full structured information. This mirrors the linguistic distinction between syntactic, semantic and pragmatic reasoning, where I would categorize the problem you would like to solve as pragmatic, which depends on the other two steps.
My solution here just incorporates the particular decision you wanted to make into a single parsing run, at the cost of readability of the ss DCG rule: we add an additional argument that collects the sentences that have been parsed already, a so called accumulator. When we start parsing, the history is empty which is reflected by the rule ss(S) --> ss(S,[]).. For the actual rules, we need to distinguish if the current sentence starts with a demonstrative pronoun or not. In the first case we need resolve it, which we do here by looking at possible noun phrases in the previous sentence that agree in gender. With this machinery in place, we can parse the sentence [peter, is, a father, '.', he, is a father,'.']:
?- phrase(ss(Tree), [peter,is,a,father,'.', he, is, a, father, '.']).
Tree = [s(np([name(peter, male)], name), vp([verb(is), np([article(a), object(father, male)], object)])), s(np([pronoun(he, male)], dpronoun), vp([verb(is), np([article(a), object(..., ...)], object)]))] ;
but we cannot parse [peter,is,a,father,'.', she, is, a, father, '.']:
?- phrase(ss(Tree), [peter,is,a,father,'.', she, is, a, father, '.']).
false.
In a proper semantic/pragmatic analysis, we would enrich the pronoun phrase with the actual referenced noun phrase but this would be done as a rewriting of the original parse tree. Here is the code for this:
%%%% utility predicates
% gender_of(X,Y) is true if X is the gender of the syntax tree node Y
gender_of(X,name(_,X)).
gender_of(X,pronoun(_,X)).
gender_of(X,object(_,X)).
gender_of(G,np([X],_)) :-
gender_of(G,X).
gender_of(G,np([_,X],_)) :-
gender_of(G,X).
% nps_of(X,Y) is true if X is the list of nps occurring in the syntax tree node Y
nps_of([],vp([_])).
nps_of([NP],vp([_,NP])).
nps_of([NP|Rest],s(NP,VP)) :-
nps_of(Rest, VP).
% nountype_of(X,Y) is true if X is the type of the np node Y
nountype_of(X, np(_,X)).
% is_intransitive(X) is true if the verb X does not require an object phrase
is_intransitive(is).
is_intransitive(walk).
% is_transitive(X) is true if the verb X requires an object phrase
is_transitive(is).
% is_bitransitive(X) is true if the verb X requires two object phrases
is_bitransitive(is).
%%%% DCG rules
% name are distinct from objects because they do not require articles
name(name(peter,male)) --> [peter].
name(name(isabel,female)) --> [isabel].
name(name(guido,male)) --> [guido].
name(name(claudia,female)) --> [claudia].
% nouns that require an article
object(object(mother,female)) --> [mother].
object(object(father,male)) --> [father].
object(object(male,male)) --> [male].
object(object(female,female)) --> [female].
% verbs
verb(verb(is)) --> [is].
verb(verb(walk)) --> [walks].
% pronouns
pronoun(pronoun(he,male)) --> [he].
pronoun(pronoun(she,female)) --> [she].
% articles
article(article(a)) -->
[a].
article(article(the)) -->
[the].
% noun phrases
np(np([A,O],object)) -->
article(A),
object(O).
np(np([N],name)) -->
name(N).
np(np([PN], dpronoun)) -->
pronoun(PN).
% verb phrases
vp(vp([V,NP])) -->
verb(V),
{ V = verb(Name), is_transitive(Name) },
np(NP).
vp(vp([V])) -->
verb(V),
{ V = verb(Name), is_intransitive(Name) }.
end -->
['.'].
% a single sentence
s(s(NP,VP)) -->
np(NP),
vp(VP),
end.
% a list of sentences, with accumulator
ss([],_Acc) -->
[].
ss([S|Sentences],[]) -->
s(S),
ss(Sentences, [S]).
ss([S|Sentences], [LastS | Acc]) -->
{ S = s(np([Pronoun], dpronoun),_) },
s(S),
{ gender_of(G, Pronoun), nps_of(LastNPS, LastS), member(LNP, LastNPS), gender_of(G,LNP) },
ss(Sentences, [S, LastS | Acc]).
ss([S|Sentences], [LastS | Acc]) -->
{ S = s(NP,_), nountype_of(NT,NP), dif(NT,dpronoun) },
s(S),
ss(Sentences, [S, LastS | Acc]).
% wrapper of ss with empty accumulator
ss(S) -->
ss(S,[]).