W3C home > Mailing lists > Public > www-rdf-interest@w3.org > March 2001

Re: Open Worlds, Distribution, Delegation, Federation, Logic, NI

From: <jos.deroo.jd@belgium.agfa.com>
Date: Fri, 2 Mar 2001 17:36:12 +0100
To: sandro@w3.org
Cc: timbl@w3.org, www-rdf-logic@w3.org, www-rdf-interest@w3.org
Message-Id: <OFF77BD475.2BCEB252-ON41256A03.005ACFD4@bayer-ag.com>


I'm really with you on those topics, although I haven't
had enough chance to talk with you about those topics on the
technical pleanary meeting (but I have still your face
in front of my mind ...).
We have been making steps back and forward in those matters
but one clear thing is declarative and mathematical languages
(another daml if you want) and n3 is a great notation for that.
With respect to negation, I don't know if we are avoiding naf
(negation as failure) when we are using
  {:subject :verb :object} log:implies <data:,>
which is a specific form of a nested implication (if I'm correct)
The <data:,> (or the "" if you want) is not the same as
log:Falsehood but just stands for a no-proof-found instance
which could be the result of any (delegated) attempt to find
any evidence (when using a universally quantified verb for the
conclusion). So I'm not sure wether that's naf or not, but it
certainly _opens_ the way engines can interact ...
I don't see great difficulty in the use of operators such as
plus, minus, times, slash and relational operators such as less
than etc. and they are quite useful for such things as
normative value comparisons (in e.g. image measurements).
Other side-effected things are not clear to me (at least not clear
when they are not properly defined in an axiom system (I'm for the
moment much biased by Rudolf Carnap's symbolic logic stuff ...).
I hope to continue this discussion sooner or later ...

Jos De Roo, Agfa http://www.agfa.com/w3c/jdroo/

sandro@w3.org@INTERNET@w3.org on 01/03/2001 16:37:26

Sent by:  www-rdf-interest-request@w3.org

To:   timbl@w3.org@INTERNET, www-rdf-logic@w3.org@INTERNET,
Subject:  Open Worlds, Distribution, Delegation, Federation, Logic, NI
This may or may not be obvious: one tremendous benefit of the
triple-set model is that completely transparent distribution and
delegation becomes so much easier that we can probably do them.

This is what I was trying to do with NILE.  (It stands for
Notation-Independant Logic Engine, a relatively unimportant fact that
I couldn't seem to remember while digesting lunch, for those of you at
the RDF-IG meeting Tuesday).

Putting this as clearly as I can this morning, speaking to this
diverse audience, here's how distribution and delegation can work:

   1. Do all your communication as passing triples of constant terms
      (that is: RDF with some reasonable answers to some items on the
      issues list).

   2. This means the "RDF API" looks like this:

         Foo.tell(Term subject, Term predicate, Term object);

   3. You get information back by asking for it to be sent somewhere.
      For instance, you might (somehow) create a Term for your own
      tell() interface (Bar), then present a graph-matching pattern
      along with that "return address" for the query results.

   4. This is a universal API.  It works for everything.  You can put
      a triple store below it, obviously, but you can also put any
      kind of software below it.  Two extreme examples:

            You can put a unix kernel below it, using a vocabulary of
            the system call names and a vocabulary of bytes and
            mutable byte-sequences that can point each other.

            You can put UDP+TCP/IP below it, with a vocabulary of
            ports and addresses and byte-sequences, letting you talk
            to anything on The Internet.

      These examples subsume each other, since in theory the unix
      kernel can talk on the internet, and on the net you can make
      connections to unix machines, where you can talk to their

   5. If your query structure works with the "open world" assumption,
      then you can talk to anything below or _above_ the API, without
      even knowing the difference.  Fred poses a query to a generic
      triple store, looking for all Widgets between $20 and $30.  The
      triple store answers the query with what it knows -- perhaps it
      tells Fred about 2 particular.  Meanwhile, some widget sellers
      have meta-queries in the triple store: they presented queries
      about queries about widgets.  That leads the triple store to
      send them Fred's query, and they can tell him about their

   6. Some of these external information providers are self-contained
      and stateless.  All they do is get triples (perhaps responses to
      meta-queries) and offer back triples.  They can be coded as pure
      functions (no side-effects) in any programming language, or as
      the kind of rewrite rules in NILE.  (I'm vague on the theory of
      expressiveness of logics, but that's what I was aiming for.)

      (Where I was eventually trying to go with the Peano arithmetic
      example in NILE was to show this equivalence, where some
      application can use integer relations (ie arithmetic) which
      might be provided in either the rewrite rules I showed OR in
      some bit of C code, and the behavior (aside from performance)
      would be indistinguishable.  The theory is obvious and it seemed
      like a good demonstration.  It opens the door for all sorts of
      compilation-of-logic systems and various solutions to the
      performance problems in an obvious/naive implementation of this

I suspect I'm not the only one who sees this as an RDF use-case,
particularly when I see the resistance to using negation-as-failure
and closed-world systems, but I haven't heard this talked about.

I don't have a web page about this right now, but when I do (in a few
hours maybe?) I think I'll make it "http://www.w3.org/2001/03/open".
If you see me at the Tech Plenary today & tomorrow, by all means talk
to me about it.

      -- sandro
Received on Friday, 2 March 2001 11:36:37 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:44:28 UTC