RE: Grounding in English (was Re: semantics status of RDF(S))

Just a musing - could the semantics perhaps be defined by comparison with a
standard? You have a location where two sets of data, inputs & outputs. If
you feed the input data into your processor and it gives matching output to
the standard output, your processor conforms to that definition. Ok, so you
might say that if I want string A is equal to string b, then I can't really
be sure about this without all permutations. A way around this might be to
have a standard processor, if you send the same data to the standard and
you're own version, and if the outputs match (within some parameters you
care to set) you've got conformance.

Or, I suspect considerably more useful would be to define very simple
processes in this way (e.g. equivalence on a single bit) which would act as
your axioms, and derive the more complicated definitions from these.

---
Danny Ayers
http://www.isacat.net

<- -----Original Message-----
<- From: www-rdf-logic-request@w3.org
<- [mailto:www-rdf-logic-request@w3.org]On Behalf Of Sandro Hawke
<- Sent: 04 April 2001 18:21
<- To: pat hayes
<- Cc: www-rdf-logic@w3.org
<- Subject: Grounding in English (was Re: semantics status of RDF(S))
<-
<-
<-
<- > >I'm going to go out on a limb here and propose a solution that I think
<- > >provides solid semantics without being unduly restrictive.  It's
<- > >simple: reduce the RDF model to binary relations stated with
<- > >locally-scoped terms which may be defined directly in English (not
<- > >indirectly as URIs attached to semantics by various standards bodies
<- > >and by application developers).
<- >
<- > Not sure I follow this, but English is not a good way to state
<- > semantic meanings!
<-
<- Sorry for not being more clear.
<-
<- It seems to me that the only way two agents (eg you and I, or two
<- computer processes) can communicate (at least electronically) is by
<- exchanging linguistic expressions in a language they (we) both know.
<-
<- We can, of course, define a language (KIF, Prolog, FOPC, RDF, etc might
<- qualify) and then use it.  But we have to define THAT language using a
<- language we already know.
<-
<- And it occurs to me that we end up back at English.  Usually English
<- in research papers and textbooks and formal specifications and
<- dictionaries, English written with an eye toward semantic precision,
<- but still just English.
<-
<- This gives us an interesting design option: we can make a knowledge
<- exchange language with extremely simple syntax and extremely simple
<- semantics that can be arbitrarily extended in a non-conflicting way by
<- any user community.
<-
<-
<- > >More formally, in prolog syntax, the RDF model would be defined as
<- > >having two relations:
<- > >
<- > >   binary_relation(subject_term, relation_term, value_term).
<- > >
<- > >which means that the relationship identified by the relation_term (by
<- > >the mechanism defined below) is truly held between some object
<- > >identified by the subject_term and some object identified by the
<- > >value_term, respectively.
<- > >
<- > >The definitional grounding for the relation_term and optionally for
<- > >the other terms would be provided by:
<- > >
<- > >   english_definition(term, "This is English text which
<- defines something").
<- > >
<- > >This approach allows semantics to be defined with arbitrary precision
<- > >for humans by allowing the inclusion of entire textbooks or legal
<- > >codes if necessary.
<- >
<- > But it doesnt provide any model-theoretic semantics, since English
<- > doesnt have a model theory. The point is not to pin down the meaning
<- > for English readers, but to provide a mathematically checkable notion
<- > of valid inference for machines.
<-
<- So you and Peter can define a language (which is just a vocabulary,
<- here) using my mechanism.  And then you can define another one.  And
<- the two can coexist and cofunction in a variety of data stores.  And
<- machines which have been taught one of the languages (ie which know to
<- match particular English strings to their internal machine operations)
<- can follow formal declarations in that language giving semantics to
<- the other language so they can then understand both.
<-
<- > >And it allows machine processing via the
<- > >crude-but-effective mechanism of exact matching of strings.
<- >
<- > The longer the prose gets, the harder it is to get exact
<- string matching.
<-
<- I don't see computers having a real problem comparing arbitrary length
<- byte strings reproducably.  But no, I wouldn't ask people to type the
<- stuff.  For that, I'd use a level of indirection, like a web address
<- for the text.  But the level of indirection would of course be
<- formally specified in my proposed protocol to the mechanism which
<- accepted the user input.
<-
<- (My main reason for not having that web-address indirection in from
<- the start is that web page contents can change, and for security
<- and trust
<- reasons I thinks its essential to know certain semantics are immutable.)
<-
<- > Pat Hayes
<-
<-  - sandro
<-

Received on Wednesday, 4 April 2001 13:19:47 UTC