hermit | A minimal & fast Hugo theme for bloggers | Theme library

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.

Reasoning support in Virtuoso Open Source (VOS) is detailed in the inferencing and reasoning documentation. Integration with other standard reasoners is not supported, although it probably could be implemented if there were sufficient demand for it.

Virtuoso 8+ commercial edition supports Magic Sets and Custom Inference Rules allowing custom inference rules to be created for most use case.

(Also asked and answered on the OpenLink Community Forum)

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

Running inferences over the model was the missing step. Therefore, I needed to use the InferredOntologyGenerator class.

One line of code speaks more than a thousand words:

The screenshot appears to show 8.4.3 Literal Value Restriction, see also OWL2 Quick Guide, Data Property Restrictions. Programmatically this looks like following:

The syntax a : b : c creates a sequence from a to c (inclusive if possible) using steps of b. Wrapping this further in brackets has no effect in this case, since a sequence is already a matrix (i.e. it is true that a:b:c is equivalent to [a:b:c] ). Therefore

I think there are 3 issues here.

(1) Stating Animal1 SubClassOf eats some Animal2 merely states that there is a subset of individuals of the Animal1 set that eats at least 1 individual that belongs to the set of Animal2. At most you can infer that some individuals of Animal2 are eaten by Animal1. That is that isEatenBy some Animal1 SubClassOf Animal2. In (3) I will explain why you do not get this inference.

Most importantly it cannot infer that all individuals of Animal2 are eaten by Animal1, which is what is needed to infer Animal2 SubClassOf isEatenBy some Animal1.

(2) Inverse roles make claims about individuals. Hence, when you have a statement about specific individuals like eats(animal1, animal2) where animal1 and animal2 are individuals, the reasoner will infer that animal2 isEatenBy animal1.

(3) A class like isEatenBy some Animal1 is sometimes referred to as an anonymous class while classes like Animal, Animal1 and Animal2 are referred to as named classes. Because in general the number of inferences that can be made from a set of axioms is infinite, reasoners restrict their inferences to named classes.

As an example, for your eats property you can define the domain as Animal1 and the range as Animal2. This means that whenever you have eats(x, y), individuals x will be inferred to be of type Animal1 and individual y will be inferred to be of type Animal2.

To now also get an inference that is the equivalent is isEatenBy some Animal1 SubClassOf Animal2, you need to introduce a new class, say AnimalsThatAreEatenByAnimal1 that is equivalent to isEatenBy some Animal1. The reasoner will now infer that AnimalsThatAreEatenByAnimal1 is a subclass of Animal2.

In general, to understand the inferences that a reasoner can make, it crucial to understand the semantics of the axioms you define. For this you can look at the direct semantics. For an introduction on the logic, see An Introduction to Description Logics.

From

you're using pointer equality instead of object equality?