Sebastian,

You raise a good point regarding the use of frame-based versus
non-frame-based representations.

We have been using a non-frame-based approach for Subjects and Objects of
verbs....   However I have now suggested using more of a frame-based
approach for other verb arguments.   This raises the question of whether it
might be better to use a frame-based approach for Subjects and Objects as
well.

Indeed it might be.  I can think of two arguments against the frame-based
approach:

1)  It uses more Atoms

2)  We already have a bunch of RelEx2Logic rules written using the
non-frame-based approach, and it would be a pain for Ruiting and Rodas and
others to rewrite them into a frame-based approach ;p

In the end the two approaches are semantically equivalent and are both
fairly simple, so it doesn't seem a huge deal...

...

I will elaborate a bit further, so others understand the issue fully and
can express their own views...

In an OpenCog predecessor system,  instead of  e.g.

EvaluationLink
    eat
    ListLink
         Ben
         stir-fried caterpillar


we  used a frame-based format like

EvaluationLink
     Agent
     ListLink
         eat99
         Ben

EvaluationLink
     Patient
     ListLink
         eat99
         stir-fried caterpillar

Inheritance eat99 eat

This is OK.... However, apart from using more Atoms, the problem w/ this is
that in many cases, disambiguating whether the first argument (the subject
of a verb, say) is really an "agent" or not becomes tricky....   For
instance in the case

EvaluationLink
     appear
     ListLink
           Ben
           ridiculous

Ben is not the Agent and ridiculous the Patient ...

So figuring out the right semantic role label for the subject and object of
a verb gets tricky, meaning that before one does (PLN-based?) semantic
disambiguation one will have a lot of Atoms like

EvaluationLink
     map_of_Subject
     ListLink
         eat99
         Ben

EvaluationLink
     map_of_Object
     ListLink
         eat99
         stir-fried caterpillar

Inheritance eat99 eat

EvaluationLink
     map_of_Subject
     ListLink
         appear44
         Ben

EvaluationLink
     map_of_Object
     ListLink
         appear44
         ridiculous

Inheritance appear44 appear

...

This frame-based approach is not really wrong and could possibly be a
better approach...   But it doesn't add any meaning over the style where
one says

EvaluationLink
    eat
    ListLink
         Ben
         stir-fried caterpillar

EvaluationLink
     appear
     ListLink
           Ben
           ridiculous

and it does introduce a bunch of extra Atoms...

In either case once one finds out the actual role played by the subject and
object one has to create new Atoms....  So in the non frame based case, if
one find out Ben is the Agent and stir-fried caterpillar is the Patient,
one can still create

EvaluationLink
     Agent
     ListLink
         eat99
         Ben

EvaluationLink
     Patient
     ListLink
         eat99
         stir-fried caterpillar

Note that, to do the semantic disambiguation, the Atomspace could contain
general knowledge of the form

Implication
   Evaluation
       eat
       ListLink
           $X
           $Y
   ThereExists $Z
        ANDLink
            Inheritance $Z eat
            EvaluationLink Agent (ListLink $Z $X)
            EvaluationLink Patient (ListLink $Z $Y)

expressing knowledge about the semantic roles of the subject and object of
"eat", or


Implication
   ANDLink
       Evaluation
          map_from_Subject
          ListLink
             $X
             $Y
       InheritanceLink $X eat
   Evaluation
       Agent
       ListLink
           $X
           $Y


Implication
   ANDLink
       Evaluation
          map_from_Object
          ListLink
             $X
             $Y
       InheritanceLink $X eat
   Evaluation
       Patient
       ListLink
           $X
           $Y


In this case the disambiguation is easy -- the subject of "eat" is pretty
much always the Agent, and the object the Patient.  In many cases, it's
less obvious and the disambiguation requires some context...

In short, you may be right that it's inelegant to treat the Subject and
Object of a verb using non-frame-based representation, and the other
arguments of the verb (e.g. expressed via prepositions or relative
clauses)  using frame-based representation.   Using frame-based
representation for everything would be more consistent.   On the other
hand, it doesn't seem to matter much, because if PLN can't effectively
convert btw these sorts of similar representations, it won't be able to do
any interesting conceptual inferences either....

Also, we note that in the case where the function-argument relation is
defined by, say, a preposition rather than a subject or object slot, we
usually have a little more information about the meaning, e.g. we my have

EvaluationLink
     in
     ListLink
          Ben999
          house

Here we have "in" instead of something even vaguer like "map_of_Subject"
because the syntax of English uses the word "in" to denote the
function-argument relationship, rather than just using the position in the
sentence (as in the case of Subject).

Note that I am using "map_of_Subject" as a PredicateNode name here instead
of "Subject" to emphasize the point that Subject is a syntax-level
relationship, vs. Agent and Patient which are semantics-level
relationships...   Of course this is a fuzzy distinction, and e.g. "in" is
being used in both semantic and syntactic forms.

In the end language is a mess, and there is always gonna be some mess in
mapping language into any formal system.  As long as the mappings used are
relatively simple, and are mutually consistent with each other, a suitably
powerful reasoning engine should be able to sort out the mess.....
Ultimately the hard problem is inferring contextual knowledge from the mass
of mess, and using it to guide judgments; and the hardness of this is
probably not dependent on the particular choices of how to arrange the
representations of individual semantic features...

-- Ben



On Wed, Jun 4, 2014 at 1:14 AM, Sebastian Ruder <notifications@github.com>
wrote:

> In tests/python/test_pln/scm/relex2logic_pln_examples/context-link.scm:
>
> > +        ; "I like eating bass."
> > +        ; RelEx at the moment delivers the wrong output for this sentence.
> > +        ; Eating is interpreted as an adjective:
> > +        ; _obj(like, bass)
> > +        ; _subj(like, I)
> > +        ; _amod(bass, eating)
> > +        ; The output produced by RelEx2Logic should be:
> > +        (EvaluationLink
> > +            (PredicateNode "like")
> > +            (ListLink
> > +                (ConceptNode "I")
> > +                (EvaluationLink
> > +                    (PredicateNode "eat")
> > +                    (ListLink
> > +                        (ConceptNode "I")
> > +                        (ConceptNode "bass@12345")))))
>
> @bgoertzel <https://github.com/bgoertzel>, I understand the logic behind
> it: I think this is the most consistent way and preempts other, more
> difficult cases where the subject of the subordinate clause isn't the same
> as for the main clause and makes the representation analogous to
> that-clauses. Even so, I would appreciate it if you could comment briefly
> why you didn't choose to use a link for such cases containing only verb and
> object:
>
> (EvaluationLink
>     (PredicateNode "like ")
>     (ListLink
>         (ConceptNode "I")
>         (TodoLink/GerundLink
>             (PredicateNode "eat")
>             (ConceptNode "bass@12345"))))
>
> Or why you didn't choose to make like, say, ternary, as kind of a thought
> experiment:
>
> (EvaluationLink
>     (PredicateNode "like ")
>     (ListLink
>         (ConceptNode "I")
>         (PredicateNode "eat")
>         (ConceptNode "bass@12345"))))
>
> Anyway, I pushed a partial explanation for this as requested by Linas.
>
> —
> Reply to this email directly or view it on GitHub
> <https://github.com/opencog/opencog/pull/776/files#r13346447>.
>



-- 
Ben Goertzel, PhD
http://goertzel.org

"In an insane world, the sane man must appear to be insane". -- Capt. James
T. Kirk

"Emancipate yourself from mental slavery / None but ourselves can free our
minds" -- Robert Nesta Marley