Concept schemes and the models that describe them ...

Dan brought this issue up yesterday, it seems like a crucial but difficult
one.  Anyway, here's some ideas I had on it ...

(pasted from <http://esw.w3.org/topic/SkosDev/SkosCore/SchemesAndModels> ...
you might want to read it there as this is quite long)

1 A Convention for Schemes and Models

N.B. This seems like undiscovered country (please correct me if I'm wrong),
so I'm going to poke my head out and see what happens ... 

Danbri has suggested that we need some convention that describes the
relationship between the URI for a concept-scheme and the URL(s) for the RDF
models that contain all the statements describing the scheme and its
constituent concepts. 

I suggest the following. 

The URI of a concept scheme should resolve to a content-negotiable
description of just the scheme itself. 

So if the URI of my scheme is http://example.org/myscheme then an http
client requesting that resource with Content-type=application/rdf+xml should
receive something like the following ... 

<?xml version="1.0" encoding="UTF-8"?> 
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
  xmlns:skos="http://www.w3.org/2004/02/skos/core#" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:temp="http://somewhere.org/modelvocab#" > 
 
  <skos:ConceptScheme rdf:about="http://example.org/myscheme"> 
    <dc:title>My example scheme</dc:title> 
    <dc:description>An example concept scheme.</dc:description> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myscheme/concept/c0345"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myscheme/concept/c2134"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myscheme/concept/c7956"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myscheme/concept/c5342"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myscheme/concept/c5473"/> 
    <temp:loadModel> 
      <temp:Model> 
        <temp:loadFrom
rdf:resource="http://example.org/myscheme/concepts.rdf"/> 
      </temp:Model> 
    </temp:loadModel> 
  </skos:ConceptScheme> 
 
</rdf:RDF> 

The vital bit here is all the stuff with a temp: namespace prefix. In a
nutshell, I'm saying that we need a way of saying that 'The complete set of
statements describing concept scheme X can be loaded from the resource with
URL Y' . Now I have no idea what the best way to do this is, hence the temp:
stuff - hopefully someone can tell me if there is already an RDF vocabulary
for describing this sort of thing, and if not, can help me work out the best
way to do it, or even if I'm barking up the right tree or not. 

But anyway, if we take this as a temporary starting point, there are some
potentially quite interesting scenarios. 

For example, perhaps you have a multilingual concept scheme, but you don't
want to publish the whole thing as a single resource because perhaps some of
your users want to download only labels in a specific language. You could
describe this as in e.g. (again making this up off the top of my head) ... 

<?xml version="1.0" encoding="UTF-8"?> 
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
  xmlns:skos="http://www.w3.org/2004/02/skos/core#" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:temp="http://somewhere.org/modelvocab#" > 
 
  <skos:ConceptScheme rdf:about="http://example.org/myMultilingualScheme"> 
    <dc:title>My example multilingual scheme</dc:title> 
    <dc:description>An example multilingual concept scheme.</dc:description>

    <skos:hasTopConcept
rdf:resource="http://example.org/myMultilingualScheme/concept/c0345"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myMultilingualScheme/concept/c2134"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myMultilingualScheme/concept/c7956"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myMultilingualScheme/concept/c5342"/> 
    <skos:hasTopConcept
rdf:resource="http://example.org/myMultilingualScheme/concept/c5473"/> 
    <temp:loadModel> 
      <temp:Model> 
        <temp:unionOf rdf:parseType="Collection"> 
          <temp:Model> 
            <rdfs:comment>The model describing the concept
backbone.</rdfs:comment> 
            <temp:loadFrom
rdf:resource="http://example.org/myMultilingualScheme/concepts.rdf"/> 
          </temp:Model> 
          <temp:Model> 
            <rdfs:comment>The model describing english labels and
annotations.</rdfs:comment> 
            <temp:loadFrom
rdf:resource="http://example.org/myMultilingualScheme/labels_en.rdf"/> 
          </temp:Model> 
          <temp:Model> 
            <rdfs:comment>The model describing the french labels and
annotations.</rdfs:comment> 
            <temp:loadFrom
rdf:resource="http://example.org/myMultilingualScheme/labels_fr.rdf"/> 
          </temp:Model> 
        </temp:unionOf> 
      </temp:Model> 
    </temp:loadModel> 
  </skos:ConceptScheme> 
 
</rdf:RDF> 

So I'm starting to think about what you can do if you can describe set-type
operations on models. 

Another very interesting scenario is this: Let's say you want to build a new
concept scheme, but you don't want to build it from scratch. You want to
take two pre-existing schemes, include them, define links between them, and
perhaps add a few concepts of your own. Again, a union operation allows you
to do this, as in e.g. ... 

<?xml version="1.0" encoding="UTF-8"?> 
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
  xmlns:skos="http://www.w3.org/2004/02/skos/core#" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:temp="http://somewhere.org/modelvocab#" > 
 
  <skos:ConceptScheme rdf:about="http://example.org/myCombinedScheme"> 
    <dc:title>My example combined scheme</dc:title> 
    <dc:description>An example of a concept scheme built on two pre-existing
schemes.</dc:description> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c0345"/> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c2134"/> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c7956"/> 
    <skos:hasTopConcept
rdf:resource="http://authority2.org/scheme/concept/c5342"/> 
    <skos:hasTopConcept
rdf:resource="http://authority2.org/scheme/concept/c5473"/> 
    <owl:imports rdf:resource="http://authority1.org/scheme/"/> 
    <owl:imports rdf:resource="http://authority2.org/scheme/"/> 
    <temp:loadModel> 
      <temp:Model> 
        <rdfs:comment>A model containing statements linking the two imported
schemes, and some extra concepts of my own.</rdfs:comment> 
        <temp:loadFrom
rdf:resource="http://example.org/myCombinedScheme/additions.rdf"/> 
      </temp:Model> 
    </temp:loadModel> 
  </skos:ConceptScheme> 
 
</rdf:RDF> 

... here I'm relying on some implied semantics in relation to the use of
owl:imports: that the complete model describing the combined scheme must
include all the statements from the imported schemes (i.e. there is an
implied union operation). 

This scenario can be extended ... let's say you want to take two
pre-existing schemes as a starting point for a new scheme, but you don't
want to use all of these schemes - you want to throw some bits out. A set
type operation can describe this ... 

<?xml version="1.0" encoding="UTF-8"?> 
<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
  xmlns:skos="http://www.w3.org/2004/02/skos/core#" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:temp="http://somewhere.org/modelvocab#" > 
 
  <skos:ConceptScheme rdf:about="http://example.org/myCombinedScheme"> 
    <dc:title>My example combined scheme</dc:title> 
    <dc:description>An example of a concept scheme built on two pre-existing
schemes.</dc:description> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c0345"/> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c2134"/> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c7956"/> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c5342"/> 
    <skos:hasTopConcept
rdf:resource="http://authority1.org/scheme/concept/c5473"/> 
    <owl:imports rdf:resource="http://authority1.org/scheme/"/> 
    <owl:imports rdf:resource="http://authority2.org/scheme/"/> 
    <temp:loadModel> 
      <temp:Model> 
        <rdfs:comment>A model containing statements linking the two imported
schemes, and some extra concepts of my own.</rdfs:comment> 
        <temp:loadFrom
rdf:resource="http://example.org/myCombinedScheme/additions.rdf"/> 
      </temp:Model> 
    </temp:loadModel> 
    <temp:excludeModel> 
      <temp:Model> 
        <rdfs:comment>A model containing the statements from the imported
schemes that I want to be removed from my combined scheme.</rdfs:comment> 
        <temp:loadFrom
rdf:resource="http://example.org/myCombinedScheme/exclusions.rdf"/> 
      </temp:Model> 
    </temp:excludeModel> 
  </skos:ConceptScheme> 
 
</rdf:RDF> 

Now there may be a much better way of expressing this with an RDF
vocabulary, but it's the principle I want to get across. 

The other set operation is an intersection but I can't imagine any really
important use scenarios for that yet. 

So an important question is, if we are interested in describing set
operations on RDF models, can we use the OWL set operation vocabulary to do
it, or do we have to make up a new one? 

So this could all be quite far out, but I hope stimulating  :)  



---
Alistair Miles
Research Associate
CCLRC - Rutherford Appleton Laboratory
Building R1 Room 1.60
Fermi Avenue
Chilton
Didcot
Oxfordshire OX11 0QX
United Kingdom
Email:        a.j.miles@rl.ac.uk
Tel: +44 (0)1235 445440

Received on Tuesday, 10 August 2004 14:12:31 UTC