How to translate a sentence in a logical language

Question

I have a sentence and its syntax, where can I find the predicates prolog that allow me to write the sentence in a logical language?

Exists or any of you can help me to create a predicate that

takes as input the following string

(S (NP (NNP John))
    (VP (VBP see)
      (NP (NNP Mary))))

and return this

see(John,Mary)

Answer 1

I think @CapelliC's answer is better (+1), but I wanted to take a crack at it and see what I came up with. You can solve this without LisProlog, but you can be quite sure that LisProlog will do a much better job than my off-the-cuff DCG crap.

First for my convenience I wanted to stick your example sentence into the code so I don't have to keep retyping it:

sent("(S (NP (NNP John))
         (VP (VBP see)
             (NP (NNP Mary))))").

Now some helper DCG rules:

whitespace --> [X], { char_type(X, white) ; char_type(X, space) }, whitespace.
whitespace --> [].

char(C) --> [C], { char_type(C, graph), \+ memberchk(C, "()") }.

I need the memberchk in there to ensure that I don't put parenthesis into atoms.

chars([C|Rest]) --> char(C), chars(Rest).
chars([C]) --> char(C).

term(T) --> chars(C), { atom_chars(T, C) }.
term(L) --> list(L).

list(T) --> "(", terms(T), ")".

terms([]) --> [].
terms([T|Terms]) --> term(T), whitespace, !, terms(Terms).

There's mutual recursion between term and list, but this is what we want, because we want a list to be able to appear nested anywhere. Let's test the parsing:

?- sent(X), phrase(list(Y), X).
X = [40, 83, 32, 40, 78, 80, 32, 40, 78|...],
Y = ['S', ['NP', ['NNP', 'John']], ['VP', ['VBP', see], ['NP', ['NNP'|...]]]] ;

This looks good so far. The pattern matching looks very similar to @CapelliC's:

simplify(['S', ['NP', ['NNP', Subject]], 
               ['VP', ['VBP', Verb], 
                      ['NP', ['NNP', Object]]]], 
         Result) :-
    Result =.. [Verb, Subject, Object].

Unfortunately, using capitalized atoms is obscuring the intent here, which is actually quite natural. If we could use lowercase letters the pattern would look more like this:

simplify([s, [np, [nnp, Subject]], 
             [vp, [vbp, Verb], 
                  [np, [nnp, Object]]]], 
         Result) :-
    Result =.. [Verb, Subject, Object].

We're using the powerful "univ" operator here (=..) to generate a Prolog term from a list. You can think of this operator as the Lisp translator, because that's essentially what it does:

?- s(this, that) =.. X.
X = [s, this, that].

?- X =.. [s, this, that].
X = s(this, that).

So it should be clear how the pattern matching works. Let's see how the whole thing fits together:

?- sent(X), phrase(list(Y), X), simplify(Y, Z).
X = [40, 83, 32, 40, 78, 80, 32, 40, 78|...],
Y = ['S', ['NP', ['NNP', 'John']], ['VP', ['VBP', see], ['NP', ['NNP'|...]]]],
Z = see('John', 'Mary') .

For what it's worth, translating natural language sentences into logical propositions is a big question. It won't usually be this easy, but there are books that discuss how to approach the problem. I'd suggest checking out Representation and Inference for Natural Language for more information on this large problem.

So there you have it. The advantage to doing it by hand like this is that you can control what exactly from Lisp's grammar you want to take, and it's easy to extend or modify. The downside is that you will have to debug the grammar—and I'm quite sure there are problems with this one I didn't notice or take time to find (I am far from a DCG expert!). Absent better requirements I would definitely take @CapelliC's answer, but I thought it might be helpful to see how this could be approached from scratch.

Answer 2

If I understand, you want parse LISP structures to Prolog. Then LisProlog, by Markus Triska, could be the appropriate tool. Using that and this snippet

test :- parse("(S (NP (NNP John))
        (VP (VBP see)
         (NP (NNP Mary))))",
          R),
    maplist(sexp_write(""), R).

sexp_write(Indent, E) :-
    is_list(E),
    format('~s~w~n', [Indent, E]),
    maplist(sexp_write([0' |Indent]), E).
sexp_write(Indent, E) :-
    format('~s~w~n', [Indent, E]).

I get

?- test.
[s(S),[s(NP),[s(NNP),s(John)]],[s(VP),[s(VBP),s(see)],[s(NP),[s(NNP),s(Mary)]]]]
 s(S)
 [s(NP),[s(NNP),s(John)]]
  s(NP)
  [s(NNP),s(John)]
   s(NNP)
   s(John)
 [s(VP),[s(VBP),s(see)],[s(NP),[s(NNP),s(Mary)]]]
  s(VP)
  [s(VBP),s(see)]
   s(VBP)
   s(see)
  [s(NP),[s(NNP),s(Mary)]]
   s(NP)
   [s(NNP),s(Mary)]
    s(NNP)
    s(Mary)
true .

Now you should decide about translating the logical form to Prolog term.

In generality, it's a difficult theme, because you need to do some choice about quantification. For your simple statement, you could begin with a very simple pattern matching, ignoring altogether the problem above.

sexp_to_term(S_exp, T_exp) :-
    parse(S_exp, [R]),
    termize(R, T),
    pattern(T, T_exp).

pattern(T, T_exp) :-
    T = 'S'('NP'('NNP'(Subj)),'VP'('VBP'(Verb),'NP'('NNP'(Obj)))),
    T_exp =.. [Verb, Subj, Obj].

termize(s(Tag), Tag).
termize([s(Tag)|Args], Term) :-
    maplist(termize, Args, ArgsT),
    Term =.. [Tag|ArgsT].

test:

?- gtrace,sexp_to_term("(S (NP (NNP John)) (VP (VBP see) (NP (NNP Mary))))", T).
T = see('John', 'Mary').