Your document asserts:
The disadvantage is that we can't assert a complex
expression without asserting its parts.
I'm not convinced this is true. This can be done in
RDF, but requires reification, whose syntax is, shall
we say, verbose.
It's not the verbosity of reification that I object to; it's its
wrongheadedness. We could make the verbosity go away by providing
quasi-quote or some other notational convention. To oversimplify, I
could stipulate that whenever I write
<rdf:Description>
<rdf:Type resource="disjunction">
<rdf:Disjunct>
<Quote>
<rdf:Description about="roses">
<Color resource="&x;#red"/>
</rdf:Description>
</Quote>
</rdf:Disjunct>
<rdf:Disjunct>
<Quote>
<rdf:Description about="violets">
<Color resource="&x;#blue"/>
</rdf:Description>
</Quote>
</rdf:Disjunct>
The <Quote>...</Quote> expression gets expanded into a description of
the formula inside it. This is wrongheaded for two reasons:
a) It seems unnatural to analyze disjunction as being a relation among
*descriptions* of statements rather than a relation among statements.
Note that if I write something like p OR (q AND (m OR n)), I have to
reify p and q, but I have to reify the reification (or quote the
quotation) of m and n. Blech.
b) The only purpose of this trick is to get around a bug that *we*
introduced by insisting that asserting an expression entails asserting
all its subexpressions. No one's making us obey this rule but us;
let's give it up.
Someone might object to my point (a) that it isn't *disjunction*
that's a relation among descriptions of statements. It's more correct
to say that *assertion* is a relation involving descriptions of
statements: P asserts D is meaningful when P is an agent and D is a
description of a statement, possibly containing nested ANDs and ORs.
Okay, but that means that the language of D has *nothing to do* with
the language I use to describe D and what P does with it. I could
say in English "Pedro asserts 'rosas tem cor vermelho ou violetas tem
cor azul'" to describe what Pedro said in Portuguese (or in my
fractured Portuguese). Similarly, I can, we are supposing, describe in
a disjunction-free language that someone uttered a disjunction. But
what does this buy us? Either we have a language with disjunction or
we don't. If we do, why can't we use it instead of having to talk in
code about it? Why are we allowed to describe a disjunction in
intricate detail without being able to say it out loud?
It is, as you have done, important to separate the RDF
XML syntax and the underlying data model. It would be
helpful to me to understand whether your proposal to
reform RDF is motivated by dislike of the syntax, or
by the data model being insufficiently expressive.
If by "data model" you mean the graph model, then yes, it's the graph
model I don't like. I wouldn't say it's insufficently expressive; the
problem seems to be that it expresses too much.
I have nothing against graphs, and I have no doubt that thinking of
expressions as graphs is a good idea for many purposes. However,
it's just counterproductive to require a statement to entail the
statements represented by all its subgraphs.
If the problem is the syntax, then might a new
syntax for the underlying data model solve the problem.
No.
If the problem is the expressiveness of the data model,
I'd really appreciate an example to help me understand
its limitations.
Do the examples above help?
-- Drew