URIRefs are not "opaque" identifiers; mapping RDF substructure to KIF

> Also, URIs are fully opaque to the RDF MT, and we needed for
> the datatype and lexical form components to be visible to the
> MT, hence a new node type that does not have quite the level
> of opacity as URIrefs.

URIrefs are not opaque identifiers.  They have substructure which is
open to examination and is an Internet Draft Standard.  (Every web
browser has to use it, of course.)

RDF uses URIRefs as its identifiers specifically so that it can take
advantage of the web infrastructure.  If RDF were to view its
identifiers as wholey opaque, there would be provably no reason for
using URIRefs instead of something like UUIDs or TAGs.   (Requiring RDF
IDs to be UUIDs or TAGSs -- unique strings with no external semantics
-- would simplify a lot of RDF.  But we'd lose the web connection.)

Would you use an RDF Query API which never let you see the URIRefs of
the nodes it matched?

I can't find anything in the MT which really speaks to this.  For that
matter, I can't find it in KIF.  It seems implicit in most formal logic
work that while the symbols used for logical constants will not matter
to the inference process, they probably do mean something to the people
making assertions and queries.   Perhaps the opacity-during-inference
is what you're thinking of?  

I happen to think we need to open the door to some substructure
information during inference, but I recognize that's controversial.  I
like to think of software which lives above an RDF API doing queries
and assertions (especially without human intervention) as a kind of
inference engine or rules process (even if sometimes it's easier
implement directly in an imperative language).  And that software
sometimes wants to look inside strings and inside URIRefs.

In MT/FOL/KIF terms, this means 

   <a> <b> <c>

should map to

  (exists (?a ?b ?c) 
     (and (PropertyValue ?b ?a ?c)
	  (UName ?a "a")
	  (UName ?b "b")
	  (UName ?c "c")
     )
  )

where UName is a (inverse-functional) predicate relating things and
URIRef names for them.   The strings (like "a") are just KIF strings
(lists of characters).  

RDF string literals are different from KIF strings of course.  I
imagine "hello" mapping to something like rdfString("hello", "", 0),
where the last two parameters are the xmlLang value and the isXML
boolean flag.   (And I'm not sure about KIF support for Unicode, but
the need for that is obvious.)

    -- sandro

Received on Wednesday, 25 September 2002 13:32:09 UTC