How to distinguish in OWL properties describing the represented object from properties describing the representation?

Question

How to distinguish in OWL properties describing the represented object from properties describing the representation. Here's a small example:

:fgst1425 rdf:type :Building ,
                   owl:NamedIndividual ;

          rdfs:label "B28"@en ;

          :isWorkLocationOf :hugr9807 ; #this is a property of the building

          :hasURItype :ihuy8965 . #this is a property of the URI representing the building


:hugr9807 rdf:type :Person ,
                   owl:NamedIndividual ;

          rdfs:label "Ivo"@en .

:ihuy8965 rdf:type owl:NamedIndividual ,
                   owl:Thing ;

          rdfs:label "OpaqueURI"@en .

In a similar way, a property describing access, can mean access to the building and read access to the URI, representing the building.

The intention is to use reasoning both for the represented object and for the representation. If I have for example a person killed by an explosion, and this explosion is registered with an URI, I want to say that only persons satisfying specific criteria can have access to this URI, and with reasoners to find out who was illegal access, but avoid deductions of the sort that URIs kill people.

One possible solution I thought of was to put all meta-data properties under a :metaDataProperty and then with SPARQL queries the two different types of statements can be distinguished.

Another approach suggested was to use separate ontology for meta-data.

What would you advise?

Answer 1

How to distinguish in OWL properties describing the represented object from properties describing the representation.

That's a distinct that OWL doesn't make. Whoever made this ontology did some things that might be considered somewhat unusual. While

:hasURItype :ihuy8965 . #this is a property of the URI representing the 

building

might be "about the representation", as far as OWL is concerned, it's just another property of the building. After all, according to

:ihuy8965 rdf:type owl:NamedIndividual , owl:Thing ;

the value is just another named individual.

However, there's one thing that might be possible, depending on what the ontology designer did. OWL allows you to define three types of properties:

• object properties
• datatype properties
• annotation properties

The first two, object and datatype properties, are what are used by OWL reasoners, and are supposed to represent the actual meaning of the data. The third type, annotation properties are sort of "extra" data. An ontology designer might have defined :hasURItype as an annotation property to signify that its values aren't really needed for the reasoning; that is, that they're annotations to the "real" data. If that's the case, then you could do something like:

construct { ?s ?p ?o }
where {
  values ?s { :fgst1425 }
  ?s ?p ?o .
  filter not exists {
    ?p rdf:type owl:AnnotationProperty
  }
}

to exclude the properties that have been declared as annotation properties. We don't have enough of the data you're working with to know whether that approach will work here or not, though.

Update

Based on the update to the question, I think that you'd probably want to create a new annotation property that distinguishes whether properties are "representation properties" or not. E.g.,

:isRepresentationProperty a owl:AnnotationProperty

Then your property definitions can take this into account:

:isWorkLocationOf a owl:ObjectProperty .

:hasURItype a owl:ObjectProperty ;
            :isRepresentationProperty true .

Then you can update your SPARQL query to be:

construct { ?s ?p ?o }
where {
  values ?s { :fgst1425 }
  ?s ?p ?o .
  filter not exists {
    ?p :isRepresentationProperty true 
  }
}