W3C home > Mailing lists > Public > www-archive@w3.org > June 2001

Re: Inference in daml

From: Sean B. Palmer <sean@mysterylights.com>
Date: Mon, 18 Jun 2001 16:28:00 +0100
Message-ID: <011601c0f80b$59dda300$e0ec93c3@z5n9x1>
To: "Geoff Chappell" <geoff@sover.net>
Cc: <www-archive@w3.org>, "Seth Russell" <seth@robustai.net>
[...]
> It's a stretch to say that the language has quantification in
general
> - this seems to be quantification over the object only.

That's the problem. It's saying that "by making this restriction, you
are implying that you're doing this quantification", rather than "you
are doing this quantification". If it had a general mechanism for
expressing existential and universal quantification, then I'd say that
it is complete FOL, but there aren't any such terms, and it isn't even
possible to make inferences as such, because (as you note) there is no
way to quantify over predicates.

> > You can have the cardinality constraints, but where's the
negation?
> > How do you assert that a statement is false in DAML? For a start,
> > to make logical expressions in DAML, you would need an "AND",
> > and to do that you'd need to group reified statements, i.e. a
context.
>
> Negation through complementOf; And through intersectionOf; Or
through
> unionOf

Cool, but once again, complementOf isn't really direct FOL...

Hmm... could you do an intersection of statements to form a context?

   :x daml:intersectionOf [ a rdf:Statement ], [ a rdf:Statement ] .

Yep, I guess you can. Now all we need is that implies predicate, and
the quantifications...

   :x daml:intersectionOf :a , :b .
   :a a rdf:Statement . :b a rdf:Statement .
   :y daml:intersectionOf :c , :d .
   :c a rdf:Statement . :d a rdf:Statement .
   :z :sub :x; :pred :implies; :obj :y .
   :z  :Rule; :trueForAll :a, :c; :trueForSome :b , :d .

[...]
> >    { { :x :a [ :b :c; :d :h ] } log:implies { :b :c :d }}
> >    a log:Truth; log:forAll :b , :d .
> >
> > I don't think it can be done.
>
> Not up on n3 but I assume this is dereifying statements? I don't
> think it can be done in daml either - becuase I don't see any way
> to quantify over the predicate.

Strangely enough, Seth (who's on the CC anyway) discussed unreifying a
little while ago on RDF Logic, although I can never remember the URL
of the post. Maybe he can prompt us.

Yes, quantifying over predicates can't be done currently in DAML, but
that doesn't mean it can't be done in RDF. The point is that DAML only
gives you a few terms, and you make what you can out of them. If you
need something that isn't in the language, then you:-

a) Look for a lanugage that does
b) Invent the terms yourself
c) Beg the DAML people to add them to DAML

a) is getting easier all the time, but b) is often the only option,
and then you have to get people to take up your term, which they're
not going to do. The problem with primitives is that they're
primitive - they're difficult to infer, but not impossible. For
example, let's say I come up with sbp:implies, and want to use that
instead of log:implies. I'd have to do:-

{ :x sbp:implies :y } log:implies { :x log:implies :y } .
{ :x log:implies :y } sbp:implies { :x sbp:implies :y } .

To get it to work on both my system and CWM. But that means you double
the amount of statements, which is quite pointless. So the point is
that what we need is a very stable base of terms that everyone can
use: a universal set of terms. The problem with the current suite of
terms is that they are so fragmented: you have RDF Schema which is
ancient, and has quite a few issues, you have DAML which isn't even
maintained by the W3C, and is incompatable with RDF Schema
occasionally, and then you have LOG which is a TimBL hack and has even
had a namespace change from "...log.n3#" to "...log#". This is not a
good status for the Semantic Web, and really the only thing that gets
in the way is the politics.

We need a few modular steps to RDF:-

The basic syntax terms (Description, about, etc.)
Human labelling (title, label, see also, defined by, comment)
The basic schema model (resource, classes, predicates)
Higher schema/ontologies (types, subClass, subProperty, range, domain)
Model (lists, reification, contexts, cardinalities)
Logic (and, or, not, quantification, truths)
Inferences (equivalencies, implication, inverses)
Junk (starts with, uri, namespace, QNames, datatypes, string
functions)
Proof (this was obtained by x y and z)

There are many overlaps between these layers, so they'll have to be
coordinated very carefully.Interestingly, I think that as inferences
are built on top of logic, not the other way around, logic should be
developed as a more basic layer than the inferences.

> Well now that the hard part is done (the acronym is worked out)
> perhaps things can move forward at a greater pace. [...]

Let's hope so.

--
Kindest Regards,
Sean B. Palmer
@prefix : <http://webns.net/roughterms/> .
:Sean :hasHomepage <http://purl.org/net/sbp/> .
Received on Monday, 18 June 2001 11:26:53 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Wednesday, 7 November 2012 14:17:13 GMT