[
Lists Home |
Date Index |
Thread Index
]
> -----Original Message-----
> From: Thomas B. Passin [mailto:tpassin@comcast.net]
> Sent: 28 June 2003 18:02
> To: xml-dev@lists.xml.org
> Subject: Re: [xml-dev] XML-based Automation (Was: Zen or Games?)
>
>
> [Danny Ayers]
> > ...
> > CGs and RDF have a lot in common. Taking the main points of the abstract
> > syntax for CGs in the ISO standard [1] it's possible to map
> across fairly
> > directly to aspects of RDF (this is a 2 minute, first shot attempt) :
> >
> > 6.1 Conceptual Graph - RDF model
> > 6.2 Concept - Resource
> > 6.3 Conceptual Relation - Statement (/Property)
>
> Disagree. "In a conceptual graph, the boxes are called concepts, and the
> circles are called conceptual relations." (Sowa 2000, p476). RDF has no
> conceptual relations. They have to be simulated, most likely with bnodes.
Hmm, I would have thought that most of the time CG conceptual relations
would have mapped directly to RDF properties :
From the CG tutorial [1] :
A cat is on a mat.
CG version (approx) :
[Cat]->-(On)->-[Mat]
an Ntriples RDF version could look like :
<#cat> <#on> <#mat>.
both of which map to the KIF :
(exists ((?x Cat) (?y Mat)) (On ?x ?y))
> > 6.4 Lambda Expression - bnode (maybe)
>
> Disagree. lambda expressions involve variables. RDF has no varaiables.
In the general case you're probably right, though I think it's likely that
parts of RDF (or layers on top) can carry out the same purposes as lambda in
CG. Again from the tutorial :
Tom believes Mary wants to marry a sailor.
TimBL [2] suggests in N3 :
<#Tom> :believes {
<#Mary> :wants {
<#Mary> :marriedTo [ a :Sailor ]
}
}.
N3 is more than RDF, but the idea of layering on top is what gives RDF its
power.
(btw, I suspect the same statement could probably be expressed in RDF alone
using reification and a bnode - too early in the day for me to try
though...)
> > 6.5 Concept Type - Class
> > 6.6 Relation Type - (Property) Class
>
> Class, yes, Property no.
>
> > 6.7 Referent - Object (of statement)
>
> Disagree. A referent is essential an identifier (Sowa, p 424).
Ok, I must have misinterpreted that - URIref instead then.
> Good memory (or was it Google?)!
Appalling memory. It rang vague bells but as you guessed, Google did the
rest.
Yup, I did, for simple cases it works out
> well. But CGs have a lot more richness. Basically, RDF is
> existential-conjunctive, whereas CG can express all four styles
> (again from
> Sowa but I do not have a page reference right now).
Yep, RDF itself is essentialy just e-c. But it's possible through the use of
RDFS to create terms outside the core, and then give those terms more than
what's found in base level RDF. e.g. let's have :
xmldev:not rdfs:subClassOf rdf:Property
and with a bit of verbal fluff we have negation.
In effect, richer semantics can be layered on top of an anything-goes base
level by referring to external definitions. It's a strange setup, but it
seems to work, and it allows useful logical things to be done in a messy
environment like the web.
Returning to Len's reference to Sowa's Analogical Reasoning [3], presumably
the internal representation in his implementation is based on CGs. But the
inference algorithm is based around graph transformation and matching, and a
bit of predicate logic. An ontology that described CGs could be created, and
an analogical engine built on top. Alternatively the algorithm could be
rewritten to make it more RDF (and OWL) friendly. Either way, implementing
this using RDF should be possible, and not too difficult (more mudslinging
than diamond cutting, to use James Gosling's categorisation of programming
tasks). The result would have the distinct advantage of reusability in the
context of the (Semantic) web.
Cheers,
Danny.
[1] http://users.bestweb.net/~sowa/cg/tut.htm
[2] http://www.w3.org/DesignIssues/CG.html
[3] http://www.jfsowa.com/pubs/analog.htm
|
