RDFS | RDFS : an erasure code based cloud storage system | Cloud Storage library

SPARQL Query semantics specify how portions of the query are joined together. Your sub-query does not project any common variables that are shared with the outer query. It only SELECTs the ?allOwners variable which does not appear in the rest of the query.

This means that you get a cross product of all the counts and all your other results; this is why you get duplicate rows and no correlations between the counts and rows.

This kind of query can be achieved if you structure it correctly. Since you haven't provided example results you desire, I'm having to make a best guess of what you want. Something like the following may have the desired results:

You have this structure

This query seems to work quite well for me: Edited answer:

The answer I found was that the heap size was constantly overflowing. Adding the line:

Your syntax is wrong I'm afraid. For this type of query, you will need a filter, like:

In your first snippet, it is clear that the intersection must be an OWL class because it is an intersection of OWL classes. Therefore, :CClass must also be an OWL class. However, this implies some reasoning based on how terms are defined. An OWL parser does not have to apply reasoning and should be directed explicitly to whether a term is an OWL class, an object property, a datatype property, an individual, an ontology, an annotation property, a datatype or some other kind of annotation. In the case of an owl:intersectionOf axiom, it is possible that you are declaring a datatype, rather than an OWL class. So it is only by looking at the content of the list, and finding how the terms inside are declared (viz., :AClass and :BClass), that you can eventually infer that they are all OWL classes, and therefore the intersection is an OWL class, and therefore it is equivalent to an OWL class, and therefore :CClass should or could appear as an OWL class in the editor. OWL tools are free to make this kind of inferences for the sake of robustness, but it is not mandated by the OWL standard.

Edit for clarification: the standard defines a way to map RDF graphs to the abstract syntax of OWL where the constructs that use owl:intersectionOf can be mapped to either a class definition or a datatype definition. The only way the standard recommends to discriminate the two cases is by adding explicitly rdf:type owl:Class or rdf:type rdfs:Datatype (see Tables 12 and 13 of OWL 2 Web Ontology Language Mapping to RDF Graphs). OWL parsers may go beyond what the standard recommends and infer some types based on the context, but they do not have to do it. I know that the OWL API does some such syntactic inferences to avoid crashing on every invalid ontologies.

OWL semantics is defined under open-world assumption, so you can't check if the cardinality for a certain property is exactly N, because there may be other property instances even if not declared.

More precisely, these are the checks that you can do:

You can check if a cardinality is exactly 1 only if you explicitly state that "value1" is the only value for :Ind1. In this case :Ind1 will be part of :Class1.

In FOL:

∀x.(R(Ind1, x) → x = "value1")

In DL:

∃R⁻.{Ind1} ⊑ {"value1"}

In OWL2 (not tested):

The final query:

I think you are misusing OPTIONAL here. Instead you should be looking at UNION. What's the difference?