Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Axel Rauschmayer]

>> I use RDF like a next-generation relational database and think that RDF 
>> could be sold to many people this way (there is possibly are larger audience 
>> for this than for ontologies, reasoning, etc.). Especially considering how 
>> No-SQL is currently taking off. This part needs some love and seems to 
>> suffer from the almost exclusive focus on semantics.
> 
> Fair enough. I guess Im not sure how this next-generation-RDB usage fits with 
> the RDF semantics, but I'd be interested in pursuing this further. Does this 
> RDF/RDB++ vision provide any guidance towards what RDF is supposed to, like, 
> mean? Pointers?

Does it have to mean anything? I’ve always found tuple calculus and relational 
algebra quite intuitive, but as far as I remember, it is very light on 
semantics, everything is "just data". URIs as symbols are useful, but I would 
not know how to express the concepts they represent formally. What else is 
needed? A simple schema language, which should probably assume a closed world 
and unique names (unless specified otherwise). I’m surprised how something that 
is trivial (and common!) for relational databases is very hard for SPARQL (for 
example, letting SPARQL return a table where each row is a resource [1]).

Additionally, it would be useful if SPARQL allowed one to do backward-chaining 
via rules (some RIF implementations seem to do this). I can only come up with a 
few use-cases (sub-properties, transitive properties), but those would 
definitely help.

[1] http://www.w3.org/2009/12/rdf-ws/papers/ws17

There might not be anything in it, scientifically, but it would help to sell 
RDF to a community that is largely orthogonal to the one that is after RDF + 
semantics.

-- 
Dr. Axel Rauschmayer
axel.rauschma...@ifi.lmu.de
http://hypergraphs.de/
### Hyena: connected information manager, free at hypergraphs.de/hyena/

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Michael Schneider]

On Behalf Of Nathan wrote on Friday, July 02:

>Pat Hayes wrote:
>> On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:
>>> "A literal may be the object of an RDF statement, but not the subject
>>> or the predicate."
>>
>> Just to clarify, this is a purely syntactic restriction. Allowing
>> literals in subject position would require **no change at all** to the
>> RDF semantics. (The non-normative inference rules for RDF and RDFS and
>> D-entailment given in the semantics document would need revision, but
>> they would then be simplified.)
>
>I have to wonder then, what can one all place in the s,p,o slots without
>changing the RDF semantics? literal and bnode predicates for instance?

Short answer: you can put URIs, literals and bNodes in all three positions
of a triple, without needing to touch the current RDF semantics spec. 

Longer answer:
 
The syntactic restrictions of RDF (no literal subjects, no literal or bnode
predicates) are not "checked" by the semantic conditions of the RDF
semantics. Every node in a triple is (in a first "step") simply related to
some resource in the interpreted universe. For URI nodes this is probably
clear, but even literals are meant to represent resources: all datavalues
are treated as resources in RDF! bNodes are a bit different, since they do
not stand directly for a specific resource, but indicate that some resource
/exists/. 

But, in the end, all you receive from the interpretation of all the nodes
occurring in an RDF triple is essentially a binary relationships between two
resources. And the rest of the semantics specification of RDF(S), and even
of OWL Full, works exclusively on these kinds of sets of binary
relationships, below the "syntax surface", so to speak. So the whole stack
of RDF-based semantics is ready to be used with "generalized" RDF out of the
box -- just waiting for the RDF syntax to give up its restrictiveness. :-)

As a special note: Even bNode predicates, and even literal predicates are
allowed in the RDF semantics and make sense (in a technical sense, at
least), because: 

  (a) Properties are also treated as regular resources by the RDF semantics.
They have some binary relation "attached" to them (in order to allow to use
them to relate two resources), but you can still treat them like any other
resource, e.g. relate themselves to another resource by some other
property).

  (b) Literals stand for data value resources, and nothing stops a data
value resource from being used as a predicate resource. (I leave it to the
philosophers here in the list to debate whether this is good use or bad use
in practice.) 

>variables or formulae as in n3?

For formulae: Certainly "no", since formulae are normally not interpreted to
denote resources, but are assertions being interpreted by a truth value. 

For variables: Firstly, /existentially/ quantified variables are already
treated, since they are represented by bNodes. Remains /universally/
quantified variables, as they exist in N3. Supporting them would definitely
need /some/ extension of the RDF semantics, since it has at least to be said
how such variables are interpreted (this is only said for URIs, plain and
typed literals, and for bNodes so far in the spec, see Sections 1.4 and 1.5
of the RDF Semantics [1]). I just cannot tell how much extension would be
required without more deeply thinking about it. So this question keeps open
from my side at the moment. Maybe Pat has an answer?
 
>read as: if a new serialization/syntax was defined for RDF what are the
>limitations for the values of node/object and relationship specified by
>the RDF Semantics?
>
>Best,
>
>Nathan
>
>ps: apologies if this is a dumb question, I fear i'd still be hear next
>year trying to answer it myself though ;)

Not dump at all. Technically pretty demanding, in fact.

Cheers,
Michael
 
[1] 

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Haijie.Peng]

On 2010/7/1 22:35, Kingsley Idehen wrote:

Yves Raimond wrote:

Hello Kingsley!


[snip]


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" have
Identifiers in the form of Name References (which may or many 
resolve to

Structured Representations of Referents carried or borne by Descriptor
Docs/Resources). An "Identifier" != Literal.

If you are in a situation where you can't or don't want to mint an HTTP
based Name, simply use a URN, it does the job.


It does look like you're already using literal subjects in OpenLink
Virtuoso though:

http://docs.openlinksw.com/virtuoso/rdfsparql.html

SQL>SELECT *
FROM 
WHERE
{
?s foaf:Name ?name . ?name bif:contains "'rich*'".
}

Best,
y



Were is the Literal Subject in the query above?

bif:contains is a function/magic predicate scoped to Literal Objects.

 != "people".

Let's consider the following inequality:
people != people
if we imposed different interpretations on both sides，then we certainly 
could conclude the first 'people' is non-equivalence to the second 
'people' in semantic. Semantic of things is not reflected in the literal 
meaning, but is reflected in interpreter's behavior and its impact on 
the environment/world.


my two cents.

regards

Peng



What am I missing?

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Haijie.Peng]

On 2010/7/1 22:42, Kingsley Idehen wrote:

Pat Hayes wrote:


On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or however 
it is

called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

  # An rdf:List that loops around...

<#mylist> a rdf:List ;
  rdf:first <#Alice> ;
  rdf:next <#mylist> .

  # A looping, branching mess...

<#anotherlist> a rdf:List ;
  rdf:first <#anotherlist> ;
  rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just 
about impossible to guarantee that messes can't happen when all 
you are doing is describing structures in an open-world setting. 
But I think the cure is to stop thinking that possible-messes 
are a problem to be solved. So, there is dung in the road. Walk 
round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 
'linked data' practise by using examples like { 'London' a 
x:Place } - whereas I'd immediately counter with { x:London a 
'Place' }.


Surely all of the subjects as literals arguments can be countered 
with 'walk round it', and further good practise could be aided by 
a few simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" 
have Identifiers in the form of Name References (which may or many 
resolve to Structured Representations of Referents carried or 
borne by Descriptor Docs/Resources). An "Identifier" != Literal.


What ARE you talking about? You sound like someone reciting doctrine.

Literals in RDF are just as much 'identifiers' or 'names' as URIs 
are. They identify their value, most clearly and emphatically. They 
denote in exactly the same way that URIs denote. "23"^^xsd:number   
is about as good an identification of the number twenty-three as 
you are ever likely to get in any notational system since ancient 
Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked 
Data, slightly different mediums with some shared characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes). 
Thus, unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed 
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local RDF 
data). My gripe simply boils down to the nuisance factor introduced 
by data object name ambiguity in a distributed data object oriented 
realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space?


It means the number twenty-three, everywhere and for all time, 
because this meaning can be computed from the very syntactic form of 
the name. How unambiguous can something get?


Pat,

Re. RDF's triples, What is a Subject? What is an Object?.

If they are the same thing, why on earth do we use Names (with 
implications) to describe the slots in an RDF triple?


I've only once seen the RDF triple referred to as O-R-O (by @danbri) 
i.e., Object-Relation-Object.


In addition, I don't see Information and Data as being the same thing. 
Information (as I know it) is about Data + Context.  Raw Data (as I 
know it) is about: a unit of observation and deemed worthy of 
description by its observer.  You have to give Names to subject of a 
description. "23"^^xsd:number  isn't a Name.


**
I guess my own subtle mistake (re. this thread) is deeming Identifiers 
and Names to be equivalent , when they aren't :-) Of course, one can 
use an Identifier as a Name, but that doesn't make them equivalent.

**


One clear point of divergence here is that I am focused on the Web as 
Dist. DBMS that leverages 3-tuples + HTTP URIs in the S, P, and 
optionally O slot (aka. HTTP based Linked Data).


To conclude:

Name != Identifier.
We can also question the role of URI. Because the location of resource 
pointed by URI and the content of URI are orthogonal. A location is 
interpreted by a set of  locating operations, the locating result is 
only GUIDED, not CONTROLLED, by the content of URI. To realize this is 
very important!


regards

 Peng



I believe Subject == Name (an Identifier based Name) re. RDF triples 
otherwise the triple should be described as: O-R-O or O-P-O.


I believe an S-P-O triple is a piece of information (Data Object has a 
Name and at least one Attribute=Value pair).


What I desscribe actually has zilch to do with RDF as I am inclined to 
believe you see RDF :-) Thus, in a way, the literal-s

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Dan Brickley wrote:

[snip]

This is the second time in a few hours that a thread has degenerated
into talk of accusations and insults.

I don't care who started it. Sometimes email just isn't the best way
to communicate. If people are feeling this way about an email
discussion, it might be worth the respective parties spending a few
minutes on the phone to try to smooth things over. Or not. I don't
care, really. But each of these mail messages is getting distributed
to several hundred readers. It would be good if we can find ways of
using that bandwidth to solve problems rather than get into fights.

Or maybe we should all just take a weekend break, mull things over for
a couple of days, and start fresh on monday? That's my plan anyhow...

cheers,

Dan

  

Dan,

Being civil isn't rocket science.

People can debate, even do so with passion. All doable without 
unnecessary insults.


Ghana has certainly knocked me out anyhow :-(

--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Ian Davis]

On Fri, Jul 2, 2010 at 8:34 PM, Jeremy Carroll  wrote:
>  On 7/2/2010 12:00 PM, Dan Brickley wrote:
>>
>> Or maybe we should all just take a weekend break, mull things over for
>> a couple of days, and start fresh on monday? That's my plan anyhow...
>
> Yeah, maybe some of us could  meet up in some sunny place and sit in an
> office, maybe at Stanford - just like last weekend!

I have to say that meeting was a lot more civilised than the current
raging debate on these lists!

>
> Jeremy
>
>

Ian

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Jeremy Carroll]

 On 7/2/2010 12:00 PM, Dan Brickley wrote:

Or maybe we should all just take a weekend break, mull things over for
a couple of days, and start fresh on monday? That's my plan anyhow...


Yeah, maybe some of us could  meet up in some sunny place and sit in an 
office, maybe at Stanford - just like last weekend!


Jeremy

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Dan Brickley]

[snip]

This is the second time in a few hours that a thread has degenerated
into talk of accusations and insults.

I don't care who started it. Sometimes email just isn't the best way
to communicate. If people are feeling this way about an email
discussion, it might be worth the respective parties spending a few
minutes on the phone to try to smooth things over. Or not. I don't
care, really. But each of these mail messages is getting distributed
to several hundred readers. It would be good if we can find ways of
using that bandwidth to solve problems rather than get into fights.

Or maybe we should all just take a weekend break, mull things over for
a couple of days, and start fresh on monday? That's my plan anyhow...

cheers,

Dan

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Pat Hayes wrote:


On Jul 2, 2010, at 6:52 AM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jul 1, 2010, at 9:42 AM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or 
however it is
called) claims could probably make a mess, if added or 
removed...


You can create some pretty awesome messes even without OWL:

# An rdf:List that loops around...

<#mylist> a rdf:List ;
rdf:first <#Alice> ;
rdf:next <#mylist> .

# A looping, branching mess...

<#anotherlist> a rdf:List ;
rdf:first <#anotherlist> ;
rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its 
just about impossible to guarantee that messes can't happen 
when all you are doing is describing structures in an 
open-world setting. But I think the cure is to stop thinking 
that possible-messes are a problem to be solved. So, there is 
dung in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 
'linked data' practise by using examples like { 'London' a 
x:Place } - whereas I'd immediately counter with { x:London a 
'Place' }.


Surely all of the subjects as literals arguments can be 
countered with 'walk round it', and further good practise 
could be aided by a few simple notes on best practise for 
linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where 
"Subjects" have Identifiers in the form of Name References 
(which may or many resolve to Structured Representations of 
Referents carried or borne by Descriptor Docs/Resources). An 
"Identifier" != Literal.


What ARE you talking about? You sound like someone reciting 
doctrine.


Literals in RDF are just as much 'identifiers' or 'names' as 
URIs are. They identify their value, most clearly and 
emphatically. They denote in exactly the same way that URIs 
denote. "23"^^xsd:number   is about as good an identification of 
the number twenty-three as you are ever likely to get in any 
notational system since ancient Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked 
Data, slightly different mediums with some shared characteristics 
:-)


The World Wide Web is becoming a Distributed DBMS (in my eyes). 
Thus, unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed 
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local 
RDF data). My gripe simply boils down to the nuisance factor 
introduced by data object name ambiguity in a distributed data 
object oriented realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space?


It means the number twenty-three, everywhere and for all time, 
because this meaning can be computed from the very syntactic form 
of the name. How unambiguous can something get?


Pat,

Re. RDF's triples, What is a Subject? What is an Object?.


"subject' refers to the first element in a triple, "object" to the 
last. One might as well call them 'first' and 'third'. The names
'subject' and 'object' are used purely for convenience, and have no 
formal or semantic significance.




If they are the same thing, why on earth do we use Names (with 
implications) to describe the slots in an RDF triple?


I do not understand the question here well enough to provide an 
answer. Have you actually read the RDF spec documents? The RDF 
syntax model and the semantics?


You don't understand the question enough to provide an answer, but 
you are able to compute an assessment of spec assimilation. WOW !!


The logic here is: if you had understood the specs, you wouldn't be 
asking such a damn silly question as you appear to be asking. So, I 
conclude to myself, I must be misunderstanding your question. Unless, 
of course, you havn't actually read the specs...


Pat,

Assume I've read the spec and don't understand them. Rather that 
gravitating to insults, just answer the question I asked.


If too silly or dumb for you, you do have the option to ignore.

Where I come from there are no silly or dumb questions. Instead, it  
rather silly or dumb to not ask questions when pursuing clarity.


So far so good, you have spewed subjective commentary and unnecessary 
insults.


You can have a conversation without being insulting, you know.




I've only once seen the RDF triple referred to as O-R-O (by 
@danbri) i.e., Object-Relation-Object.


IF you read the specs, however, it is abundantly clear that this is 
what an RDF tri

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jul 2, 2010, at 6:52 AM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jul 1, 2010, at 9:42 AM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or  
however it is
called) claims could probably make a mess, if added or  
removed...


You can create some pretty awesome messes even without OWL:

# An rdf:List that loops around...

<#mylist> a rdf:List ;
rdf:first <#Alice> ;
rdf:next <#mylist> .

# A looping, branching mess...

<#anotherlist> a rdf:List ;
rdf:first <#anotherlist> ;
rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures  
using pointers, which is what the RDF vocabulary describes.   
Its just about impossible to guarantee that messes can't  
happen when all you are doing is describing structures in an  
open-world setting. But I think the cure is to stop thinking  
that possible-messes are a problem to be solved. So, there  
is dung in the road. Walk round it.




Could we also apply that to the 'subjects as literals'  
general discussion that's going on then?


For example I've heard people saying that it encourages bad  
'linked data' practise by using examples like { 'London' a  
x:Place } - whereas I'd immediately counter with { x:London a  
'Place' }.


Surely all of the subjects as literals arguments can be  
countered with 'walk round it', and further good practise  
could be aided by a few simple notes on best practise for  
linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where  
"Subjects" have Identifiers in the form of Name References  
(which may or many resolve to Structured Representations of  
Referents carried or borne by Descriptor Docs/Resources). An  
"Identifier" != Literal.


What ARE you talking about? You sound like someone reciting  
doctrine.


Literals in RDF are just as much 'identifiers' or 'names' as  
URIs are. They identify their value, most clearly and  
emphatically. They denote in exactly the same way that URIs  
denote. "23"^^xsd:number   is about as good an identification  
of the number twenty-three as you are ever likely to get in any  
notational system since ancient Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured  
Linked Data, slightly different mediums with some shared  
characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes).  
Thus, unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed  
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local  
RDF data). My gripe simply boils down to the nuisance factor  
introduced by data object name ambiguity in a distributed data  
object oriented realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data  
space?


It means the number twenty-three, everywhere and for all time,  
because this meaning can be computed from the very syntactic form  
of the name. How unambiguous can something get?


Pat,

Re. RDF's triples, What is a Subject? What is an Object?.


"subject' refers to the first element in a triple, "object" to the  
last. One might as well call them 'first' and 'third'. The names
'subject' and 'object' are used purely for convenience, and have no  
formal or semantic significance.




If they are the same thing, why on earth do we use Names (with  
implications) to describe the slots in an RDF triple?


I do not understand the question here well enough to provide an  
answer. Have you actually read the RDF spec documents? The RDF  
syntax model and the semantics?


You don't understand the question enough to provide an answer, but  
you are able to compute an assessment of spec assimilation. WOW !!


The logic here is: if you had understood the specs, you wouldn't be  
asking such a damn silly question as you appear to be asking. So, I  
conclude to myself, I must be misunderstanding your question. Unless,  
of course, you havn't actually read the specs...


I've only once seen the RDF triple referred to as O-R-O (by  
@danbri) i.e., Object-Relation-Object.


IF you read the specs, however, it is abundantly clear that this is  
what an RDF triple means, viz. that a relation holds between two  
objects (I prefer "things", but).


Exactly!


? I thought you were arguing *against* this view ?



So why: Subject-Predicate-Object  (SPO) everywhere re. RDF?


As I said, the terminology is used so as to make it easier to refer to  
the various parts of a triple. Yes, triples are ordered. The  
'linguistic' flavor of the SPO terminology is an unfortunate accident  
of history. In other forums

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Richard Cyganiak wrote:

Hi Yves,

[trimmed cc list]

On 2 Jul 2010, at 11:15, Yves Raimond wrote:

I am not arguing for each vendor to implement that. I am arguing for
removing this arbitrary limitation from the RDF spec. Also marked as
an issue since 2000:
http://www.w3.org/2000/03/rdf-tracking/#rdfms-literalsubjects


The demand that W3C modify the specs to allow literals as subjects 
should be rejected on a simple principle: Those who demand that change, 
including yourself, have failed to put their money where their mouth is. 
Where is the alternative specification that documents the syntactic and 
semantic extension? Where are the proposed "RDF/XML++" and "RDFa++" that 
support literals as subjects? Where are the patches to Jena, Sesame, 
Redland and ARC2 that support these changes?


The restriction seems to bother some people enough that they write noisy 
emails, but it apparently doesn't bother them enough to actually do 
anything about it.


W3C's job should be to broker compromises between non-interoperable 
approaches by different vendors, and to foster adoption by putting its 
stamp of approval on already widely deployed technologies developed by 
the community. You know, the kind of stuff that actually came out near 
the top of the RDF Next Steps work item poll [1]: named graphs, Turtle, 
RDF/JSON.


Someone mentioned HTML 3.2 in this thread. Let me mention the ill-fated 
XHTML 2.0. A group of markup purists who were more interested in 
polishing the arcane details of the language, rather than meeting the 
interests of the heaviest users and the vendors. They did an enormous 
disservice to W3C and the web. The users and vendors turned their back 
on W3C, started their own effort, and W3C ultimately had to abandon 
XHTML 2.0 or risk to become irrelevant to the future of HTML.


Literals as subjects feels very much like an XHTML 2.0 kind of feature 
to me.


Or, coming at it from a completely different direction: I have yet to 
meet a person (except Nathan perhaps) who says, "Yeah that RDF stuff, I 
had a look at it but then saw that it does not support literals as 
subjects, so I gave up on it."


To clarify - I certainly am not giving up on RDF, and RDF (with the 
exception of Graph Literals) *does* support everything I need (including 
literals as subjects) - however I am having to give up on restricting 
myself to only using the constrained subset of RDF provided by the 
common serializations.


I've found, that in order to be productive and actually make real 
applications running over a read/write web of linked data I'll need the 
most of the full RDF model & those graph literals - in other words N3 
provides everything I need [*] to be able to leave the issues behind and 
just get on being productive (and hopefully a little bit innovative).


I can, and will still publish and consume the common serializations of 
RDF we all use, but to use the data functionally in an application I 
need N3 too.


* tooling is poor of course so far.. but Toby has already stated he's 
wanting to implement in Perl, Yves has already started years ago, TimBL, 
DanC obviously with CWM, others I'm sure, and I'm certainly going to 
address an implementation for ECMAScript-262 (as are some MIT'ers) on 
client and server and quite possibly port to PHP for ARC2 (although 
that's sometime off and isn't a promise), many others have expressed the 
same sentiments over the last day or two alone - so tooling won't be an 
issue for too long, just as it isn't now for the other RDF 
serializations but was years ago.


Hope that clarifies :)

ps: fwiw, I'm with Ian, Toby, Henry and many others on this - leave the 
existing serializations alone, they are only a subset but they do the 
job quite well and let us publish and consume linked data - so it's all 
cool - changing the serializations and stack that's out there is an 
(imho) ridiculously bad idea that will benefit nobody, and it needs 
dropped from all these conversations - the original thread was from me, 
to clarify if subjects as literals were supported by the RDF Semantics, 
and they are, as if virtually anything in any position so it's a non 
issue, and certainly wasn't the issue everybodies hooked up on about 
changing rdf/xml and the likes.


Best,

Nathan

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Henry Story wrote:

On 2 Jul 2010, at 15:22, Kingsley Idehen wrote:

  

I think, the main confusion comes from the use of the term "object" for two
entirely different things: In the case of "O-R-O", it refers to (semantic)
individuals. In the case of "S-P-O", it refers to a position in a
(syntactic) RDF triple.
 
  

Conflation Conflation. It makes RDF a real PITA, unfortunately.


EAV model is crystal clear:

Entity-Attribute-Value.

Slap on HTTP names for Entity, Attribute, and Value, optionally,  and you get 
an HTTP based World Wide Web of Structured Linked Data.


This is why conflating RDF and Linked Data has nothing but downside IMHO.



It all depends to whom one is speaking Kingsley. To me EAV does not say much. 
To OO programmers
attribute values often gets them thinking somewhere along the right lines. 
  


"Value" is clearer than "Object".

A Value can be a Reference or a Literal.

A Reference can be a Name or an Address.

RDF (which I use extensively) is a problem when it comes to value 
proposition articulation. Its way too prone to the kind of thread that's 
making me miss Brazil vs. Netherlands (right now).


Anyway, I  am talking about the most basic foundation for Linked Data. 
It doens't need RDF overhang.


Simple story:

An HTTP Name for the things you deem worthy of describing and then 
sharing with others via a network (e.g. World Wide Web).
Application of said Names to Description Subject, its Attributes, and 
Attribute Values.


Do that and we can Link and Lookup stuff across an HTTP network, really 
simple!

I think it may be best to think in terms of arrows between things, as shown 
below. I think
since the 60ies everyone at the age of 5 starts learning about mappings between 
objects, these
mappings are arrows, and are very easy to understand.


  









All of these are ok with me. I also like RDF, it means many things, and
most of all Reality Distortion Field. Because as you know, our view of
reality is very distorted (just think of how people 2000 years ago saw the 
world),
and so to get to understand things better we need to enter what will seem 
a reality distortion field from our very limited point of view.
  


BTW -- Richard packs a goatee these days. Need a temporal dimension for 
richer representation LOL!



Kingsley


Henry




  



--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Michael Schneider wrote:

Kingsley Idehen wrote:

  

So why: Subject-Predicate-Object  (SPO) everywhere re. RDF?

O-R-O reflects what you've just described.

Like many of the RDF oddities (playing out nicely in this thread), you
have an O-R-O but everyone talks about S-P-O.

"Subject" has implicit meaning, it lends itself to describing stuff.  If
I recall, RDF stands for: Resource Description Framework.

I guess "Description" also means nothing?



"S-P-O" typically refers to a syntactic aspect of RDF triples, while "O-R-O"
refers to a semantic aspect.

"S-P-O": "S" ("subject") stands for the first node in an RDF triple. "P"
("predicate") for the second node. "O" ("object") for the third node. The
nodes and the triples are entities of the RDF Abstract Syntax. They don't
have any semantic meaning on their own.

"O-R-O": In the RDF semantics, a syntactic RDF triple is interpreted as a
relationship that holds between two individuals. The two "O"s refer the two
individuals (or resources, or objects), being taken from the domain of
discourse (the "world", about which assertions are made). The "R" stands for
the property (or relation; in any case a semantic entity) that is used to
define the relationship between the two individuals. 


So, these are very different aspects that must not be confused. An "S-P-O"
syntactic RDF triple is interpreted as a "O-R-O" semantic relationship
between individuals. The "S" in "S-P-O" can be a URI, a bNode, and maybe
also a literal in the future. The "O"s in "O-R-O" stand for entities in the
"world". A semantic interpretation function can then use the "S" to denote
(to "name") the "O". But there is no a-priory connection between the two:
any "S-P-O" triple can be interpreted by any "O-R-O" relationship.

I think, the main confusion comes from the use of the term "object" for two
entirely different things: In the case of "O-R-O", it refers to (semantic)
individuals. In the case of "S-P-O", it refers to a position in a
(syntactic) RDF triple.
  


Conflation Conflation. It makes RDF a real PITA, unfortunately.


EAV model is crystal clear:

Entity-Attribute-Value.

Slap on HTTP names for Entity, Attribute, and Value, optionally,  and 
you get an HTTP based World Wide Web of Structured Linked Data.



This is why conflating RDF and Linked Data has nothing but downside IMHO.


Kingsley

Michael

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===


  



--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Michael Schneider]

Kingsley Idehen wrote:

>So why: Subject-Predicate-Object  (SPO) everywhere re. RDF?
>
>O-R-O reflects what you've just described.
>
>Like many of the RDF oddities (playing out nicely in this thread), you
>have an O-R-O but everyone talks about S-P-O.
>
>"Subject" has implicit meaning, it lends itself to describing stuff.  If
>I recall, RDF stands for: Resource Description Framework.
>
>I guess "Description" also means nothing?

"S-P-O" typically refers to a syntactic aspect of RDF triples, while "O-R-O"
refers to a semantic aspect.

"S-P-O": "S" ("subject") stands for the first node in an RDF triple. "P"
("predicate") for the second node. "O" ("object") for the third node. The
nodes and the triples are entities of the RDF Abstract Syntax. They don't
have any semantic meaning on their own.

"O-R-O": In the RDF semantics, a syntactic RDF triple is interpreted as a
relationship that holds between two individuals. The two "O"s refer the two
individuals (or resources, or objects), being taken from the domain of
discourse (the "world", about which assertions are made). The "R" stands for
the property (or relation; in any case a semantic entity) that is used to
define the relationship between the two individuals. 

So, these are very different aspects that must not be confused. An "S-P-O"
syntactic RDF triple is interpreted as a "O-R-O" semantic relationship
between individuals. The "S" in "S-P-O" can be a URI, a bNode, and maybe
also a literal in the future. The "O"s in "O-R-O" stand for entities in the
"world". A semantic interpretation function can then use the "S" to denote
(to "name") the "O". But there is no a-priory connection between the two:
any "S-P-O" triple can be interpreted by any "O-R-O" relationship.

I think, the main confusion comes from the use of the term "object" for two
entirely different things: In the case of "O-R-O", it refers to (semantic)
individuals. In the case of "S-P-O", it refers to a position in a
(syntactic) RDF triple.

Michael

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Ivan Mikhailov]

On Fri, 2010-07-02 at 12:42 +0200, Richard Cyganiak wrote:
> Hi Yves,

> On 2 Jul 2010, at 11:15, Yves Raimond wrote:
> > I am not arguing for each vendor to implement that. I am arguing for
> > removing this arbitrary limitation from the RDF spec. Also marked as
> > an issue since 2000:
> > http://www.w3.org/2000/03/rdf-tracking/#rdfms-literalsubjects
> 
> The demand that W3C modify the specs to allow literals as subjects  
> should be rejected on a simple principle: Those who demand that  
> change, including yourself, have failed to put their money where their  
> mouth is. Where is the alternative specification that documents the  
> syntactic and semantic extension? Where are the proposed "RDF/XML++"  
> and "RDFa++" that support literals as subjects? Where are the patches  
> to Jena, Sesame, Redland and ARC2 that support these changes?

+1, with a small correction. I'd expect a patch for Virtuoso as well ;)

Actually, the approval of a new spec will require two adequate
implementations. I can't imagine that existing vendors will decide to
waste their time to make their products worse in terms of speed and disk
footprint and scalability. "The most efficient critics is sabotage", you
know.

Some new vendor may of course try to become a "strikebreaker" but his
benchmark runs will look quite poorly, because others will continue to
optimize any SPARQL BGP like

?s ?p ?o .
?o ?p2 ?s2 .

into more selective

?s ?p ?o . FILTER (isREFERENCE (?o)) .
?o ?p2 ?s2 .

and this sort of rewriting will easily bring them two orders of
magnitude of speed on a simple query with less than 10 triple patterns.
Keeping in mind that Bio2RDF people tend to write queries with 20-30
triple patterns mostly connected into long chains, the speed difference
on real life queries will be a blocking issue.

-

The discussion is quite long; I'm sorry I can't continue to track it
accurately, I'm on a critical path of a new Virtuoso release.

If somebody is interested in
a whole list of reasons why I will not put this feature into the DB core
or
a whole list of workarounds for it at DB application level
or
a detailed history of round Earth and Columbus
then
ping me and I'll write a page at ESW wiki.

Best Regards,

Ivan Mikhailov
OpenLink Virtuoso
http://virtuoso.openlinksw.com

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

Hi Richard!

>
> [trimmed cc list]
>
> On 2 Jul 2010, at 11:15, Yves Raimond wrote:
>>
>> I am not arguing for each vendor to implement that. I am arguing for
>> removing this arbitrary limitation from the RDF spec. Also marked as
>> an issue since 2000:
>> http://www.w3.org/2000/03/rdf-tracking/#rdfms-literalsubjects
>
> The demand that W3C modify the specs to allow literals as subjects should be
> rejected on a simple principle: Those who demand that change, including
> yourself, have failed to put their money where their mouth is. Where is the
> alternative specification that documents the syntactic and semantic
> extension? Where are the proposed "RDF/XML++" and "RDFa++" that support
> literals as subjects? Where are the patches to Jena, Sesame, Redland and
> ARC2 that support these changes?

This is a really unfair comment, Richard, and I am sure you realise
that. We are arguing for a very small modification of
http://www.w3.org/TR/rdf-concepts/#section-Literals - not of any
serialisation at the moment. Some of them happen to already support
that (the RDF subset of N3). The serialisation work is outside of the
scope of this discussion (but should happen, I agree) - let's stick to
small, iterative, improvements and bug fixes.

>
> The restriction seems to bother some people enough that they write noisy
> emails, but it apparently doesn't bother them enough to actually do anything
> about it.
>

Same thing - very unfair. We are being very specific about the change
we want made. Some of us implemented patches and libraries supporting
that (I wrote a swi-prolog one, Toby mentioned a Perl one, CWM
supports it since ages, as well as all other N3 engines). So, please,
if you want to criticise our proposal, do it on a sound basis, instead
of just trying to get as many people as you can very frustrated at the
way such decisions are being made.

Also, putting forward the "us vs. them" argument is not really the
best way to move forward, as I am sure you would agree. We suffered
from that in the LOD community a lot (and as Dan points out, still
suffer from that a lot in the whole Semantic Web community), so please
stop sending such emails anytime you feel in opposition with a
proposal, and let's have a fruitful debate.

> W3C's job should be to broker compromises between non-interoperable
> approaches by different vendors, and to foster adoption by putting its stamp
> of approval on already widely deployed technologies developed by the
> community. You know, the kind of stuff that actually came out near the top
> of the RDF Next Steps work item poll [1]: named graphs, Turtle, RDF/JSON.
>

W3C's job is also to provide bug-free specs, and interoperable one.
The fact that you can CONSTRUCT an invalid RDF document in SPARQL,
whilst still being valid SPARQL, is bad IMHO.

> Someone mentioned HTML 3.2 in this thread. Let me mention the ill-fated
> XHTML 2.0. A group of markup purists who were more interested in polishing
> the arcane details of the language, rather than meeting the interests of the
> heaviest users and the vendors. They did an enormous disservice to W3C and
> the web. The users and vendors turned their back on W3C, started their own
> effort, and W3C ultimately had to abandon XHTML 2.0 or risk to become
> irrelevant to the future of HTML.
>
> Literals as subjects feels very much like an XHTML 2.0 kind of feature to
> me.
>
> Or, coming at it from a completely different direction: I have yet to meet a
> person (except Nathan perhaps) who says, "Yeah that RDF stuff, I had a look
> at it but then saw that it does not support literals as subjects, so I gave
> up on it."

The same reasoning can be applied to all the things in the current
item poll: Turtle not existing didn't stop people publishing RDF/XML.
Named Graphs not being spec'ed out didn't stop them either. So I would
also argue this is a buggy argument, mostly there for drawing more FUD
on a thread that, I think, doesn't need more.

Best,
y

>
> Best,
> Richard
>
> [1] http://www.w3.org/2010/06/rdf-work-items/table
>
>
>>
>> That aside, I don't see your point about extra hardware. There is, in
>> my experience, no substantial difference between storing
>>
>> <#me> foaf:name "Ivan" and "Ivan" :name_of <#me>.
>>
>>> _not_enough_unique_ to interlink data.
>>
>> There are. Their value is their identity. They are *perfectly* unique.
>> "cat" is uniquely identifying the string made of c, a and t. From your
>> previous email, I suppose you're concerned about rounding for floats
>> and doubles, is that it? If so, whatever you write as their rounded
>> value is their identity (and we can't write "Pi"^^xsd:real afaik :) ).
>>
>>>
>>> [ ] str:double_metaphone_word "Acton" ; str:double_metaphone "AKTN" .
>>> and
>>> [ ] str:soundex_word "Smith" ; str:soundex "S530" .
>>>
>>
>> I agree this is another way to model it, and Jeremy suggested it as
>> well. But it creates a level of indirection and, from a modeling point
>> of view, does look very weird. If you we

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Pat Hayes wrote:


On Jul 1, 2010, at 9:42 AM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or 
however it is
called) claims could probably make a mess, if added or 
removed...


You can create some pretty awesome messes even without OWL:

 # An rdf:List that loops around...

 <#mylist> a rdf:List ;
 rdf:first <#Alice> ;
 rdf:next <#mylist> .

 # A looping, branching mess...

 <#anotherlist> a rdf:List ;
 rdf:first <#anotherlist> ;
 rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just 
about impossible to guarantee that messes can't happen when all 
you are doing is describing structures in an open-world 
setting. But I think the cure is to stop thinking that 
possible-messes are a problem to be solved. So, there is dung 
in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 
'linked data' practise by using examples like { 'London' a 
x:Place } - whereas I'd immediately counter with { x:London a 
'Place' }.


Surely all of the subjects as literals arguments can be 
countered with 'walk round it', and further good practise could 
be aided by a few simple notes on best practise for linked data 
etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where 
"Subjects" have Identifiers in the form of Name References (which 
may or many resolve to Structured Representations of Referents 
carried or borne by Descriptor Docs/Resources). An "Identifier" 
!= Literal.


What ARE you talking about? You sound like someone reciting doctrine.

Literals in RDF are just as much 'identifiers' or 'names' as URIs 
are. They identify their value, most clearly and emphatically. 
They denote in exactly the same way that URIs denote. 
"23"^^xsd:number   is about as good an identification of the 
number twenty-three as you are ever likely to get in any 
notational system since ancient Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked 
Data, slightly different mediums with some shared characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes). 
Thus, unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed 
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local 
RDF data). My gripe simply boils down to the nuisance factor 
introduced by data object name ambiguity in a distributed data 
object oriented realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space?


It means the number twenty-three, everywhere and for all time, 
because this meaning can be computed from the very syntactic form of 
the name. How unambiguous can something get?


Pat,

Re. RDF's triples, What is a Subject? What is an Object?.


"subject' refers to the first element in a triple, "object" to the 
last. One might as well call them 'first' and 'third'. The names
'subject' and 'object' are used purely for convenience, and have no 
formal or semantic significance.




If they are the same thing, why on earth do we use Names (with 
implications) to describe the slots in an RDF triple?


I do not understand the question here well enough to provide an 
answer. Have you actually read the RDF spec documents? The RDF syntax 
model and the semantics?


You don't understand the question enough to provide an answer, but you 
are able to compute an assessment of spec assimilation. WOW !!




I've only once seen the RDF triple referred to as O-R-O (by @danbri) 
i.e., Object-Relation-Object.


IF you read the specs, however, it is abundantly clear that this is 
what an RDF triple means, viz. that a relation holds between two 
objects (I prefer "things", but).


Exactly!

So why: Subject-Predicate-Object  (SPO) everywhere re. RDF?

O-R-O reflects what you've just described.

Like many of the RDF oddities (playing out nicely in this thread), you 
have an O-R-O but everyone talks about S-P-O.


"Subject" has implicit meaning, it lends itself to describing stuff.  If 
I recall, RDF stands for: Resource Description Framework.


I guess "Description" also means nothing?





In addition, I don't see Information and Data as being the same 
thing. Information (as I know it) is about Data + Context.  Raw Data 
(as I know it) is about: a unit of observation and deemed worthy of 
description by its observer.  You have to give Names to subject of a 
description. "23"^^xsd:numb

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Henry Story]

On 2 Jul 2010, at 12:42, Richard Cyganiak wrote:

> Hi Yves,
> 
> [trimmed cc list]
> 
> On 2 Jul 2010, at 11:15, Yves Raimond wrote:
>> I am not arguing for each vendor to implement that. I am arguing for
>> removing this arbitrary limitation from the RDF spec. Also marked as
>> an issue since 2000:
>> http://www.w3.org/2000/03/rdf-tracking/#rdfms-literalsubjects
> 
> The demand that W3C modify the specs to allow literals as subjects should be 
> rejected on a simple principle: Those who demand that change, including 
> yourself, have failed to put their money where their mouth is. Where is the 
> alternative specification that documents the syntactic and semantic 
> extension? Where are the proposed "RDF/XML++" and "RDFa++" that support 
> literals as subjects? Where are the patches to Jena, Sesame, Redland and ARC2 
> that support these changes?
> 
> The restriction seems to bother some people enough that they write noisy 
> emails, but it apparently doesn't bother them enough to actually do anything 
> about it.

Sorry it is implemented in Cwm, and Euler sharp, and the N3 javascript parser 
in tabulator, and we
hear about rules having them, and even them being allowed by the latest OWL 2 
spec.

Furthermore as argued it is not complicated to do allow existing systems to use 
this:

take any 

 "ted" chars 3 .

and transform to

 [] sameas "ted"
chars 3.

There is even a language for it called N3, that is what SPARQL was based on.

   So I don't see why you have to be so agressive here.

Henry

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Richard Cyganiak]

Hi Yves,

[trimmed cc list]

On 2 Jul 2010, at 11:15, Yves Raimond wrote:

I am not arguing for each vendor to implement that. I am arguing for
removing this arbitrary limitation from the RDF spec. Also marked as
an issue since 2000:
http://www.w3.org/2000/03/rdf-tracking/#rdfms-literalsubjects


The demand that W3C modify the specs to allow literals as subjects  
should be rejected on a simple principle: Those who demand that  
change, including yourself, have failed to put their money where their  
mouth is. Where is the alternative specification that documents the  
syntactic and semantic extension? Where are the proposed "RDF/XML++"  
and "RDFa++" that support literals as subjects? Where are the patches  
to Jena, Sesame, Redland and ARC2 that support these changes?


The restriction seems to bother some people enough that they write  
noisy emails, but it apparently doesn't bother them enough to actually  
do anything about it.


W3C's job should be to broker compromises between non-interoperable  
approaches by different vendors, and to foster adoption by putting its  
stamp of approval on already widely deployed technologies developed by  
the community. You know, the kind of stuff that actually came out near  
the top of the RDF Next Steps work item poll [1]: named graphs,  
Turtle, RDF/JSON.


Someone mentioned HTML 3.2 in this thread. Let me mention the ill- 
fated XHTML 2.0. A group of markup purists who were more interested in  
polishing the arcane details of the language, rather than meeting the  
interests of the heaviest users and the vendors. They did an enormous  
disservice to W3C and the web. The users and vendors turned their back  
on W3C, started their own effort, and W3C ultimately had to abandon  
XHTML 2.0 or risk to become irrelevant to the future of HTML.


Literals as subjects feels very much like an XHTML 2.0 kind of feature  
to me.


Or, coming at it from a completely different direction: I have yet to  
meet a person (except Nathan perhaps) who says, "Yeah that RDF stuff,  
I had a look at it but then saw that it does not support literals as  
subjects, so I gave up on it."


Best,
Richard

[1] http://www.w3.org/2010/06/rdf-work-items/table




That aside, I don't see your point about extra hardware. There is, in
my experience, no substantial difference between storing

<#me> foaf:name "Ivan" and "Ivan" :name_of <#me>.


_not_enough_unique_ to interlink data.


There are. Their value is their identity. They are *perfectly* unique.
"cat" is uniquely identifying the string made of c, a and t. From your
previous email, I suppose you're concerned about rounding for floats
and doubles, is that it? If so, whatever you write as their rounded
value is their identity (and we can't write "Pi"^^xsd:real afaik :) ).



[ ] str:double_metaphone_word "Acton" ; str:double_metaphone "AKTN" .
and
[ ] str:soundex_word "Smith" ; str:soundex "S530" .



I agree this is another way to model it, and Jeremy suggested it as
well. But it creates a level of indirection and, from a modeling point
of view, does look very weird. If you were to extend that model to,
say, "1" list:in (1 2 3), that would look very nasty...

Best,
y

are at least protected from collisions and allow more properties to  
be added in a safe way.



Best Regards,

Ivan Mikhailov
OpenLink Software
http://virtuoso.openlinksw.com

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Ivan Mikhailov]

On Fri, 2010-07-02 at 08:50 +0100, Graham Klyne wrote:
> [cc's trimmed]
> 
> I'm with Jeremy here, the problem's economic not technical.
> 
> If we could introduce subjects-as-literals in a way that:
> (a) doesn't invalidate any existing RDF, and
> (b) doesn't permit the generation of RDF/XML that existing applications 
> cannot 
> parse,
> 
> then I think there's a possible way forward.

Yes, there's such a way, more over, it will be just a small subset of a
richer language that is widely used already, so it will require very
little coding.

When there's a need in SPARQL-like extensions, like
subjects-as-literals, there's a straightforward way of serializing data
as SPARQL fragments. Note that in this way not only subjects-as-literals
are available, but even SPARQL 1.1 features like path expressions or
"for each X" expressed as "?X" in an appropriate place of an appropriate
BGP.

Best Regards,

Ivan Mikhailov,
OpenLink Software
http://virtuoso.openlinksw.com

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Ian Davis]

Yves,

On Fri, Jul 2, 2010 at 10:15 AM, Yves Raimond  wrote:
> First: this is *not* a dirty hack.
>
> "Brickley" bif:contains "ckley" is a perfectly valid thing to say.
>

You could, today, use data: URIs to represent literals with no change
to any RDF system.

Ian

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Michael Schneider]

Pat Hayes wrote:

>Just to clarify, this is a purely syntactic restriction. Allowing
>literals in subject position would require **no change at all** to the
>RDF semantics. 

Indeed.

And this is probably one of the reasons why several RDF-related standards
have already adopted literal subjects. Some examples:

* For the OWL 2 RDF-Based Semantics, being an extension of the RDF
Semantics, it has been explicitly allowed (in the "MAY" sense) to apply it
to "generalized RDF", where literals and bNodes may occur in any position of
a triple:



(However, OWL 2 Full is still defined to be the language that consists of
the RDF-Based Semantics and the official RDF Syntax, i.e. where subjects are
not allowed to be literals.)

* The OWL 2 RL/RDF Ruleset also allows for generalized RDF, see the second
paragraph of 

 


* The RIF RDF and OWL Compatibility specification (just became a W3C
Recommendation) also uses generalized RDF, see the note at

 


and the definitions at

 


* SPARQL 1.1 (still work in progress) allows literal subjects in Triple
Patterns:

 

I could imagine that this list of important technologies allowing for
literal subjects will grow over time, and maybe there even exist some more
today that I missed. If RDF2 would also adopt generalized RDF, all these
RDF-dependent standards could then be updated by dropping all these "MAY"s
and similar statements.

Michael

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

Hello Ivan!

On Fri, Jul 2, 2010 at 5:50 AM, Ivan Mikhailov
 wrote:
> Hello Yves,
>
>> > It's a virtuoso function surfaced as a predicate.
>> > "magic predicate" was an initial moniker used at creation time.
>> > "bif:contains" doesn't exist in pure triple form etc..
>>
>> Why couldn't it? For example, you may want to express exactly what
>> triple lead you to give a particular result, and within that scope you
>> may end up having to write: "Brickley" bif:contains "ckley" in RDF.
>>
>> Forbidding literals as subjects makes this statement impossible to
>> express, however that's a very sensible thing you may want to express.
>>
>> There are also lots of literal search examples that comes to mind:
>>
>> "Acton" str:double_metaphone "AKTN" .
>> "Smith" str:soundex "S530" .
>
> Yes, SPARQL permits literals in subject position, and we use that for
> dirty hacks. That does not mean that raw data should permit the same.
> SPARQL (and especially our SPARQL/BI) uses many different things in
> subject position, e.g., variables (and expressions, up to subqueries)
> that's not an excuse to allow the same in raw data.

First: this is *not* a dirty hack.

"Brickley" bif:contains "ckley" is a perfectly valid thing to say.

>
> I don't even say about technical price of the extension for both
> developers (extra work) and each user of any big RDF storage (extra
> hardware). I simply don't see a reason, because literals are simply

I am not arguing for each vendor to implement that. I am arguing for
removing this arbitrary limitation from the RDF spec. Also marked as
an issue since 2000:
http://www.w3.org/2000/03/rdf-tracking/#rdfms-literalsubjects

That aside, I don't see your point about extra hardware. There is, in
my experience, no substantial difference between storing

<#me> foaf:name "Ivan" and "Ivan" :name_of <#me>.

> _not_enough_unique_ to interlink data.

There are. Their value is their identity. They are *perfectly* unique.
"cat" is uniquely identifying the string made of c, a and t. From your
previous email, I suppose you're concerned about rounding for floats
and doubles, is that it? If so, whatever you write as their rounded
value is their identity (and we can't write "Pi"^^xsd:real afaik :) ).

>
> [ ] str:double_metaphone_word "Acton" ; str:double_metaphone "AKTN" .
> and
> [ ] str:soundex_word "Smith" ; str:soundex "S530" .
>

I agree this is another way to model it, and Jeremy suggested it as
well. But it creates a level of indirection and, from a modeling point
of view, does look very weird. If you were to extend that model to,
say, "1" list:in (1 2 3), that would look very nasty...

Best,
y

> are at least protected from collisions and allow more properties to be added 
> in a safe way.
>
>
> Best Regards,
>
> Ivan Mikhailov
> OpenLink Software
> http://virtuoso.openlinksw.com
>
>
>

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Graham Klyne]

[cc's trimmed]

I'm with Jeremy here, the problem's economic not technical.

If we could introduce subjects-as-literals in a way that:
(a) doesn't invalidate any existing RDF, and
(b) doesn't permit the generation of RDF/XML that existing applications cannot 
parse,


then I think there's a possible way forward.

#g
--

BTW, which list is the most appropriate for this discussion?  I seem to be 
getting 4 copies of some messages!



Jeremy Carroll wrote:

Jiří Procházka wrote:


I wonder, when using owl:sameAs or related, to "name" literals to be
able to say other useful thing about them in normal triples (datatype,
language, etc) does it break OWL DL 

yes it does


(or any other formalism which is
base of some ontology extending RDF semantics)?


Not OWL full

 Or would it if
rdf:sameAs was introduced?
  


It would still break OWL DL

Best,
Jiri
  
OWL DL is orthogonal to this issue. The OWL DLers already prohibit 
certain RDF - specifically the workaround for not having literal as 
subjects. So they are neutral.
I reiterate that I agree whole-heartedly with the technical arguments 
for making this change; however the economic case is missing.


Jeremy

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Pat Hayes wrote:


On Jul 2, 2010, at 12:07 AM, Nathan wrote:


Pat Hayes wrote:

On Jul 1, 2010, at 11:49 PM, Nathan wrote:

Pat Hayes wrote:

On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:

"A literal may be the object of an RDF statement, but not the subject
or the predicate."
Just to clarify, this is a purely syntactic restriction. Allowing 
literals in subject position would require **no change at all** to 
the RDF semantics. (The non-normative inference rules for RDF and 
RDFS and D-entailment given in the semantics document would need 
revision, but they would then be simplified.)


I have to wonder then, what can one all place in the s,p,o slots 
without changing the RDF semantics? literal and bnode predicates for 
instance? variables or formulae as in n3?


read as: if a new serialization/syntax was defined for RDF what are 
the limitations for the values of node/object and relationship 
specified by the RDF Semantics?
None at all. The semantics as stated works fine with triples which 
have any kind of syntactic node in any position in any combination. 
The same basic semantic construction is used in ISO Common Logic, 
which allows complete syntactic freedom, so that the the same name 
can denote an individual, a property, a function and a proposition 
all at the same time.

Pat
PS. Its not a dumb question :-)


thus is N3 valid RDF? (I read yes, but want/need to hear that's right!)


Well, no. It depends what you mean by 'valid RDF'. N3 obviously has a 
lot of syntax that goes way beyond what is legal in RDF, so its not 
valid RDF. But if you mean, the basic RDF semantics can be extended to 
cover all the constructs in N3 (without completely breaking) then yes, 
it can. In fact, N3 is a subset of Common Logic, and the same basic 
semantic construction of RDF works for all of CL.  But it would be a 
real extension, in that all the 'extra' syntax of N3 (notably, the graph 
literals idea) would need to have its semantics specified explicitly. It 
wouldn't come for free.


Hope I've answered your question (?)



perfectly, thanks!

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jul 2, 2010, at 12:07 AM, Nathan wrote:


Pat Hayes wrote:

On Jul 1, 2010, at 11:49 PM, Nathan wrote:

Pat Hayes wrote:

On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:
"A literal may be the object of an RDF statement, but not the  
subject

or the predicate."
Just to clarify, this is a purely syntactic restriction. Allowing  
literals in subject position would require **no change at all**  
to the RDF semantics. (The non-normative inference rules for RDF  
and RDFS and D-entailment given in the semantics document would  
need revision, but they would then be simplified.)


I have to wonder then, what can one all place in the s,p,o slots  
without changing the RDF semantics? literal and bnode predicates  
for instance? variables or formulae as in n3?


read as: if a new serialization/syntax was defined for RDF what  
are the limitations for the values of node/object and relationship  
specified by the RDF Semantics?
None at all. The semantics as stated works fine with triples which  
have any kind of syntactic node in any position in any combination.  
The same basic semantic construction is used in ISO Common Logic,  
which allows complete syntactic freedom, so that the the same name  
can denote an individual, a property, a function and a proposition  
all at the same time.

Pat
PS. Its not a dumb question :-)


thus is N3 valid RDF? (I read yes, but want/need to hear that's  
right!)


Well, no. It depends what you mean by 'valid RDF'. N3 obviously has a  
lot of syntax that goes way beyond what is legal in RDF, so its not  
valid RDF. But if you mean, the basic RDF semantics can be extended to  
cover all the constructs in N3 (without completely breaking) then yes,  
it can. In fact, N3 is a subset of Common Logic, and the same basic  
semantic construction of RDF works for all of CL.  But it would be a  
real extension, in that all the 'extra' syntax of N3 (notably, the  
graph literals idea) would need to have its semantics specified  
explicitly. It wouldn't come for free.


Hope I've answered your question (?)

Pat



ty so far,

nathan





IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Pat Hayes wrote:


On Jul 1, 2010, at 11:49 PM, Nathan wrote:


Pat Hayes wrote:

On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:

"A literal may be the object of an RDF statement, but not the subject
or the predicate."
Just to clarify, this is a purely syntactic restriction. Allowing 
literals in subject position would require **no change at all** to 
the RDF semantics. (The non-normative inference rules for RDF and 
RDFS and D-entailment given in the semantics document would need 
revision, but they would then be simplified.)


I have to wonder then, what can one all place in the s,p,o slots 
without changing the RDF semantics? literal and bnode predicates for 
instance? variables or formulae as in n3?


read as: if a new serialization/syntax was defined for RDF what are 
the limitations for the values of node/object and relationship 
specified by the RDF Semantics?


None at all. The semantics as stated works fine with triples which have 
any kind of syntactic node in any position in any combination. The same 
basic semantic construction is used in ISO Common Logic, which allows 
complete syntactic freedom, so that the the same name can denote an 
individual, a property, a function and a proposition all at the same time.


Pat

PS. Its not a dumb question :-)


thus is N3 valid RDF? (I read yes, but want/need to hear that's right!)

ty so far,

nathan

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jul 1, 2010, at 11:49 PM, Nathan wrote:


Pat Hayes wrote:

On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:
"A literal may be the object of an RDF statement, but not the  
subject

or the predicate."
Just to clarify, this is a purely syntactic restriction. Allowing  
literals in subject position would require **no change at all** to  
the RDF semantics. (The non-normative inference rules for RDF and  
RDFS and D-entailment given in the semantics document would need  
revision, but they would then be simplified.)


I have to wonder then, what can one all place in the s,p,o slots  
without changing the RDF semantics? literal and bnode predicates for  
instance? variables or formulae as in n3?


read as: if a new serialization/syntax was defined for RDF what are  
the limitations for the values of node/object and relationship  
specified by the RDF Semantics?


None at all. The semantics as stated works fine with triples which  
have any kind of syntactic node in any position in any combination.  
The same basic semantic construction is used in ISO Common Logic,  
which allows complete syntactic freedom, so that the the same name can  
denote an individual, a property, a function and a proposition all at  
the same time.


Pat

PS. Its not a dumb question :-)



Best,

Nathan

ps: apologies if this is a dumb question, I fear i'd still be hear  
next year trying to answer it myself though ;)






IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Ivan Mikhailov]

Hello Yves,

> > It's a virtuoso function surfaced as a predicate.
> > "magic predicate" was an initial moniker used at creation time.
> > "bif:contains" doesn't exist in pure triple form etc..
> 
> Why couldn't it? For example, you may want to express exactly what
> triple lead you to give a particular result, and within that scope you
> may end up having to write: "Brickley" bif:contains "ckley" in RDF.
> 
> Forbidding literals as subjects makes this statement impossible to
> express, however that's a very sensible thing you may want to express.
> 
> There are also lots of literal search examples that comes to mind:
> 
> "Acton" str:double_metaphone "AKTN" .
> "Smith" str:soundex "S530" .

Yes, SPARQL permits literals in subject position, and we use that for
dirty hacks. That does not mean that raw data should permit the same.
SPARQL (and especially our SPARQL/BI) uses many different things in
subject position, e.g., variables (and expressions, up to subqueries)
that's not an excuse to allow the same in raw data.

I don't even say about technical price of the extension for both
developers (extra work) and each user of any big RDF storage (extra
hardware). I simply don't see a reason, because literals are simply
_not_enough_unique_ to interlink data.

[ ] str:double_metaphone_word "Acton" ; str:double_metaphone "AKTN" .
and
[ ] str:soundex_word "Smith" ; str:soundex "S530" .

are at least protected from collisions and allow more properties to be added in 
a safe way.


Best Regards,

Ivan Mikhailov
OpenLink Software
http://virtuoso.openlinksw.com

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Pat Hayes wrote:

On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:

"A literal may be the object of an RDF statement, but not the subject
or the predicate."


Just to clarify, this is a purely syntactic restriction. Allowing 
literals in subject position would require **no change at all** to the 
RDF semantics. (The non-normative inference rules for RDF and RDFS and 
D-entailment given in the semantics document would need revision, but 
they would then be simplified.)


I have to wonder then, what can one all place in the s,p,o slots without 
changing the RDF semantics? literal and bnode predicates for instance? 
variables or formulae as in n3?


read as: if a new serialization/syntax was defined for RDF what are the 
limitations for the values of node/object and relationship specified by 
the RDF Semantics?


Best,

Nathan

ps: apologies if this is a dumb question, I fear i'd still be hear next 
year trying to answer it myself though ;)

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jul 1, 2010, at 11:18 AM, Yves Raimond wrote:

On Thu, Jul 1, 2010 at 3:46 PM, Henry Story   
wrote:


On 1 Jul 2010, at 16:35, Kingsley Idehen wrote:


Yves Raimond wrote:

Hello Kingsley!


[snip]



IMHO an emphatic NO.

RDF is about constructing structured descriptions where  
"Subjects" have
Identifiers in the form of Name References (which may or many  
resolve to
Structured Representations of Referents carried or borne by  
Descriptor

Docs/Resources). An "Identifier" != Literal.

If you are in a situation where you can't or don't want to mint  
an HTTP

based Name, simply use a URN, it does the job.



It does look like you're already using literal subjects in OpenLink
Virtuoso though:

http://docs.openlinksw.com/virtuoso/rdfsparql.html

SQL>SELECT *
FROM 
WHERE
 {
   ?s foaf:Name ?name . ?name bif:contains "'rich*'".
 }

Best,
y




Were is the Literal Subject in the query above?

bif:contains is a function/magic predicate scoped to Literal  
Objects.


 != "people".

What am I missing?


Why do you think it is magic? Such a relation makes complete sense.
Given that is is a relation between literals it can be tested  
without needing

to look at the world. Just like an math:isgreaterThan relation ...

In fact I wonder how much SPARQL could be simplified by thinking of  
things this

way. Could one perhaps get rid of the FILTER( ) clause?


+1

Almost all FILTER functions I know of could be done using predicates
in the where clause (it would even look a bit more like SQL :) ).



In any case RDF Semantics does, I believe,
allow literals in subject position. It is just that many many  
syntaxes

don't allow that to be expressed,



It doesn't seem to be allowed in the RDF semantics:
http://www.w3.org/TR/rdf-concepts/#section-Literals

"A literal may be the object of an RDF statement, but not the subject
or the predicate."


Just to clarify, this is a purely syntactic restriction. Allowing  
literals in subject position would require **no change at all** to the  
RDF semantics. (The non-normative inference rules for RDF and RDFS and  
D-entailment given in the semantics document would need revision, but  
they would then be simplified.)


Pat





But there is nothing you can do to stop that happening  
semantically.  A URI or bnode

can just be names for strings.

And as for it requiring a change to the infrastructure of your DB,  
it is not clear that

it immediately does, since you can alwasy rewrite


"father" containsLetters 6 .

as

[] owl:sameAs "father";
  containsLetters 6 .

Henry




--

Regards,

Kingsley Idehen President & CEO OpenLink Software  
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen














IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jul 1, 2010, at 9:42 AM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or  
however it is
called) claims could probably make a mess, if added or  
removed...


You can create some pretty awesome messes even without OWL:

 # An rdf:List that loops around...

 <#mylist> a rdf:List ;
 rdf:first <#Alice> ;
 rdf:next <#mylist> .

 # A looping, branching mess...

 <#anotherlist> a rdf:List ;
 rdf:first <#anotherlist> ;
 rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using  
pointers, which is what the RDF vocabulary describes.  Its  
just about impossible to guarantee that messes can't happen  
when all you are doing is describing structures in an open- 
world setting. But I think the cure is to stop thinking that  
possible-messes are a problem to be solved. So, there is dung  
in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general  
discussion that's going on then?


For example I've heard people saying that it encourages bad  
'linked data' practise by using examples like { 'London' a  
x:Place } - whereas I'd immediately counter with { x:London a  
'Place' }.


Surely all of the subjects as literals arguments can be  
countered with 'walk round it', and further good practise could  
be aided by a few simple notes on best practise for linked data  
etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where  
"Subjects" have Identifiers in the form of Name References  
(which may or many resolve to Structured Representations of  
Referents carried or borne by Descriptor Docs/Resources). An  
"Identifier" != Literal.


What ARE you talking about? You sound like someone reciting  
doctrine.


Literals in RDF are just as much 'identifiers' or 'names' as URIs  
are. They identify their value, most clearly and emphatically.  
They denote in exactly the same way that URIs denote.  
"23"^^xsd:number   is about as good an identification of the  
number twenty-three as you are ever likely to get in any  
notational system since ancient Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked  
Data, slightly different mediums with some shared  
characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes).  
Thus, unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed  
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local  
RDF data). My gripe simply boils down to the nuisance factor  
introduced by data object name ambiguity in a distributed data  
object oriented realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space?


It means the number twenty-three, everywhere and for all time,  
because this meaning can be computed from the very syntactic form  
of the name. How unambiguous can something get?


Pat,

Re. RDF's triples, What is a Subject? What is an Object?.


"subject' refers to the first element in a triple, "object" to the  
last. One might as well call them 'first' and 'third'. The names
'subject' and 'object' are used purely for convenience, and have no  
formal or semantic significance.




If they are the same thing, why on earth do we use Names (with  
implications) to describe the slots in an RDF triple?


I do not understand the question here well enough to provide an  
answer. Have you actually read the RDF spec documents? The RDF syntax  
model and the semantics?




I've only once seen the RDF triple referred to as O-R-O (by @danbri)  
i.e., Object-Relation-Object.


IF you read the specs, however, it is abundantly clear that this is  
what an RDF triple means, viz. that a relation holds between two  
objects (I prefer "things", but).




In addition, I don't see Information and Data as being the same  
thing. Information (as I know it) is about Data + Context.  Raw Data  
(as I know it) is about: a unit of observation and deemed worthy of  
description by its observer.  You have to give Names to subject of a  
description. "23"^^xsd:number  isn't a Name.


Why do you say this? It is certainly as much a name as, say, "Patrick  
J. Hayes". It is a well-formed string which denotes something, and its  
denotation is perfectly clear, in fact computable. So, it is a name. I  
challenge you to specify what you mean by "Name" in such a way that it  
excludes literals as names, other than by simply reiterating your bare  
claim that they are not.




**
I guess my own subtle mistake (re. this thread) is deeming  
Identifiers and Names to be equivalent , wh

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jul 1, 2010, at 3:38 AM, Henry Story wrote:



On 30 Jun 2010, at 21:09, Pat Hayes wrote:



For example I've heard people saying that it encourages bad  
'linked data' practise by using examples like { 'London' a  
x:Place } - whereas I'd immediately counter with { x:London a  
'Place' }.


Surely all of the subjects as literals arguments can be countered  
with 'walk round it', and further good practise could be aided by  
a few simple notes on best practise for linked data etc.


I wholly agree. Allowing literals in subject position in RDF is a  
no-brainer. (BTW, it would also immediately solve the 'bugs in the  
RDF rules' problem.) These arguments against it are nonsensical.  
The REAL argument against it is that it will mess up OWL-DL, or at  
any rate it *might* mess up OWL-DL.


The Description Logic police are still in charge:-)


I agree that literals can be subjects. In any case they are, because  
you just can take an inverse function from a thing to a string, and  
you have it.


But I do think

  'London' a x:Place

is bad design because really 'London' is a string and not a place.


Absolutely. That triple plus a reasonably sensible ontology of places  
plus a basic RDFS reasoner should flag a contradiction fairly directly.


Pat



Now of course x:Place my be the collection of names of places in  
english, in which case it is ok. So it is difficult to say just like  
that. There would have to be quite a lot of education in the when is  
it right to use strings as subjects space.


Henry





Pat






IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

On Thu, Jul 1, 2010 at 5:45 PM, Henry Story  wrote:
>
> On 1 Jul 2010, at 18:18, Yves Raimond wrote:
>
>>>
>>> In any case RDF Semantics does, I believe,
>>> allow literals in subject position. It is just that many many syntaxes
>>> don't allow that to be expressed,
>>
>>
>> It doesn't seem to be allowed in the RDF semantics:
>> http://www.w3.org/TR/rdf-concepts/#section-Literals
>>
>> "A literal may be the object of an RDF statement, but not the subject
>> or the predicate."
>
> Yes, but a bnode or a URI can refer to a literal. So if those can refer to a 
> literal,
> then instead of writing
>
> [1] _:n1 owl:sameAs "hello";
>     numLetters 5 .
>
> Why not also allow one to write
>
> [2] "hello" numLetters 5.
>
> ?
>
> That is what I meant.
>
> In any case one can always map [2] to [1], so I am not sure
> the costs of allowing [2] need be that high. Every current implementation
> could just parse [2] and write it out as [1].
>
> No?
>
> It just seems that [2] is a more concise way of writing things, and
> it is conceptually cleaner.

I definitely agree...

For my thesis work, I had to store quite a lot of signal processing
computations in RDF, and had to hack a few triple stores (mainly SWI's
one) to handle literals as subjects. I used a similar hack to do that,
it was very easy to implement...

y

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Henry Story]

On 1 Jul 2010, at 18:18, Yves Raimond wrote:

>> 
>> In any case RDF Semantics does, I believe,
>> allow literals in subject position. It is just that many many syntaxes
>> don't allow that to be expressed,
> 
> 
> It doesn't seem to be allowed in the RDF semantics:
> http://www.w3.org/TR/rdf-concepts/#section-Literals
> 
> "A literal may be the object of an RDF statement, but not the subject
> or the predicate."

Yes, but a bnode or a URI can refer to a literal. So if those can refer to a 
literal,
then instead of writing

[1] _:n1 owl:sameAs "hello";
 numLetters 5 .

Why not also allow one to write

[2] "hello" numLetters 5.

?

That is what I meant. 

In any case one can always map [2] to [1], so I am not sure
the costs of allowing [2] need be that high. Every current implementation
could just parse [2] and write it out as [1].

No?

It just seems that [2] is a more concise way of writing things, and
it is conceptually cleaner. 


Henry

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Yves Raimond wrote:

Hello!

  

IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" have
Identifiers in the form of Name References (which may or many resolve to
Structured Representations of Referents carried or borne by Descriptor
Docs/Resources). An "Identifier" != Literal.

If you are in a situation where you can't or don't want to mint an HTTP
based Name, simply use a URN, it does the job.



It does look like you're already using literal subjects in OpenLink
Virtuoso though:

http://docs.openlinksw.com/virtuoso/rdfsparql.html

SQL>SELECT *
FROM 
WHERE
 {
   ?s foaf:Name ?name . ?name bif:contains "'rich*'".
 }

Best,
y


  

Were is the Literal Subject in the query above?



?name is a literal. And it is used as a subject.
  


Yves,

Here's why its deemed magic/function/unreal predicate (a function 
selectively working on literal data associated with the URI):


1. http://bit.ly/cQJTWQ -- SPARQL Query Results Page
2. http://bit.ly/acQc4u -- Actual SPARQL Query

There isn't an actual Literal Subject in the Virtuoso RDF DBMS. The 
RDF_QUAD Table  explicitly has Column "S" set to type IRI.


Here is the actual SQL DML for RDF_QUAD:

create table "DB"."DBA"."RDF_QUAD"
(
 "P" IRI_ID,
 "S" IRI_ID,
 "O" ANY,
 "G" IRI_ID,
 PRIMARY KEY ("P", "S", "O", "G")
);


Kingsley



Best,
y

  

bif:contains is a function/magic predicate scoped to Literal Objects.

 != "people".

What am I missing?

--

Regards,

Kingsley Idehen   President & CEO OpenLink Software Web:
http://www.openlinksw.com
Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen








  



--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

On Thu, Jul 1, 2010 at 5:22 PM, Kingsley Idehen  wrote:
> Henry Story wrote:
>>
>> On 1 Jul 2010, at 16:35, Kingsley Idehen wrote:
>>
>>
>>>
>>> Yves Raimond wrote:
>>>

 Hello Kingsley!


 [snip]


>
> IMHO an emphatic NO.
>
> RDF is about constructing structured descriptions where "Subjects" have
> Identifiers in the form of Name References (which may or many resolve
> to
> Structured Representations of Referents carried or borne by Descriptor
> Docs/Resources). An "Identifier" != Literal.
>
> If you are in a situation where you can't or don't want to mint an HTTP
> based Name, simply use a URN, it does the job.
>

 It does look like you're already using literal subjects in OpenLink
 Virtuoso though:

 http://docs.openlinksw.com/virtuoso/rdfsparql.html

 SQL>SELECT *
 FROM 
 WHERE
  {
   ?s foaf:Name ?name . ?name bif:contains "'rich*'".
  }

 Best,
 y


>>>
>>> Were is the Literal Subject in the query above?
>>>
>>> bif:contains is a function/magic predicate scoped to Literal Objects.
>>>
>>>  != "people".
>>>
>>> What am I missing?
>>>
>>
>> Why do you think it is magic? Such a relation makes complete sense.
>>
>
> It's a virtuoso function surfaced as a predicate.
> "magic predicate" was an initial moniker used at creation time.
> "bif:contains" doesn't exist in pure triple form etc..

Why couldn't it? For example, you may want to express exactly what
triple lead you to give a particular result, and within that scope you
may end up having to write: "Brickley" bif:contains "ckley" in RDF.

Forbidding literals as subjects makes this statement impossible to
express, however that's a very sensible thing you may want to express.

There are also lots of literal search examples that comes to mind:

"Acton" str:double_metaphone "AKTN" .
"Smith" str:soundex "S530" .
...

Best,
y

>
>> Given that is is a relation between literals it can be tested without
>> needing
>> to look at the world. Just like an math:isgreaterThan relation ...
>>
>> In fact I wonder how much SPARQL could be simplified by thinking of things
>> this
>> way. Could one perhaps get rid of the FILTER( ) clause?
>>
>> In any case RDF Semantics does, I believe, allow literals in subject
>> position. It is just that many many syntaxes
>> don't allow that to be expressed,
>>
>> But there is nothing you can do to stop that happening semantically.  A
>> URI or bnode
>> can just be names for strings.
>>
>> And as for it requiring a change to the infrastructure of your DB, it is
>> not clear that
>> it immediately does, since you can alwasy rewrite
>>
>>
>> "father" containsLetters 6 .
>>
>> as
>> [] owl:sameAs "father";
>>   containsLetters 6 .
>>
>
> DBMS wise, indexing is an issue which ultimately leads to data access
> performance problems etc.. Steve already covered that ditto Ivan in earlier
> comments, I believe.
>
> In Virtuoso an IRI is a native type with implications as per comment above.
>
>
> Kingsley
>>
>> Henry
>>
>>
>>
>>
>>>
>>> --
>>>
>>> Regards,
>>>
>>> Kingsley Idehen       President & CEO OpenLink Software     Web:
>>> http://www.openlinksw.com
>>> Weblog: http://www.openlinksw.com/blog/~kidehen
>>> Twitter/Identi.ca: kidehen
>>>
>>>
>>>
>>>
>>>
>>
>>
>>
>
>
> --
>
> Regards,
>
> Kingsley Idehen       President & CEO OpenLink Software     Web:
> http://www.openlinksw.com
> Weblog: http://www.openlinksw.com/blog/~kidehen
> Twitter/Identi.ca: kidehen
>
>
>
>
>

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Henry Story wrote:

On 1 Jul 2010, at 16:35, Kingsley Idehen wrote:

  

Yves Raimond wrote:


Hello Kingsley!


[snip]

 
  

IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" have
Identifiers in the form of Name References (which may or many resolve to
Structured Representations of Referents carried or borne by Descriptor
Docs/Resources). An "Identifier" != Literal.

If you are in a situation where you can't or don't want to mint an HTTP
based Name, simply use a URN, it does the job.
   


It does look like you're already using literal subjects in OpenLink
Virtuoso though:

http://docs.openlinksw.com/virtuoso/rdfsparql.html

SQL>SELECT *
FROM 
WHERE
 {
   ?s foaf:Name ?name . ?name bif:contains "'rich*'".
 }

Best,
y

 
  

Were is the Literal Subject in the query above?

bif:contains is a function/magic predicate scoped to Literal Objects.

 != "people".

What am I missing?



Why do you think it is magic? Such a relation makes complete sense.
  

It's a virtuoso function surfaced as a predicate.
"magic predicate" was an initial moniker used at creation time. 
"bif:contains" doesn't exist in pure triple form etc..



Given that is is a relation between literals it can be tested without needing
to look at the world. Just like an math:isgreaterThan relation ...

In fact I wonder how much SPARQL could be simplified by thinking of things this
way. Could one perhaps get rid of the FILTER( ) clause?

In any case RDF Semantics does, I believe, 
allow literals in subject position. It is just that many many syntaxes

don't allow that to be expressed,

But there is nothing you can do to stop that happening semantically.  A URI or 
bnode
can just be names for strings.

And as for it requiring a change to the infrastructure of your DB, it is not 
clear that
it immediately does, since you can alwasy rewrite


"father" containsLetters 6 .

as 


[] owl:sameAs "father";
   containsLetters 6 .
  


DBMS wise, indexing is an issue which ultimately leads to data access 
performance problems etc.. Steve already covered that ditto Ivan in 
earlier comments, I believe.


In Virtuoso an IRI is a native type with implications as per comment above.


Kingsley

Henry



  

--

Regards,

Kingsley Idehen   President & CEO OpenLink Software Web: 
http://www.openlinksw.com
Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 










  



--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

On Thu, Jul 1, 2010 at 3:46 PM, Henry Story  wrote:
>
> On 1 Jul 2010, at 16:35, Kingsley Idehen wrote:
>
>> Yves Raimond wrote:
>>> Hello Kingsley!
>>>
>>>
>>> [snip]
>>>
>>>
 IMHO an emphatic NO.

 RDF is about constructing structured descriptions where "Subjects" have
 Identifiers in the form of Name References (which may or many resolve to
 Structured Representations of Referents carried or borne by Descriptor
 Docs/Resources). An "Identifier" != Literal.

 If you are in a situation where you can't or don't want to mint an HTTP
 based Name, simply use a URN, it does the job.

>>>
>>> It does look like you're already using literal subjects in OpenLink
>>> Virtuoso though:
>>>
>>> http://docs.openlinksw.com/virtuoso/rdfsparql.html
>>>
>>> SQL>SELECT *
>>> FROM 
>>> WHERE
>>>  {
>>>    ?s foaf:Name ?name . ?name bif:contains "'rich*'".
>>>  }
>>>
>>> Best,
>>> y
>>>
>>>
>>
>> Were is the Literal Subject in the query above?
>>
>> bif:contains is a function/magic predicate scoped to Literal Objects.
>>
>>  != "people".
>>
>> What am I missing?
>
> Why do you think it is magic? Such a relation makes complete sense.
> Given that is is a relation between literals it can be tested without needing
> to look at the world. Just like an math:isgreaterThan relation ...
>
> In fact I wonder how much SPARQL could be simplified by thinking of things 
> this
> way. Could one perhaps get rid of the FILTER( ) clause?

+1

Almost all FILTER functions I know of could be done using predicates
in the where clause (it would even look a bit more like SQL :) ).

>
> In any case RDF Semantics does, I believe,
> allow literals in subject position. It is just that many many syntaxes
> don't allow that to be expressed,


It doesn't seem to be allowed in the RDF semantics:
http://www.w3.org/TR/rdf-concepts/#section-Literals

"A literal may be the object of an RDF statement, but not the subject
or the predicate."

>
> But there is nothing you can do to stop that happening semantically.  A URI 
> or bnode
> can just be names for strings.
>
> And as for it requiring a change to the infrastructure of your DB, it is not 
> clear that
> it immediately does, since you can alwasy rewrite
>
>
> "father" containsLetters 6 .
>
> as
>
> [] owl:sameAs "father";
>   containsLetters 6 .
>
> Henry
>
>
>
>> --
>>
>> Regards,
>>
>> Kingsley Idehen             President & CEO OpenLink Software     Web: 
>> http://www.openlinksw.com
>> Weblog: http://www.openlinksw.com/blog/~kidehen
>> Twitter/Identi.ca: kidehen
>>
>>
>>
>>
>>
>
>

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

Hello!

>>
>>>
>>> IMHO an emphatic NO.
>>>
>>> RDF is about constructing structured descriptions where "Subjects" have
>>> Identifiers in the form of Name References (which may or many resolve to
>>> Structured Representations of Referents carried or borne by Descriptor
>>> Docs/Resources). An "Identifier" != Literal.
>>>
>>> If you are in a situation where you can't or don't want to mint an HTTP
>>> based Name, simply use a URN, it does the job.
>>>
>>
>> It does look like you're already using literal subjects in OpenLink
>> Virtuoso though:
>>
>> http://docs.openlinksw.com/virtuoso/rdfsparql.html
>>
>> SQL>SELECT *
>> FROM 
>> WHERE
>>  {
>>    ?s foaf:Name ?name . ?name bif:contains "'rich*'".
>>  }
>>
>> Best,
>> y
>>
>>
>
> Were is the Literal Subject in the query above?

?name is a literal. And it is used as a subject.

Best,
y

>
> bif:contains is a function/magic predicate scoped to Literal Objects.
>
>  != "people".
>
> What am I missing?
>
> --
>
> Regards,
>
> Kingsley Idehen       President & CEO OpenLink Software     Web:
> http://www.openlinksw.com
> Weblog: http://www.openlinksw.com/blog/~kidehen
> Twitter/Identi.ca: kidehen
>
>
>
>
>

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Henry Story]

On 1 Jul 2010, at 16:35, Kingsley Idehen wrote:

> Yves Raimond wrote:
>> Hello Kingsley!
>> 
>> 
>> [snip]
>> 
>>  
>>> IMHO an emphatic NO.
>>> 
>>> RDF is about constructing structured descriptions where "Subjects" have
>>> Identifiers in the form of Name References (which may or many resolve to
>>> Structured Representations of Referents carried or borne by Descriptor
>>> Docs/Resources). An "Identifier" != Literal.
>>> 
>>> If you are in a situation where you can't or don't want to mint an HTTP
>>> based Name, simply use a URN, it does the job.
>>>
>> 
>> It does look like you're already using literal subjects in OpenLink
>> Virtuoso though:
>> 
>> http://docs.openlinksw.com/virtuoso/rdfsparql.html
>> 
>> SQL>SELECT *
>> FROM 
>> WHERE
>>  {
>>?s foaf:Name ?name . ?name bif:contains "'rich*'".
>>  }
>> 
>> Best,
>> y
>> 
>>  
> 
> Were is the Literal Subject in the query above?
> 
> bif:contains is a function/magic predicate scoped to Literal Objects.
> 
>  != "people".
> 
> What am I missing?

Why do you think it is magic? Such a relation makes complete sense.
Given that is is a relation between literals it can be tested without needing
to look at the world. Just like an math:isgreaterThan relation ...

In fact I wonder how much SPARQL could be simplified by thinking of things this
way. Could one perhaps get rid of the FILTER( ) clause?

In any case RDF Semantics does, I believe, 
allow literals in subject position. It is just that many many syntaxes
don't allow that to be expressed,

But there is nothing you can do to stop that happening semantically.  A URI or 
bnode
can just be names for strings.

And as for it requiring a change to the infrastructure of your DB, it is not 
clear that
it immediately does, since you can alwasy rewrite


"father" containsLetters 6 .

as 

[] owl:sameAs "father";
   containsLetters 6 .

Henry



> -- 
> 
> Regards,
> 
> Kingsley Idehen President & CEO OpenLink Software Web: 
> http://www.openlinksw.com
> Weblog: http://www.openlinksw.com/blog/~kidehen
> Twitter/Identi.ca: kidehen 
> 
> 
> 
> 
> 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Pat Hayes wrote:


On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or however 
it is

called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

  # An rdf:List that loops around...

  <#mylist> a rdf:List ;
  rdf:first <#Alice> ;
  rdf:next <#mylist> .

  # A looping, branching mess...

  <#anotherlist> a rdf:List ;
  rdf:first <#anotherlist> ;
  rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just 
about impossible to guarantee that messes can't happen when all 
you are doing is describing structures in an open-world setting. 
But I think the cure is to stop thinking that possible-messes are 
a problem to be solved. So, there is dung in the road. Walk round 
it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 
'linked data' practise by using examples like { 'London' a x:Place 
} - whereas I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered 
with 'walk round it', and further good practise could be aided by 
a few simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" 
have Identifiers in the form of Name References (which may or many 
resolve to Structured Representations of Referents carried or borne 
by Descriptor Docs/Resources). An "Identifier" != Literal.


What ARE you talking about? You sound like someone reciting doctrine.

Literals in RDF are just as much 'identifiers' or 'names' as URIs 
are. They identify their value, most clearly and emphatically. They 
denote in exactly the same way that URIs denote. "23"^^xsd:number   
is about as good an identification of the number twenty-three as you 
are ever likely to get in any notational system since ancient 
Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked 
Data, slightly different mediums with some shared characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes). Thus, 
unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed 
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local RDF 
data). My gripe simply boils down to the nuisance factor introduced 
by data object name ambiguity in a distributed data object oriented 
realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space?


It means the number twenty-three, everywhere and for all time, because 
this meaning can be computed from the very syntactic form of the name. 
How unambiguous can something get?


Pat,

Re. RDF's triples, What is a Subject? What is an Object?.

If they are the same thing, why on earth do we use Names (with 
implications) to describe the slots in an RDF triple?


I've only once seen the RDF triple referred to as O-R-O (by @danbri) 
i.e., Object-Relation-Object.


In addition, I don't see Information and Data as being the same thing. 
Information (as I know it) is about Data + Context.  Raw Data (as I know 
it) is about: a unit of observation and deemed worthy of description by 
its observer.  You have to give Names to subject of a description. 
"23"^^xsd:number  isn't a Name.


**
I guess my own subtle mistake (re. this thread) is deeming Identifiers 
and Names to be equivalent , when they aren't :-) Of course, one can use 
an Identifier as a Name, but that doesn't make them equivalent.

**


One clear point of divergence here is that I am focused on the Web as 
Dist. DBMS that leverages 3-tuples + HTTP URIs in the S, P, and 
optionally O slot (aka. HTTP based Linked Data).


To conclude:

Name != Identifier.

I believe Subject == Name (an Identifier based Name) re. RDF triples 
otherwise the triple should be described as: O-R-O or O-P-O.


I believe an S-P-O triple is a piece of information (Data Object has a 
Name and at least one Attribute=Value pair).


What I desscribe actually has zilch to do with RDF as I am inclined to 
believe you see RDF :-) Thus, in a way, the literal-subject debate may 
simply help everyone understand and accept that RDF != Linked Data. 
Thus, providing additional proof that RDF isn't mandatory or even 
required re. delivery of  HTTP based Linked Data.


RDF based Linked Data != RDF. They are different things, clearly.  We 
can't have it both ways (** Pat: not for you, that's for those that deem 
RDF and Li

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Yves Raimond wrote:

Hello Kingsley!


[snip]

  

IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" have
Identifiers in the form of Name References (which may or many resolve to
Structured Representations of Referents carried or borne by Descriptor
Docs/Resources). An "Identifier" != Literal.

If you are in a situation where you can't or don't want to mint an HTTP
based Name, simply use a URN, it does the job.



It does look like you're already using literal subjects in OpenLink
Virtuoso though:

http://docs.openlinksw.com/virtuoso/rdfsparql.html

SQL>SELECT *
FROM 
WHERE
  {
?s foaf:Name ?name . ?name bif:contains "'rich*'".
  }

Best,
y

  


Were is the Literal Subject in the query above?

bif:contains is a function/magic predicate scoped to Literal Objects.

 != "people".

What am I missing?

--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

Hello!

On Thu, Jul 1, 2010 at 3:41 AM, Pat Hayes  wrote:
>
> On Jun 30, 2010, at 4:25 PM, Toby Inkster wrote:
>
>> On Wed, 30 Jun 2010 13:18:25 -0700
>> Jeremy Carroll  wrote:
>>
>>> Here are the reasons I voted this way:
>>>
>>> - it will mess up RDF/XML
>>
>> No it won't - it will just mean that RDF/XML is only capable of
>> representing a subset of RDF graphs. And guess what? That's already
>> the case.
>>
>
> EXACTLY.

I whole-heartedly agree with Pat and Toby, here... This is a small
fix, and would get rid of one of the most obviously broken thing in
the current RDF spec.

We had a fairly heated discussion about that on IRC, last Tuesday,
which might be worth pointing to as it exposes arguments from both
sides of the fence:
http://chatlogs.planetrdf.com/swig/2010-06-29.html#T11-41-34

Best,
y

>
> Pat
>
>
>> --
>> Toby A Inkster
>> 
>> 
>>
>>
>>
>
> 
> IHMC                                     (850)434 8903 or (650)494 3973
> 40 South Alcaniz St.           (850)202 4416   office
> Pensacola                            (850)202 4440   fax
> FL 32502                              (850)291 0667   mobile
> phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes
>
>
>
>
>
>
>

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Ivan Mikhailov]

Hello,

Please, don't extend the existing model, for two reasons.

>From implementor's POV, arbitrary literals are bad for any sort of
indexing. 

>From AI specialist's POV, literals are simply not subjects.
Can a number or a string _act_? Can you provide a living specimen of it?
The feature is useless in modelling of the real world. so let it stay
jailed in object position. If RDF could be extended, there are many
better things to add, e.g., physical units.

Finally, I don't want to get rounding errors on graphs like I can get
them in CAD system. Should subject 3.14151956 and subject
3.141519559 connect their triples, can you guess? In any CAD I have
a tolerance level to treat two points as "equal enough" and "their"
geometric shapes connected; I'd prefer to never chose a tolerance level
for a graph of heterogeneous or simply unknown nature.

Best Regards,

Ivan Mikhailov
OpenLink Software
http://virtuoso.openlinksw.com

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Yves Raimond]

Hello Kingsley!


[snip]

>
> IMHO an emphatic NO.
>
> RDF is about constructing structured descriptions where "Subjects" have
> Identifiers in the form of Name References (which may or many resolve to
> Structured Representations of Referents carried or borne by Descriptor
> Docs/Resources). An "Identifier" != Literal.
>
> If you are in a situation where you can't or don't want to mint an HTTP
> based Name, simply use a URN, it does the job.

It does look like you're already using literal subjects in OpenLink
Virtuoso though:

http://docs.openlinksw.com/virtuoso/rdfsparql.html

SQL>SELECT *
FROM 
WHERE
  {
?s foaf:Name ?name . ?name bif:contains "'rich*'".
  }

Best,
y

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Michael Schneider]

Nathan wrote:

>re OWL DL, does it have to consider every triple in a 'graph'?

No, and it cannot do so in general. Strictly speaking, OWL DL doesn't even
have a notion of RDF triples or RDF graphs. OWL DL "thinks" in terms of
constructs such as axioms and class expressions. The genuine "abstract"
syntax of OWL (2) DL, defined in [1], deals with such constructs, not with
RDF triples. OWL DL rather uses RDF as a serialization syntax, via the RDF
mapping defined in [2]. 

Basically, for each of the constructs in the abstract OWL DL syntax there is
a set of RDF triples encoding this construct. Sets of RDF triples that do
not match the serialization of any of the OWL DL constructs (or of sets of
them) are simply not syntactically valid and have no semantic meaning in OWL
DL. In fact, the whole RDF graph will be regarded as an invalid OWL DL
ontology if such sets of triples exist.

As an example, consider the RDF serialization of the OWL DL construct for
universal property restrictions:

   _:x rdf:type owl:Restriction .
   _:x owl:onProperty ex:p .
   _:x owl:allValuesFrom ex:c .

When this RDF serialization is used as the input to an OWL DL system, the
system will try to map it into the corresponding "abstract" OWL DL syntax
construct. This is only a one-or-nothing mapping, i.e. a single RDF triple
from the triple set above has no meaning for OWL DL. For instance, if the
OWL DL system only finds the triple

_:x owl:allValuesFrom a:Dog .

and not the other two triples, then the RDF encoding of the universal
property restriction is simply broken, and you will probably receive an
error. It is /not/ the case, as one might think, that this single triple is
still sort of a property assertion with the property owl:allValuesFrom. 

Note that you have a triple-focused view in RDF(S) and OWL Full, where the
single triple is regarded as an axiom on its own. But, as stated, OWL DL
requires that the set of all RDF triples is the encoding of some set of OWL
DL constructs, otherwise the RDF is just something that is not well-defined.


Michael

[1] 
[2] 

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Geoff Chappell]

-Original Message-
From: semantic-web-requ...@w3.org [mailto:semantic-web-requ...@w3.org] On
Behalf Of Pat Hayes
Sent: Thursday, July 01, 2010 12:47 AM
To: Axel Rauschmayer
Cc: David Booth; nat...@webr3.org; Toby Inkster; Dan Brickley; Linked Data
community; Semantic Web
Subject: Re: Subjects as Literals, [was Re: The Ordered List Ontology]


On Jun 30, 2010, at 3:12 PM, Axel Rauschmayer wrote:

>> Intuitively, I would expect each subject literal to have a unique  
>> identity. For example, I would want to annotate a particular  
>> instance of "abc" and not all literals "abc". Wouldn't the latter  
>> treatment make literals-as-subjects less appealing?
>
>Hmm. Im not sure what this means. Each literal has its own identity,  
>in a sense, but what the literal refers to is the same in each case:  
>every occurrence of "23"^^xsd:number must refer to twenty-three. And  
>since this (the number, not the literal) is what the literal refers  
>to, and so what the RDF which uses the literal is talking about, why  
>does it matter which literal you use to refer to it with?
>
>Maybe what you really need to do is to reify the literal and then talk  
>about that. Then your notion of this literal vs. that literal does  
>make sense, but it bears on the semantics of reification in RDF (or  
>whatever finally takes its place in some future incarnation.)

Just wondering if there is an assumption in the can-subjects-be-literals
debate that the tidy vs. untidy literal question will be revisited? I guess
it's far less of an issue with datatyped literals, but plain literals as
subjects seem to be at best not that useful and at worst encourage usage
that would just be wrong - e.g:

"Obama" ex:presidentOf ex:USA

where the plain literal "Obama" is used to refer to the person, rather than
the string of characters that it actually refers to. To "fix" rdf to allow
that would seem to be a far greater change than just allowing literals as
subjects.

-Geoff

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Michael Schneider]

Henry Story wrote:

> On 30 Jun 2010, at 21:09, Pat Hayes wrote:
>> The Description Logic police are still in charge:-)
>
>I agree that literals can be subjects. In any case they are, because you
>just can take an inverse function from a thing to a string, and you have
>it.

I guess, the Description Logic police will be very alerted, if you start
creating inverses of properties that allow strings in object position. :-)

(That's only supported by OWL Full.)

Michael

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Henry Story]

On 30 Jun 2010, at 21:09, Pat Hayes wrote:

>> 
>> For example I've heard people saying that it encourages bad 'linked data' 
>> practise by using examples like { 'London' a x:Place } - whereas I'd 
>> immediately counter with { x:London a 'Place' }.
>> 
>> Surely all of the subjects as literals arguments can be countered with 'walk 
>> round it', and further good practise could be aided by a few simple notes on 
>> best practise for linked data etc.
> 
> I wholly agree. Allowing literals in subject position in RDF is a no-brainer. 
> (BTW, it would also immediately solve the 'bugs in the RDF rules' problem.) 
> These arguments against it are nonsensical. The REAL argument against it is 
> that it will mess up OWL-DL, or at any rate it *might* mess up OWL-DL.
> 
> The Description Logic police are still in charge:-)

I agree that literals can be subjects. In any case they are, because you just 
can take an inverse function from a thing to a string, and you have it.

But I do think 

   'London' a x:Place

is bad design because really 'London' is a string and not a place.

Now of course x:Place my be the collection of names of places in english, in 
which case it is ok. So it is difficult to say just like that. There would have 
to be quite a lot of education in the when is it right to use strings as 
subjects space.

Henry



> 
> Pat

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jun 30, 2010, at 3:12 PM, Axel Rauschmayer wrote:

Intuitively, I would expect each subject literal to have a unique  
identity. For example, I would want to annotate a particular  
instance of "abc" and not all literals "abc". Wouldn't the latter  
treatment make literals-as-subjects less appealing?


Hmm. Im not sure what this means. Each literal has its own identity,  
in a sense, but what the literal refers to is the same in each case:  
every occurrence of "23"^^xsd:number must refer to twenty-three. And  
since this (the number, not the literal) is what the literal refers  
to, and so what the RDF which uses the literal is talking about, why  
does it matter which literal you use to refer to it with?


Maybe what you really need to do is to reify the literal and then talk  
about that. Then your notion of this literal vs. that literal does  
make sense, but it bears on the semantics of reification in RDF (or  
whatever finally takes its place in some future incarnation.)


Re. the DL police: I use RDF like a next-generation relational  
database and think that RDF could be sold to many people this way  
(there is possibly are larger audience for this than for ontologies,  
reasoning, etc.). Especially considering how No-SQL is currently  
taking off. This part needs some love and seems to suffer from the  
almost exclusive focus on semantics.


Fair enough. I guess Im not sure how this next-generation-RDB usage  
fits with the RDF semantics, but I'd be interested in pursuing this  
further. Does this RDF/RDB++ vision provide any guidance towards what  
RDF is supposed to, like, mean? Pointers?


Pat Hayes



Axel

On Jun 30, 2010, at 21:52 , David Booth wrote:


On Wed, 2010-06-30 at 14:09 -0500, Pat Hayes wrote:

On Jun 30, 2010, at 11:50 AM, Nathan wrote:

[ . . . ]

Surely all of the subjects as literals arguments can be countered
with 'walk round it', and further good practise could be aided by a
few simple notes on best practise for linked data etc.


I wholly agree. Allowing literals in subject position in RDF is a  
no-

brainer.


I agree, but at the W3C RDF Next Steps workshop over the weekend, I  
was
surprised to find that there was substantial sentiment *against*  
having

literals as subjects.  A straw poll showed that of those at the
workshop, this is how people felt about having an RDF working group
charter include literals as subjects:
http://www.w3.org/2010/06/28-rdfn-minutes.html

Charter MUST include:  0
Charter SHOULD include:1
Charter MAY include:   6
Charter MUST NOT include: 12

Readers, please note that this was a non-binding, informative STRAW  
POLL

ONLY -- not a vote.

Pat, I wish you had been there.  ;)

David


(BTW, it would also immediately solve the 'bugs in the RDF
rules' problem.) These arguments against it are nonsensical. The  
REAL
argument against it is that it will mess up OWL-DL, or at any rate  
it

*might* mess up OWL-DL.

The Description Logic police are still in charge:-)

Pat





Best,

Nathan





IHMC (850)434 8903 or (650)494  
3973

40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes











--
David Booth, Ph.D.
Cleveland Clinic (contractor)
http://dbooth.org/

Opinions expressed herein are those of the author and do not  
necessarily

reflect those of Cleveland Clinic.





--
Dr. Axel Rauschmayer
axel.rauschma...@ifi.lmu.de
http://hypergraphs.de/
:: Hyena: connected information manager, free at hypergraphs.de/ 
hyena/ ::







IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jun 30, 2010, at 4:25 PM, Toby Inkster wrote:


On Wed, 30 Jun 2010 13:18:25 -0700
Jeremy Carroll  wrote:


Here are the reasons I voted this way:

- it will mess up RDF/XML


No it won't - it will just mean that RDF/XML is only capable of
representing a subset of RDF graphs. And guess what? That's already
the case.



EXACTLY.

Pat



--
Toby A Inkster








IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jun 30, 2010, at 3:49 PM, Kingsley Idehen wrote:


Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or however  
it is
called) claims could probably make a mess, if added or  
removed...


You can create some pretty awesome messes even without OWL:

  # An rdf:List that loops around...

  <#mylist> a rdf:List ;
  rdf:first <#Alice> ;
  rdf:next <#mylist> .

  # A looping, branching mess...

  <#anotherlist> a rdf:List ;
  rdf:first <#anotherlist> ;
  rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using  
pointers, which is what the RDF vocabulary describes.  Its just  
about impossible to guarantee that messes can't happen when all  
you are doing is describing structures in an open-world setting.  
But I think the cure is to stop thinking that possible-messes  
are a problem to be solved. So, there is dung in the road. Walk  
round it.




Could we also apply that to the 'subjects as literals' general  
discussion that's going on then?


For example I've heard people saying that it encourages bad  
'linked data' practise by using examples like { 'London' a  
x:Place } - whereas I'd immediately counter with { x:London a  
'Place' }.


Surely all of the subjects as literals arguments can be countered  
with 'walk round it', and further good practise could be aided by  
a few simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects"  
have Identifiers in the form of Name References (which may or many  
resolve to Structured Representations of Referents carried or  
borne by Descriptor Docs/Resources). An "Identifier" != Literal.


What ARE you talking about? You sound like someone reciting doctrine.

Literals in RDF are just as much 'identifiers' or 'names' as URIs  
are. They identify their value, most clearly and emphatically. They  
denote in exactly the same way that URIs denote. "23"^^xsd:number
is about as good an identification of the number twenty-three as  
you are ever likely to get in any notational system since ancient  
Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked  
Data, slightly different mediums with some shared characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes).  
Thus, unambiguous naming matters.


A topic for a longer discussion; but irrelevant here, since typed  
literals are as unambiguous as a name can possibly get.




Literal Subjects aren't a "show stopper" per se. (esp. for local RDF  
data). My gripe simply boils down to the nuisance factor introduced  
by data object name ambiguity in a distributed data object oriented  
realm such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space?


It means the number twenty-three, everywhere and for all time, because  
this meaning can be computed from the very syntactic form of the name.  
How unambiguous can something get?


Pat


I know the meaning of: , based on the resource I deref at: 




Kingsley




Pat Hayes



If you are in a situation where you can't or don't want to mint an  
HTTP based Name, simply use a URN, it does the job.





Best,

Nathan





--

Regards,

Kingsley Idehen  President & CEO OpenLink Software  
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen









IHMC (850)434 8903 or (650)494  
3973

40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes









--

Regards,

Kingsley Idehen   President & CEO OpenLink Software Web: 
http://www.openlinksw.com
Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen









IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jun 30, 2010, at 2:52 PM, David Booth wrote:


On Wed, 2010-06-30 at 14:09 -0500, Pat Hayes wrote:

On Jun 30, 2010, at 11:50 AM, Nathan wrote:

[ . . . ]

Surely all of the subjects as literals arguments can be countered
with 'walk round it', and further good practise could be aided by a
few simple notes on best practise for linked data etc.


I wholly agree. Allowing literals in subject position in RDF is a no-
brainer.


I agree, but at the W3C RDF Next Steps workshop over the weekend, I  
was
surprised to find that there was substantial sentiment *against*  
having

literals as subjects.  A straw poll showed that of those at the
workshop, this is how people felt about having an RDF working group
charter include literals as subjects:
http://www.w3.org/2010/06/28-rdfn-minutes.html

 Charter MUST include:  0
 Charter SHOULD include:1
 Charter MAY include:   6
 Charter MUST NOT include: 12

Readers, please note that this was a non-binding, informative STRAW  
POLL

ONLY -- not a vote.

Pat, I wish you had been there.  ;)


I have very mixed views on this, I have to say. Part of me wanted  
badly to be present. But after reading the results of the straw poll,  
part of me wants to completely forget about RDF,  never think about an  
ontology or a logic ever again, and go off and do something completely  
different, like art or philosophy.


Pat




David


(BTW, it would also immediately solve the 'bugs in the RDF
rules' problem.) These arguments against it are nonsensical. The REAL
argument against it is that it will mess up OWL-DL, or at any rate it
*might* mess up OWL-DL.

The Description Logic police are still in charge:-)

Pat





Best,

Nathan





IHMC (850)434 8903 or (650)494  
3973

40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes











--
David Booth, Ph.D.
Cleveland Clinic (contractor)
http://dbooth.org/

Opinions expressed herein are those of the author and do not  
necessarily

reflect those of Cleveland Clinic.






IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

RE: Subjects as Literals, [was Re: The Ordered List Ontology]

[Michael Schneider]

Jirí Procházka wrote:

>I wonder, when using owl:sameAs or related, to "name" literals to be
>able to say other useful thing about them in normal triples (datatype,
>language, etc) does it break OWL DL

Literals in owl:sameAs axioms are not allowed in OWL (1/2) DL. owl:sameAs
can only be used to equate individuals. An axiom of the form

ex:u owl:sameAs "foo" .

would, however, equate an individual with a data value. The semantics of OWL
DL states that individuals and data values are disjoint [1], so such a
statement would always lead to semantic inconsistency. But, in fact, the
syntax of OWL DL disallows stating such an axiom, anyway: only URIs are
allowed in sameness axioms [2].

>(or any other formalism 

OWL Full allows it, both syntactically and semantically.

>which is base of some ontology extending RDF semantics)? 

OWL Full is an extension of the RDF Semantics in the sense of [3]. This
explains why OWL Full can treat sameAs'ed literals semantically without
problems: under the semantics of RDFS all data values are individuals
("rdfs:Literal rdfs:subClassOf rdfs:Resource"). So there is no disjointness
between data values and individuals as in OWL DL. Also, as for RDFS, OWL
Full allows for arbitrary RDF as input, so sameAs'ed literals are also
syntactically allowed.

Or would it if
>rdf:sameAs was introduced?

Such a definition would probably not be different from what OWL Full already
provides, only at a different semantic layer. So I would consider it
redundant in RDF.
 
Michael

[1]
http://www.w3.org/TR/2009/REC-owl2-direct-semantics-20091027/#Interpretation
s
[2] http://www.w3.org/TR/2009/REC-owl2-syntax-20091027/#Individual_Equality
[3] http://www.w3.org/TR/rdf-mt/#DefSemanticExtension

--
Dipl.-Inform. Michael Schneider
Research Scientist, Information Process Engineering (IPE)
Tel  : +49-721-9654-726
Fax  : +49-721-9654-727
Email: michael.schnei...@fzi.de
WWW  : http://www.fzi.de/michael.schneider
===
FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959
Stiftung des bürgerlichen Rechts, Az 14-0563.1, RP Karlsruhe
Vorstand: Prof. Dr.-Ing. Rüdiger Dillmann, Dipl. Wi.-Ing. Michael Flor,
Prof. Dr. Dr. h.c. Wolffried Stucky, Prof. Dr. Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus
===

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Jeremy Carroll wrote:

Jiří Procházka wrote:


I wonder, when using owl:sameAs or related, to "name" literals to be
able to say other useful thing about them in normal triples (datatype,
language, etc) does it break OWL DL 

yes it does


(or any other formalism which is
base of some ontology extending RDF semantics)?


Not OWL full

 Or would it if
rdf:sameAs was introduced?
  


It would still break OWL DL

Best,
Jiri
  
OWL DL is orthogonal to this issue. The OWL DLers already prohibit 
certain RDF - specifically the workaround for not having literal as 
subjects. So they are neutral.
I reiterate that I agree whole-heartedly with the technical arguments 
for making this change; however the economic case is missing.


Are you referring to the cost of fixing RDF/XML or the cost of 
specifying RDF correctly and having RDF/XML as a subset of RDF?


IMHO the economic case (and ethical, technical) is extremely strong when 
you look at it on the ten year timeline - pinning all of RDF on the 
serialization specific features and limitations of RDF/XML really 
hinders progress (now and in the future).


There doesn't need to be any cost here, define RDF properly and separate 
from any serialization, define RDF/XML as a subset of it, and let us all 
get on and create new and wonderful serializations that will drive 
another decade of innovation.


I'm 100% sure that if tooling for N3 was more widely available and the 
web of data was N3 powered, we'd be much further down the line - the 
proof is already there with the work done at MIT-CSAIL and RPI, fact is 
you simply can't do everything needed for a web of data with RDF/XML.


Best,

Nathan

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Jeremy Carroll]

Jiří Procházka wrote:


I wonder, when using owl:sameAs or related, to "name" literals to be
able to say other useful thing about them in normal triples (datatype,
language, etc) does it break OWL DL 

yes it does


(or any other formalism which is
base of some ontology extending RDF semantics)?


Not OWL full

 Or would it if
rdf:sameAs was introduced?
  


It would still break OWL DL

Best,
Jiri
  
OWL DL is orthogonal to this issue. The OWL DLers already prohibit 
certain RDF - specifically the workaround for not having literal as 
subjects. So they are neutral.
I reiterate that I agree whole-heartedly with the technical arguments 
for making this change; however the economic case is missing.


Jeremy

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Toby Inkster wrote:

On Wed, 30 Jun 2010 13:18:25 -0700
Jeremy Carroll  wrote:


Here are the reasons I voted this way:

- it will mess up RDF/XML


No it won't - it will just mean that RDF/XML is only capable of
representing a subset of RDF graphs. And guess what? That's already
the case.



Yes! +100

we all keep saying RDF isn't RDF/XML don't we..?

Perhaps, RDF is really N3, with N3 Rules etc which expand it, and then 
different serializations support subsets of that - the RDF/XML spec 
already appears to be only a spec for RDF/XML not RDF (broadly speaking) 
maybe it just needs that said in a normative way so we can get on and 
build what we all really need, define a core RDF non serialization 
specific Rec/Spec then go from there - nobody says each serialization 
*must* handle all of RDF, but perhaps levels of conformance could be 
added to each serialization spec

- has graph literals/formulae/nested graphs Y/N
- has literal subjects y/n
- supports rules y/n
etc

Best,

Nathan

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Toby Inkster]

On Wed, 30 Jun 2010 13:18:25 -0700
Jeremy Carroll  wrote:

> Here are the reasons I voted this way:
> 
> - it will mess up RDF/XML

No it won't - it will just mean that RDF/XML is only capable of
representing a subset of RDF graphs. And guess what? That's already
the case.

-- 
Toby A Inkster

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Pat Hayes wrote:


On Jun 30, 2010, at 11:50 AM, Nathan wrote:


Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:

That said, i'm sure sameAs and differentIndividual (or however it is
called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

   # An rdf:List that loops around...

   <#mylist> a rdf:List ;
   rdf:first <#Alice> ;
   rdf:next <#mylist> .

   # A looping, branching mess...

   <#anotherlist> a rdf:List ;
   rdf:first <#anotherlist> ;
   rdf:next <#anotherlist> .

They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just about 
impossible to guarantee that messes can't happen when all you are 
doing is describing structures in an open-world setting. But I think 
the cure is to stop thinking that possible-messes are a problem to be 
solved. So, there is dung in the road. Walk round it.


Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked 
data' practise by using examples like { 'London' a x:Place } - whereas 
I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered with 
'walk round it', and further good practise could be aided by a few 
simple notes on best practise for linked data etc.


I wholly agree. Allowing literals in subject position in RDF is a 
no-brainer. (BTW, it would also immediately solve the 'bugs in the RDF 
rules' problem.) These arguments against it are nonsensical. The REAL 
argument against it is that it will mess up OWL-DL, or at any rate it 
*might* mess up OWL-DL.


The Description Logic police are still in charge:-)


As you know I'm pretty new to this, relatively, but here's a thought I 
can't get rid of.


Keep RDF as loose as possible at the core semantic level (subjects as 
literals etc).


Have the semantics of each triple defined by it's predicate (each 
property can define it's own domain and range etc)


This may also allow for using rdf as a data model, and there's no reason 
every triple must be dereferencable etc.


Above this, afaict, no reason why each serialization can't have it's own 
strong semantics too, like HTML+RDFa can instruct that a URI should be 
embedded and so forth (

Just a thought.. I'm sure you can tell me why I'm wrong

re OWL DL, does it have to consider every triple in a 'graph'?

Nathan

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Nathan wrote:

Kingsley Idehen wrote:

Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:

That said, i'm sure sameAs and differentIndividual (or however it is
called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

# An rdf:List that loops around...

<#mylist> a rdf:List ;
rdf:first <#Alice> ;
rdf:next <#mylist> .

# A looping, branching mess...

<#anotherlist> a rdf:List ;
rdf:first <#anotherlist> ;
rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just 
about impossible to guarantee that messes can't happen when all you 
are doing is describing structures in an open-world setting. But I 
think the cure is to stop thinking that possible-messes are a 
problem to be solved. So, there is dung in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked 
data' practise by using examples like { 'London' a x:Place } - 
whereas I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered 
with 'walk round it', and further good practise could be aided by a 
few simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" 
have Identifiers in the form of Name References (which may or many 
resolve to Structured Representations of Referents carried or borne 
by Descriptor Docs/Resources). An "Identifier" != Literal.


If you are in a situation where you can't or don't want to mint an 
HTTP based Name, simply use a URN, it does the job.


Surely that's Linked Data or a variant of EAV, not RDF - why should 
the core level data model be restricted so that it can't be used to 
say simple things like { 1 x:lessThan 2 ) ?


Yes, that's the context of my response.

I (biases on my sleeve) believe that local RDF (as per the past) has 
limited value.




Moreover, { :a :b "something" } == { "something" [owl:inverseOf :b] :a }

aside: you know I fully grok all the benefits of linked data and am a 
huge proponent, but rdf at it's core isn't linked data and saying:

  { x:London rdfs:label "London" }
is the same as saying
  { "London" is rdfs:label of x:London }
afaik, directionality doesn't come in to it.


Yes, RDF != Linked Data. But ironically, it might take this entire 
debate to fix that perception bug :-)




Best,

Nathan

please do correct me if I'm wrong




--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Pat Hayes wrote:


On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:

That said, i'm sure sameAs and differentIndividual (or however it is
called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

   # An rdf:List that loops around...

   <#mylist> a rdf:List ;
   rdf:first <#Alice> ;
   rdf:next <#mylist> .

   # A looping, branching mess...

   <#anotherlist> a rdf:List ;
   rdf:first <#anotherlist> ;
   rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just 
about impossible to guarantee that messes can't happen when all you 
are doing is describing structures in an open-world setting. But I 
think the cure is to stop thinking that possible-messes are a 
problem to be solved. So, there is dung in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked 
data' practise by using examples like { 'London' a x:Place } - 
whereas I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered 
with 'walk round it', and further good practise could be aided by a 
few simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" 
have Identifiers in the form of Name References (which may or many 
resolve to Structured Representations of Referents carried or borne 
by Descriptor Docs/Resources). An "Identifier" != Literal.


What ARE you talking about? You sound like someone reciting doctrine.

Literals in RDF are just as much 'identifiers' or 'names' as URIs are. 
They identify their value, most clearly and emphatically. They denote 
in exactly the same way that URIs denote. "23"^^xsd:number   is about 
as good an identification of the number twenty-three as you are ever 
likely to get in any notational system since ancient Babylonia.


Yes, but ancient Bablyonia != World Wide Web of Structured Linked Data, 
slightly different mediums with some shared characteristics :-)


The World Wide Web is becoming a Distributed DBMS (in my eyes). Thus, 
unambiguous naming matters.


Literal Subjects aren't a "show stopper" per se. (esp. for local RDF 
data). My gripe simply boils down to the nuisance factor introduced by 
data object name ambiguity in a distributed data object oriented realm 
such as the emerging Web of Linked Data.


What does ""23"^^xsd:number " mean to anyone in a global data space? I 
know the meaning of: 
, based on the 
resource I deref at: 




Kingsley




Pat Hayes



If you are in a situation where you can't or don't want to mint an 
HTTP based Name, simply use a URN, it does the job.





Best,

Nathan





--

Regards,

Kingsley Idehen  President & CEO OpenLink Software Web: 
http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen









IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes









--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen 

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Nathan]

Kingsley Idehen wrote:

Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:

That said, i'm sure sameAs and differentIndividual (or however it is
called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

# An rdf:List that loops around...

<#mylist> a rdf:List ;
rdf:first <#Alice> ;
rdf:next <#mylist> .

# A looping, branching mess...

<#anotherlist> a rdf:List ;
rdf:first <#anotherlist> ;
rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just about 
impossible to guarantee that messes can't happen when all you are 
doing is describing structures in an open-world setting. But I think 
the cure is to stop thinking that possible-messes are a problem to be 
solved. So, there is dung in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked 
data' practise by using examples like { 'London' a x:Place } - whereas 
I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered with 
'walk round it', and further good practise could be aided by a few 
simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" have 
Identifiers in the form of Name References (which may or many resolve to 
Structured Representations of Referents carried or borne by Descriptor 
Docs/Resources). An "Identifier" != Literal.


If you are in a situation where you can't or don't want to mint an HTTP 
based Name, simply use a URN, it does the job.


Surely that's Linked Data or a variant of EAV, not RDF - why should the 
core level data model be restricted so that it can't be used to say 
simple things like { 1 x:lessThan 2 ) ?


Moreover, { :a :b "something" } == { "something" [owl:inverseOf :b] :a }

aside: you know I fully grok all the benefits of linked data and am a 
huge proponent, but rdf at it's core isn't linked data and saying:

  { x:London rdfs:label "London" }
is the same as saying
  { "London" is rdfs:label of x:London }
afaik, directionality doesn't come in to it.

Best,

Nathan

please do correct me if I'm wrong

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Jeremy Carroll]

David Booth wrote:


I agree, but at the W3C RDF Next Steps workshop over the weekend, I was
surprised to find that there was substantial sentiment *against* having
literals as subjects.  A straw poll showed that of those at the
workshop, this is how people felt about having an RDF working group
charter include literals as subjects:
http://www.w3.org/2010/06/28-rdfn-minutes.html

  Charter MUST include:  0
  Charter SHOULD include:1
  Charter MAY include:   6
  Charter MUST NOT include: 12


  


I was one of the "MUST NOT"s to my surprise.

Here are the reasons I voted this way:

- it will mess up RDF/XML
- RDF/XML is horrid but we had consensus that it was unfixable - i.e. we 
need to live with it.
- however little work the WG does is too much in terms of the real 
obstacles to SW success (following Dan from

http://lists.w3.org/Archives/Public/semantic-web/2010Mar/0196.html
[[

What I feel is
missing (despite the *millions*) that has been thrown at the Semantic
Web brand, is the boring slog of getting the base tools and software
polished. 


]]
). In particular my view is that literals as subjects is not part of the 
problem to be solved.
- this is a purists' desire not a practical obstacle. No value-adding 
argument made for a change of this magnitude. It's a bug. Fixing it may 
cost $0.5M to $1M say, maybe more. I don't see that much return.


Jeremy

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Axel Rauschmayer]

Intuitively, I would expect each subject literal to have a unique identity. For 
example, I would want to annotate a particular instance of "abc" and not all 
literals "abc". Wouldn't the latter treatment make literals-as-subjects less 
appealing?

Re. the DL police: I use RDF like a next-generation relational database and 
think that RDF could be sold to many people this way (there is possibly are 
larger audience for this than for ontologies, reasoning, etc.). Especially 
considering how No-SQL is currently taking off. This part needs some love and 
seems to suffer from the almost exclusive focus on semantics.

Axel

On Jun 30, 2010, at 21:52 , David Booth wrote:

> On Wed, 2010-06-30 at 14:09 -0500, Pat Hayes wrote:
>> On Jun 30, 2010, at 11:50 AM, Nathan wrote:
> [ . . . ]
>>> Surely all of the subjects as literals arguments can be countered  
>>> with 'walk round it', and further good practise could be aided by a  
>>> few simple notes on best practise for linked data etc.
>> 
>> I wholly agree. Allowing literals in subject position in RDF is a no- 
>> brainer. 
> 
> I agree, but at the W3C RDF Next Steps workshop over the weekend, I was
> surprised to find that there was substantial sentiment *against* having
> literals as subjects.  A straw poll showed that of those at the
> workshop, this is how people felt about having an RDF working group
> charter include literals as subjects:
> http://www.w3.org/2010/06/28-rdfn-minutes.html
> 
>  Charter MUST include:  0
>  Charter SHOULD include:1
>  Charter MAY include:   6
>  Charter MUST NOT include: 12
> 
> Readers, please note that this was a non-binding, informative STRAW POLL
> ONLY -- not a vote.
> 
> Pat, I wish you had been there.  ;)
> 
> David
> 
>> (BTW, it would also immediately solve the 'bugs in the RDF  
>> rules' problem.) These arguments against it are nonsensical. The REAL  
>> argument against it is that it will mess up OWL-DL, or at any rate it  
>> *might* mess up OWL-DL.
>> 
>> The Description Logic police are still in charge:-)
>> 
>> Pat
>> 
>> 
>> 
>>> 
>>> Best,
>>> 
>>> Nathan
>>> 
>>> 
>> 
>> 
>> IHMC (850)434 8903 or (650)494 3973
>> 40 South Alcaniz St.   (850)202 4416   office
>> Pensacola(850)202 4440   fax
>> FL 32502  (850)291 0667   mobile
>> phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes
>> 
>> 
>> 
>> 
>> 
>> 
>> 
>> 
> 
> 
> -- 
> David Booth, Ph.D.
> Cleveland Clinic (contractor)
> http://dbooth.org/
> 
> Opinions expressed herein are those of the author and do not necessarily
> reflect those of Cleveland Clinic.
> 
> 
> 

-- 
Dr. Axel Rauschmayer
axel.rauschma...@ifi.lmu.de
http://hypergraphs.de/
:: Hyena: connected information manager, free at hypergraphs.de/hyena/ ::

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[David Booth]

On Wed, 2010-06-30 at 14:09 -0500, Pat Hayes wrote:
> On Jun 30, 2010, at 11:50 AM, Nathan wrote:
[ . . . ]
> > Surely all of the subjects as literals arguments can be countered  
> > with 'walk round it', and further good practise could be aided by a  
> > few simple notes on best practise for linked data etc.
> 
> I wholly agree. Allowing literals in subject position in RDF is a no- 
> brainer. 

I agree, but at the W3C RDF Next Steps workshop over the weekend, I was
surprised to find that there was substantial sentiment *against* having
literals as subjects.  A straw poll showed that of those at the
workshop, this is how people felt about having an RDF working group
charter include literals as subjects:
http://www.w3.org/2010/06/28-rdfn-minutes.html

  Charter MUST include:  0
  Charter SHOULD include:1
  Charter MAY include:   6
  Charter MUST NOT include: 12

Readers, please note that this was a non-binding, informative STRAW POLL
ONLY -- not a vote.

Pat, I wish you had been there.  ;)

David

> (BTW, it would also immediately solve the 'bugs in the RDF  
> rules' problem.) These arguments against it are nonsensical. The REAL  
> argument against it is that it will mess up OWL-DL, or at any rate it  
> *might* mess up OWL-DL.
> 
> The Description Logic police are still in charge:-)
> 
> Pat
> 
> 
> 
> >
> > Best,
> >
> > Nathan
> >
> >
> 
> 
> IHMC (850)434 8903 or (650)494 3973
> 40 South Alcaniz St.   (850)202 4416   office
> Pensacola(850)202 4440   fax
> FL 32502  (850)291 0667   mobile
> phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes
> 
> 
> 
> 
> 
> 
> 
> 


-- 
David Booth, Ph.D.
Cleveland Clinic (contractor)
http://dbooth.org/

Opinions expressed herein are those of the author and do not necessarily
reflect those of Cleveland Clinic.

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Melvin Carvalho]

On 30 June 2010 21:14, Pat Hayes  wrote:

>
> On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:
>
>  Nathan wrote:
>>
>>> Pat Hayes wrote:
>>>
 On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

> On Wed, 30 Jun 2010 10:54:20 +0100
> Dan Brickley  wrote:
>
>> That said, i'm sure sameAs and differentIndividual (or however it is
>> called) claims could probably make a mess, if added or removed...
>>
>
> You can create some pretty awesome messes even without OWL:
>
>   # An rdf:List that loops around...
>
>   <#mylist> a rdf:List ;
>   rdf:first <#Alice> ;
>   rdf:next <#mylist> .
>
>   # A looping, branching mess...
>
>   <#anotherlist> a rdf:List ;
>   rdf:first <#anotherlist> ;
>   rdf:next <#anotherlist> .
>
>
 They might be messy, but they are *possible* structures using pointers,
 which is what the RDF vocabulary describes.  Its just about impossible to
 guarantee that messes can't happen when all you are doing is describing
 structures in an open-world setting. But I think the cure is to stop
 thinking that possible-messes are a problem to be solved. So, there is dung
 in the road. Walk round it.


>>> Could we also apply that to the 'subjects as literals' general discussion
>>> that's going on then?
>>>
>>> For example I've heard people saying that it encourages bad 'linked data'
>>> practise by using examples like { 'London' a x:Place } - whereas I'd
>>> immediately counter with { x:London a 'Place' }.
>>>
>>> Surely all of the subjects as literals arguments can be countered with
>>> 'walk round it', and further good practise could be aided by a few simple
>>> notes on best practise for linked data etc.
>>>
>>
>> IMHO an emphatic NO.
>>
>> RDF is about constructing structured descriptions where "Subjects" have
>> Identifiers in the form of Name References (which may or many resolve to
>> Structured Representations of Referents carried or borne by Descriptor
>> Docs/Resources). An "Identifier" != Literal.
>>
>
> What ARE you talking about? You sound like someone reciting doctrine.
>
> Literals in RDF are just as much 'identifiers' or 'names' as URIs are. They
> identify their value, most clearly and emphatically. They denote in exactly
> the same way that URIs denote. "23"^^xsd:number   is about as good an
> identification of the number twenty-three as you are ever likely to get in
> any notational system since ancient Babylonia.
>

You can also do this:

http://km.aifb.kit.edu/projects/numbers/web/n23


>
> Pat Hayes
>
>
>
>> If you are in a situation where you can't or don't want to mint an HTTP
>> based Name, simply use a URN, it does the job.
>>
>>
>>
>>> Best,
>>>
>>> Nathan
>>>
>>>
>>>
>>
>> --
>>
>> Regards,
>>
>> Kingsley Idehen   President & CEO OpenLink Software Web:
>> http://www.openlinksw.com
>> Weblog: 
>> http://www.openlinksw.com/blog/~kidehen
>> Twitter/Identi.ca: kidehen
>>
>>
>>
>>
>>
>>
>>
> 
> IHMC (850)434 8903 or (650)494 3973
> 40 South Alcaniz St.   (850)202 4416   office
> Pensacola(850)202 4440   fax
> FL 32502  (850)291 0667   mobile
> phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes
>
>
>
>
>
>
>

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Jiří Procházka]

On 06/30/2010 09:09 PM, Pat Hayes wrote:
> 
> On Jun 30, 2010, at 11:50 AM, Nathan wrote:
> 
>> Pat Hayes wrote:
>>> On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:
 On Wed, 30 Jun 2010 10:54:20 +0100
 Dan Brickley  wrote:
> That said, i'm sure sameAs and differentIndividual (or however it is
> called) claims could probably make a mess, if added or removed...

 You can create some pretty awesome messes even without OWL:

# An rdf:List that loops around...

<#mylist> a rdf:List ;
rdf:first <#Alice> ;
rdf:next <#mylist> .

# A looping, branching mess...

<#anotherlist> a rdf:List ;
rdf:first <#anotherlist> ;
rdf:next <#anotherlist> .

>>> They might be messy, but they are *possible* structures using
>>> pointers, which is what the RDF vocabulary describes.  Its just about
>>> impossible to guarantee that messes can't happen when all you are
>>> doing is describing structures in an open-world setting. But I think
>>> the cure is to stop thinking that possible-messes are a problem to be
>>> solved. So, there is dung in the road. Walk round it.
>>
>> Could we also apply that to the 'subjects as literals' general
>> discussion that's going on then?
>>
>> For example I've heard people saying that it encourages bad 'linked
>> data' practise by using examples like { 'London' a x:Place } - whereas
>> I'd immediately counter with { x:London a 'Place' }.
>>
>> Surely all of the subjects as literals arguments can be countered with
>> 'walk round it', and further good practise could be aided by a few
>> simple notes on best practise for linked data etc.
> 
> I wholly agree. Allowing literals in subject position in RDF is a
> no-brainer. (BTW, it would also immediately solve the 'bugs in the RDF
> rules' problem.) These arguments against it are nonsensical. The REAL
> argument against it is that it will mess up OWL-DL, or at any rate it
> *might* mess up OWL-DL.

I wonder, when using owl:sameAs or related, to "name" literals to be
able to say other useful thing about them in normal triples (datatype,
language, etc) does it break OWL DL (or any other formalism which is
base of some ontology extending RDF semantics)? Or would it if
rdf:sameAs was introduced?

Best,
Jiri

> 
> The Description Logic police are still in charge:-)
> 
> Pat
> 
> 
> 
>>
>> Best,
>>
>> Nathan
>>
>>
> 
> 
> IHMC (850)434 8903 or (650)494 3973
> 40 South Alcaniz St.   (850)202 4416   office
> Pensacola(850)202 4440   fax
> FL 32502  (850)291 0667   mobile
> phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes
> 
> 
> 
> 
> 
> 



signature.asc
Description: OpenPGP digital signature

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jun 30, 2010, at 1:30 PM, Kingsley Idehen wrote:


Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or however  
it is

called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

   # An rdf:List that loops around...

   <#mylist> a rdf:List ;
   rdf:first <#Alice> ;
   rdf:next <#mylist> .

   # A looping, branching mess...

   <#anotherlist> a rdf:List ;
   rdf:first <#anotherlist> ;
   rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using  
pointers, which is what the RDF vocabulary describes.  Its just  
about impossible to guarantee that messes can't happen when all  
you are doing is describing structures in an open-world setting.  
But I think the cure is to stop thinking that possible-messes are  
a problem to be solved. So, there is dung in the road. Walk round  
it.




Could we also apply that to the 'subjects as literals' general  
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked  
data' practise by using examples like { 'London' a x:Place } -  
whereas I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered  
with 'walk round it', and further good practise could be aided by a  
few simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects"  
have Identifiers in the form of Name References (which may or many  
resolve to Structured Representations of Referents carried or borne  
by Descriptor Docs/Resources). An "Identifier" != Literal.


What ARE you talking about? You sound like someone reciting doctrine.

Literals in RDF are just as much 'identifiers' or 'names' as URIs are.  
They identify their value, most clearly and emphatically. They denote  
in exactly the same way that URIs denote. "23"^^xsd:number   is about  
as good an identification of the number twenty-three as you are ever  
likely to get in any notational system since ancient Babylonia.


Pat Hayes



If you are in a situation where you can't or don't want to mint an  
HTTP based Name, simply use a URN, it does the job.





Best,

Nathan





--

Regards,

Kingsley Idehen   President & CEO OpenLink Software Web: 
http://www.openlinksw.com
Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen









IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Pat Hayes]

On Jun 30, 2010, at 11:50 AM, Nathan wrote:


Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:
That said, i'm sure sameAs and differentIndividual (or however it  
is

called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

   # An rdf:List that loops around...

   <#mylist> a rdf:List ;
   rdf:first <#Alice> ;
   rdf:next <#mylist> .

   # A looping, branching mess...

   <#anotherlist> a rdf:List ;
   rdf:first <#anotherlist> ;
   rdf:next <#anotherlist> .

They might be messy, but they are *possible* structures using  
pointers, which is what the RDF vocabulary describes.  Its just  
about impossible to guarantee that messes can't happen when all you  
are doing is describing structures in an open-world setting. But I  
think the cure is to stop thinking that possible-messes are a  
problem to be solved. So, there is dung in the road. Walk round it.


Could we also apply that to the 'subjects as literals' general  
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked  
data' practise by using examples like { 'London' a x:Place } -  
whereas I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered  
with 'walk round it', and further good practise could be aided by a  
few simple notes on best practise for linked data etc.


I wholly agree. Allowing literals in subject position in RDF is a no- 
brainer. (BTW, it would also immediately solve the 'bugs in the RDF  
rules' problem.) These arguments against it are nonsensical. The REAL  
argument against it is that it will mess up OWL-DL, or at any rate it  
*might* mess up OWL-DL.


The Description Logic police are still in charge:-)

Pat





Best,

Nathan





IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St.   (850)202 4416   office
Pensacola(850)202 4440   fax
FL 32502  (850)291 0667   mobile
phayesAT-SIGNihmc.us   http://www.ihmc.us/users/phayes

Re: Subjects as Literals, [was Re: The Ordered List Ontology]

[Kingsley Idehen]

Nathan wrote:

Pat Hayes wrote:

On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:

On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley  wrote:

That said, i'm sure sameAs and differentIndividual (or however it is
called) claims could probably make a mess, if added or removed...


You can create some pretty awesome messes even without OWL:

# An rdf:List that loops around...

<#mylist> a rdf:List ;
rdf:first <#Alice> ;
rdf:next <#mylist> .

# A looping, branching mess...

<#anotherlist> a rdf:List ;
rdf:first <#anotherlist> ;
rdf:next <#anotherlist> .



They might be messy, but they are *possible* structures using 
pointers, which is what the RDF vocabulary describes.  Its just about 
impossible to guarantee that messes can't happen when all you are 
doing is describing structures in an open-world setting. But I think 
the cure is to stop thinking that possible-messes are a problem to be 
solved. So, there is dung in the road. Walk round it.




Could we also apply that to the 'subjects as literals' general 
discussion that's going on then?


For example I've heard people saying that it encourages bad 'linked 
data' practise by using examples like { 'London' a x:Place } - whereas 
I'd immediately counter with { x:London a 'Place' }.


Surely all of the subjects as literals arguments can be countered with 
'walk round it', and further good practise could be aided by a few 
simple notes on best practise for linked data etc.


IMHO an emphatic NO.

RDF is about constructing structured descriptions where "Subjects" have 
Identifiers in the form of Name References (which may or many resolve to 
Structured Representations of Referents carried or borne by Descriptor 
Docs/Resources). An "Identifier" != Literal.


If you are in a situation where you can't or don't want to mint an HTTP 
based Name, simply use a URN, it does the job.





Best,

Nathan





--

Regards,

Kingsley Idehen	  
President & CEO 
OpenLink Software 
Web: http://www.openlinksw.com

Weblog: http://www.openlinksw.com/blog/~kidehen
Twitter/Identi.ca: kidehen