The Ordered List Ontology

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
296 messages Options
1234 ... 15
Reply | Threaded
Open this post in threaded view
|

The Ordered List Ontology

Bob Ferris
Hello everybody,

in a longer discussion in the Music Ontology mailing list about how to
model a playlist, Samer Abdallah came up with a very good proposal[1] of
modelling a sequence/ordered list (as recently also discussed at RDFNext
Workshop[2]) as semantic graph (in RDF).
So, here we go:

- specification[3] (please also note the anonymous inverse properties)
- concepts and relations in a graphic[4]
- funky playlist example[5,6]

Again, thanks a lot Samer Abdallah for that cool concept.
Comments, suggestions, critics are very welcome.

Cheers,


Bob

PS: its all OWL based ;) however, we could also downgrade the concept on
the basis of rdfs:class, if needed.



[1]
http://groups.google.com/group/music-ontology-specification-group/msg/305a42362a1e4145
[2] http://www.w3.org/2009/12/rdf-ws/slides/rdflist.pdf
[3]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/rdf/orderedlistontology.n3
[4]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist.gif
[5]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/examples/orderedlist_-_example.n3
[6]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist_example.gif 


Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Barry Norton-2

Bob, I wrote a similar representation in WSML-Flight [1] a few years ago
[2], where it was possible to construct an axiom that for a list of
length n there should exist unique values for each of the indices 1-n,
and no others. I doubt that this is possible here (without RIF), is it?

Barry

[1] http://www.wsmo.org/TR/d16/
[2] http://www.ip-super.org/res/Deliverables/M36/D1.5.pdf



On 28/06/10 09:58, Bob Ferris wrote:

> Hello everybody,
>
> in a longer discussion in the Music Ontology mailing list about how to
> model a playlist, Samer Abdallah came up with a very good proposal[1]
> of modelling a sequence/ordered list (as recently also discussed at
> RDFNext Workshop[2]) as semantic graph (in RDF).
> So, here we go:
>
> - specification[3] (please also note the anonymous inverse properties)
> - concepts and relations in a graphic[4]
> - funky playlist example[5,6]
>
> Again, thanks a lot Samer Abdallah for that cool concept.
> Comments, suggestions, critics are very welcome.
>
> Cheers,
>
>
> Bob
>
> PS: its all OWL based ;) however, we could also downgrade the concept
> on the basis of rdfs:class, if needed.
>
>
>
> [1]
> http://groups.google.com/group/music-ontology-specification-group/msg/305a42362a1e4145 
>
> [2] http://www.w3.org/2009/12/rdf-ws/slides/rdflist.pdf
> [3]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/rdf/orderedlistontology.n3 
>
> [4]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist.gif 
>
> [5]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/examples/orderedlist_-_example.n3 
>
> [6]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist_example.gif 
>
>


Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Graham Klyne-7
In reply to this post by Bob Ferris
Bob,

A desired feature that led to the current rdf:List structure is the ability to
"close" a list - so some separate sub-graph can't "silently" add properties not
in the original.  Your pattern might allow this through additon of a
"maxSlotIndex" property on "olo:OrderedList" (not suggesting this as a design,
just an example).

#g
--


Bob Ferris wrote:

> Hello everybody,
>
> in a longer discussion in the Music Ontology mailing list about how to
> model a playlist, Samer Abdallah came up with a very good proposal[1] of
> modelling a sequence/ordered list (as recently also discussed at RDFNext
> Workshop[2]) as semantic graph (in RDF).
> So, here we go:
>
> - specification[3] (please also note the anonymous inverse properties)
> - concepts and relations in a graphic[4]
> - funky playlist example[5,6]
>
> Again, thanks a lot Samer Abdallah for that cool concept.
> Comments, suggestions, critics are very welcome.
>
> Cheers,
>
>
> Bob
>
> PS: its all OWL based ;) however, we could also downgrade the concept on
> the basis of rdfs:class, if needed.
>
>
>
> [1]
> http://groups.google.com/group/music-ontology-specification-group/msg/305a42362a1e4145 
>
> [2] http://www.w3.org/2009/12/rdf-ws/slides/rdflist.pdf
> [3]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/rdf/orderedlistontology.n3 
>
> [4]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist.gif 
>
> [5]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/examples/orderedlist_-_example.n3 
>
> [6]
> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist_example.gif 
>
>




Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Bob Ferris
In reply to this post by Barry Norton-2
Am 28.06.2010 10:17, schrieb Barry Norton:
>
> Bob, I wrote a similar representation in WSML-Flight [1] a few years ago
> [2], where it was possible to construct an axiom that for a list of
> length n there should exist unique values for each of the indices 1-n,
> and no others. I doubt that this is possible here (without RIF), is it?
>

Hi Barry,

as far as I can see, you used rdf:list/rdf:rest for the list modelling,
is that right? You maybe also followed the still ongoing discussion
about rdf:list[1].
One conclusion for me was that we need another concept, which is
independent of rdf:list (rdf:seq). I thought also about adding further
properties, especially olo:previous and olo:next to express a
concatenated list.
This properties could get a owl:cardinality restriction of "1". However,
then it might still be possible to define two slots, which have the same
index in the ordered list, but I currently don't know how to change this
without using a rule, which defines that there could only one slot per
index.

Cheers,


Bob

PS: Please also think about the naming a bit: olo:OrderdList vs.
olo:Sequence, which one would you prefer? (/me +1 olo:OrderedList)

[1]
http://old.nabble.com/What-is-it-that%27s-wrong-with-rdf%3AList-to28920391.html



Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Bob Ferris
In reply to this post by Graham Klyne-7
Hi Graham,

thanks a lot for this suggestion. I spent some more time in making this
concept a bit more solid [1,2]. Here the features that I added/changed
in the v0.3 proposal (+ for added, ~for modified):

  + olo:next - to associate the next slot of a slot in an ordered list
  ~ olo:length - to enable a single length association to an ordered list
  ~ olo:length - rdfs:range xsd:positiveInteger (no empty lists!)
  ~ olo:index - to enable a single index association to a slot in an
ordered list
  ~ anonymous inverse property of olo:slot to rdfs:type
owl:FunctionalProperty

With that changes it should be possible

... to create a unique neighbourhood relation; the list ends if the slot
hasn't a neighbour (that means no is:next property is set)
... to associate a single index to a slot; however, this still not
prevents from inserting several slots with the same index
... to associate a single length to an ordered list

To model the unique relations for index and length I followed the
pattern from here[3].

I think, if the size of the ordered list is defined in its length, which
should be used by a rule for validation, why we need than another
property, which defines its max length (see also my thoughts about
practical application)?
I still believe that it isn't possible to guarantee full valid ordered
lists, without the use of some rules (only with the
rdf:first/rdf:next/rdf:nil pattern). However, rules are created for some
purpose, so why not use them (think practical here).
Another practical thought is, if something changes in the ordered list,
e.g. a new slot would be added, than the graph of the list will be
rewritten or a new one would be created (that depends on the used
revision mechanism).

Comments, suggestions, critics on the new proposal are very welcome.

Cheers,


Bob


[1]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/branches/orderedlistsonto_v03/rdf/orderedlistontology.n3
[2]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/branches/orderedlistsonto_v03/gfx/olo_-_orderedlist.gif 

[3] http://www.w3.org/TR/2004/REC-owl-guide-20040210/#simpleCardinality

Am 28.06.2010 10:51, schrieb Graham Klyne:

> Bob,
>
> A desired feature that led to the current rdf:List structure is the
> ability to "close" a list - so some separate sub-graph can't "silently"
> add properties not in the original. Your pattern might allow this
> through additon of a "maxSlotIndex" property on "olo:OrderedList" (not
> suggesting this as a design, just an example).
>
> #g
> --
>
>
> Bob Ferris wrote:
>> Hello everybody,
>>
>> in a longer discussion in the Music Ontology mailing list about how to
>> model a playlist, Samer Abdallah came up with a very good proposal[1]
>> of modelling a sequence/ordered list (as recently also discussed at
>> RDFNext Workshop[2]) as semantic graph (in RDF).
>> So, here we go:
>>
>> - specification[3] (please also note the anonymous inverse properties)
>> - concepts and relations in a graphic[4]
>> - funky playlist example[5,6]
>>
>> Again, thanks a lot Samer Abdallah for that cool concept.
>> Comments, suggestions, critics are very welcome.
>>
>> Cheers,
>>
>>
>> Bob
>>
>> PS: its all OWL based ;) however, we could also downgrade the concept
>> on the basis of rdfs:class, if needed.
>>
>>
>>
>> [1]
>> http://groups.google.com/group/music-ontology-specification-group/msg/305a42362a1e4145
>>
>> [2] http://www.w3.org/2009/12/rdf-ws/slides/rdflist.pdf
>> [3]
>> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/rdf/orderedlistontology.n3
>>
>> [4]
>> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist.gif
>>
>> [5]
>> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/examples/orderedlist_-_example.n3
>>
>> [6]
>> http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist_example.gif
>>
>>
>
>


--
--------------------BEGIN-OF-SIGNATURE--------------------

Bob Ferris

website: http://elbklang.net
e-mail:  [hidden email]

--------------------END-OF-SIGNATURE----------------------

Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Aldo Gangemi-3
In reply to this post by Bob Ferris
Hi Bob, I like the basic idea here because it matches a real modelling need to represent ordered collections/lists.
A vocabulary for that can be submitted as a design patterns on ODP [1] for public utility.

However, why do you want to represent ordered lists, slots and items as [ rdf:type owl:Class ] (or rdfs:Class)? While a list is a set mathematically speaking, is there any advantage in representing the lists you want to talk about as sets?

This has some bad consequences. In your example, SexMachine and GoodFoot are inferred to be [ rdf:type owl:Class ], not only [ rdf:type mo:Track ]. Therefore James Brown results to be the author (foaf:made) of an owl:Class (SexMachine), ehich is at least awkward :).

In order to avoid this consequence, while preserving the basic intuition of your vocabulary, you can have ordered lists, slots and items as [ rdf:type owl:Thing ] instead. As a related example that follows this practice, on ODP, there is the "collection entity" pattern [2], which can represent any kind of collection/list, and can be extended with your vocabulary to represent ordered lists with slots and indexes.

Best
Aldo

[1] http://www.ontologydesignpatterns.org
[2] http://www.ontologydesignpatterns.org/cp/owl/collectionentity.owl

On 28 Jun 2010, at 09:58, Bob Ferris wrote:

> Hello everybody,
>
> in a longer discussion in the Music Ontology mailing list about how to model a playlist, Samer Abdallah came up with a very good proposal[1] of modelling a sequence/ordered list (as recently also discussed at RDFNext Workshop[2]) as semantic graph (in RDF).
> So, here we go:
>
> - specification[3] (please also note the anonymous inverse properties)
> - concepts and relations in a graphic[4]
> - funky playlist example[5,6]
>
> Again, thanks a lot Samer Abdallah for that cool concept.
> Comments, suggestions, critics are very welcome.
>
> Cheers,
>
>
> Bob
>
> PS: its all OWL based ;) however, we could also downgrade the concept on the basis of rdfs:class, if needed.
>
>
>
> [1] http://groups.google.com/group/music-ontology-specification-group/msg/305a42362a1e4145
> [2] http://www.w3.org/2009/12/rdf-ws/slides/rdflist.pdf
> [3] http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/rdf/orderedlistontology.n3
> [4] http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist.gif
> [5] http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/examples/orderedlist_-_example.n3
> [6] http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/trunk/gfx/olo_-_orderedlist_example.gif 
>



_____________________________________

Aldo Gangemi
Senior Researcher
Semantic Technology Lab (STLab)
Institute for Cognitive Science and Technology,
National Research Council (ISTC-CNR)
Via Nomentana 56, 00161, Roma, Italy
Tel: +390644161535
Fax: +390644161513
[hidden email]
http://www.stlab.istc.cnr.it
http://www.istc.cnr.it/createhtml.php?nbr=71
skype aldogangemi


Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

speroni
Hi Aldo,

Hi Bob, I like the basic idea here because it matches a real modelling need to represent ordered collections/lists.
A vocabulary for that can be submitted as a design patterns on ODP [1] for public utility.

An OWL ontology describing ordered/non-ordered collections [1] has been published by Paolo Ciccarese for SWAN [2]. I think it is enough general to be considered a kind of pattern for handling these scenarios, isn't it?

Best,

S.


[1] - http://swan.mindinformatics.org/spec/1.2/collections.html
[2] - http://swan.mindinformatics.org



----------------------------------------------------------------------------
Silvio Peroni, Ph.D. student
Department of Computer Science
University of Bologna, Bologna (Italy)
+39 051 2094871

Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Aldo Gangemi-3
Yes, I like the SWAN ontology ... I remember sometimes ago I wanted to modularize it and submit the modules as design patterns :).

Consider that, besides the typing problem in OLO, there is a difference between OLO and SWAN in that OLO allows for "slots" that enable a designer to assign indexes to items directly, while SWAN does not have indexes, although they can be inferred with a query over the "swan:nextItem" property. SWAN has the advantage of making a clear distinction between sets, bags and lists.

In principle, with a RIF rule added to SWAN (or a SPARQL/SPIN add-on), you can get the same results as in OLO, while being able to reason with transitivity over a sequence relation in a list.

Considering sequencing, it'd be nice to decouple transitivity and intransitivity (easier queries and rules), cf. the "sequence" design pattern in ODP [3].


On 28 Jun 2010, at 15:08, Silvio Peroni wrote:

Hi Aldo,

Hi Bob, I like the basic idea here because it matches a real modelling need to represent ordered collections/lists.
A vocabulary for that can be submitted as a design patterns on ODP [1] for public utility.

An OWL ontology describing ordered/non-ordered collections [1] has been published by Paolo Ciccarese for SWAN [2]. I think it is enough general to be considered a kind of pattern for handling these scenarios, isn't it?

Best,

S.


[1] - http://swan.mindinformatics.org/spec/1.2/collections.html
[2] - http://swan.mindinformatics.org



----------------------------------------------------------------------------
Silvio Peroni, Ph.D. student
Department of Computer Science
University of Bologna, Bologna (Italy)
+39 051 2094871




_____________________________________

Aldo Gangemi
Senior Researcher
Semantic Technology Lab (STLab)
Institute for Cognitive Science and Technology,
National Research Council (ISTC-CNR) 
Via Nomentana 56, 00161, Roma, Italy 
Tel: +390644161535
Fax: +390644161513
skype aldogangemi

Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Bob Ferris
Hi Aldo,
Hi Silvio,

Thanks a lot, Silvio, for the Colletion Ontology. I oversaw this
ontology somehow.

Am 28.06.2010 16:29, schrieb Aldo Gangemi:
> Yes, I like the SWAN ontology ... I remember sometimes ago I wanted to
> modularize it and submit the modules as design patterns :).
>
> Consider that, besides the typing problem in OLO, there is a difference
> between OLO and SWAN in that OLO allows for "slots" that enable a
> designer to assign indexes to items directly, while SWAN does not have
> indexes, although they can be inferred with a query over the
> "swan:nextItem" property. SWAN has the advantage of making a clear
> distinction between sets, bags and lists.

Yes, the initial and primary access method to single slots in an ordered
list should be olo:index. The secondary access method is its (currently)
optional iterator olo:next as shortcut to the next slot in the list.

>
> In principle, with a RIF rule added to SWAN (or a SPARQL/SPIN add-on),
> you can get the same results as in OLO, while being able to reason with
> transitivity over a sequence relation in a list.
>
> Considering sequencing, it'd be nice to decouple transitivity and
> intransitivity (easier queries and rules), cf. the "sequence" design
> pattern in ODP [3].

The transitivity re. the 'follow issue' is also very interesting. Maybe
we could also add it. However, I see then many triples in the transitive
'follow properties', which implies a more complicate change mechanism.
May one have to figure out the performances of the different approaches.

 > However, why do you want to represent ordered lists, slots and items
 > as [ rdf:type owl:Class ] (or rdfs:Class)?

Because I like to use here the most abstract concept of a meta model. In
the OWL world this is for me owl:Class or owl:Thing and in the RDFS
world this is for me rdfs:Resource (as the most abstract concept
overall) and rdfs:Class.

 > While a list is a set mathematically speaking, is there any advantage
 > in representing the lists you want to talk about as sets?
 >
 > This has some bad consequences. In your example, SexMachine and
 > GoodFoot are inferred to be [ rdf:type owl:Class ], not only [
 > rdf:type mo:Track ]. Therefore James Brown results to be the author
 > (foaf:made) of an owl:Class (SexMachine), ehich is at least awkward
 > :).

Thanks for that hint, Aldo. I removed the rdfs:range from olo:item in
the v 0.5 version[1].

Feel free to add further comments, suggestions, critics.

Cheers,


Bob

[1]
http://motools.svn.sourceforge.net/viewvc/motools/orderedlistsonto/branches/orderedlistsonto_v03/rdf/orderedlistontology.n3

Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Dan Brickley-2
In reply to this post by Graham Klyne-7




On 28 Jun 2010, at 09:51, Graham Klyne <[hidden email]> wrote:

> Bob,
>
> A desired feature that led to the current rdf:List structure is the ability to "close" a list - so some separate sub-graph can't "silently" add properties not in the original.

Also that consumers could notice when some intermediary truncates the data.

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

Dan
Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Toby Inkster-4
On Wed, 30 Jun 2010 10:54:20 +0100
Dan Brickley <[hidden email]> 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> .

--
Toby A Inkster
<mailto:[hidden email]>
<http://tobyinkster.co.uk>


Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Pat Hayes

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

> On Wed, 30 Jun 2010 10:54:20 +0100
> Dan Brickley <[hidden email]> 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.

Pat

> --
> Toby A Inkster
> <mailto:[hidden email]>
> <http://tobyinkster.co.uk>
>
>
>

------------------------------------------------------------
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






Reply | Threaded
Open this post in threaded view
|

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

Nathan Rixham-2
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 <[hidden email]> 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.

Best,

Nathan

Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Hugh Glaser
In reply to this post by Toby Inkster-4
<Enjoying a trip down memory lane when I used to be functional>

On 30/06/2010 12:45, "Toby Inkster" <[hidden email]> wrote:

> On Wed, 30 Jun 2010 10:54:20 +0100
> Dan Brickley <[hidden email]> 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> .
That's not a mess, that's pretty.
And can be pretty useful.
An infinite list of Alices - I think Lewis Carroll would have heartily
approved.
>
> # A looping, branching mess...
>
> <#anotherlist> a rdf:List ;
> rdf:first <#anotherlist> ;
> rdf:next <#anotherlist> .
An interesting structure.

I'm sure I can think of some use cases for the first, but not so sure about
the second in RDF.

Am I right in thinking that owl:sameAs is a bit like a "let" or "where"
clause?

I like to think that Strachey would be using RDF to bring down my SPARQL
endpoint by getting it to calculate things like infinite precision
multiplication.
Any offers what that Prime Sieve would look like in RDF?
Here is what it looks like in Miranda:
        primes = sieve [ 2.. ]
                 where
                 sieve (p:x) = p : sieve [ n | n <- x; n mod p > 0 ]


Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Barry Norton-2

I wondered who'd be first to mention lazy-evaluation FP :)

(My example would have been in Haskell)

Barry


On 30/06/10 20:01, Hugh Glaser wrote:

> <Enjoying a trip down memory lane when I used to be functional>
>
> On 30/06/2010 12:45, "Toby Inkster"<[hidden email]>  wrote:
>
>    
>> On Wed, 30 Jun 2010 10:54:20 +0100
>> Dan Brickley<[hidden email]>  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>  .
>>      
> That's not a mess, that's pretty.
> And can be pretty useful.
> An infinite list of Alices - I think Lewis Carroll would have heartily
> approved.
>    
>> # A looping, branching mess...
>>
>> <#anotherlist>  a rdf:List ;
>> rdf:first<#anotherlist>  ;
>> rdf:next<#anotherlist>  .
>>      
> An interesting structure.
>
> I'm sure I can think of some use cases for the first, but not so sure about
> the second in RDF.
>
> Am I right in thinking that owl:sameAs is a bit like a "let" or "where"
> clause?
>
> I like to think that Strachey would be using RDF to bring down my SPARQL
> endpoint by getting it to calculate things like infinite precision
> multiplication.
> Any offers what that Prime Sieve would look like in RDF?
> Here is what it looks like in Miranda:
>          primes = sieve [ 2.. ]
>                   where
>                   sieve (p:x) = p : sieve [ n | n<- x; n mod p>  0 ]
>
>
>    


Reply | Threaded
Open this post in threaded view
|

Re: The Ordered List Ontology

Dan Brickley-2
In reply to this post by Pat Hayes
On Wed, Jun 30, 2010 at 6:34 PM, Pat Hayes <[hidden email]> wrote:

>
> On Jun 30, 2010, at 6:45 AM, Toby Inkster wrote:
>
>> On Wed, 30 Jun 2010 10:54:20 +0100
>> Dan Brickley <[hidden email]> 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.

Yes.

So this is a point that probably needs careful presentation to new
users of this technology. Educating people that they shouldn't believe
any random RDF they find in the Web, ... now that is pretty easy.
Still needs doing, but it shadows real world intuitions pretty well.

If in real life you think the Daily Mail is full of nonsense, then it
isn't a huge leap to treat RDFized representations of their claims
with similar skepticism (eg. see
http://data.totl.net/cancer_causes.rdf for a great list of Things The
Daily Mail Say Might Cause Cancer).

*However* it is going to be tough to persuade developers to treat a
basic data structure like List in the same way. Lists are the kinds of
thing we expect to be communicated perfectly or to get some low-level
error. A lot of developers will write RDF-consuming code that won't
anticipate errors. Hopefully supporting software libraries can take
some of the strain here...

cheers,

Dan

Reply | Threaded
Open this post in threaded view
|

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

Kingsley Idehen
In reply to this post by Nathan Rixham-2
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 <[hidden email]> 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






Reply | Threaded
Open this post in threaded view
|

Re: Subjects as Literals

David Booth-6
On Wed, 2010-06-30 at 14:30 -0400, Kingsley Idehen wrote:
> Nathan wrote:
> > Pat Hayes 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.
>
> 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.

Can you explain *why* you think literals should not be permitted as
subjects?  The rationale you have given above sounds like it is saying
that literals should not be subjects because RDF does not permit
literals to be subjects.  

IMHO, RDF should allow "anyone to say anything about anything" -- not
"anyone to say anything about anything . . . except a literal".
However, if you see some specific harm in permitting statements about
literals, please tell us what that harm would be.



--
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.


Reply | Threaded
Open this post in threaded view
|

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

Pat Hayes
In reply to this post by Nathan Rixham-2

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 <[hidden email]> 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






Reply | Threaded
Open this post in threaded view
|

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

Pat Hayes
In reply to this post by Kingsley Idehen

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 <[hidden email]> 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






1234 ... 15