rdfs | Distributed File Sync built in Ruby | Database library

try this

I think the first thing to be aware of is that equivalence, say D equivalentClass E, is an abbreviation for D subClassOf E and E subClassOf D. The semantics of subClassOf is subset. This means that the set D is a subset of set E and set E is a subset of D, which means set D and set E are exactly the same set. We say they are equivalent.

Note now the semantics of subClassOf. If I know F subClassOf E and G subClassOf E, what can I say about how F and G relates to each other? Absolutely nothing. It is a bit like knowing a bicycle and a truck are both vehicles. That does not make a bicycle a truck or a truck a bicycle, though both are vehicles.

Thus, in your example, A can be expanded to the 2 axioms

A subClassOf (a_to_b some B) and (a_to_c some C)

(a_to_b some B) and (a_to_c some C) subClassOf A

Answers to your questions:

(a) With the assertions for x as you have it, we can see that x is indeed an instance of A. However, there is no information wrt x that makes it possible for us to say x is of type A2. All we know is that both x and A2 are subclasses of (a_to_b some B) and (a_to_c some C).

(b) This is due to the Open World Assumption, which means the reasoner does not make any assumptions based on the absence of information. If you have not stated explicitly that y has no a_to_b relation to B, it will assume that an a_to_b relation exists but is merely not known. This is as opposed to the closed world assumption made by databases usually. I.e., if no employer information exists for a client the assumption is often made that the client is not employed.

You can state that y has no a_to_b relation by stating that a_to_b max 0 B. The reasoner will then give an inconsistency.

(c1) yes, but these may not be known currently due to the open world assumption.

(c2) yes, based on the semantics of equivalence

(c3) yes.

This is not true for A2 because it is merely a subclass rather than all things that have a relation a_to_b with an instance of B and have a relation a_to_C with an instance of C.

When to use equivalent vs subClassOf

Equivalence is used for definitions. That is when you want to state the necessary and sufficient conditions for something to be called an A (from your example).

SubClassOf is used when you want to define a hierarchy from most general to most specific. I.e., it is typically what you see in taxonomies and in programming you will see it as object oriented class hierarchies.

Per the useful comments above, it now works. I'm doing:

The main difference between RDFS and SKOS is outlined in the SKOS specs:

https://www.w3.org/TR/skos-reference/#L1045

The elements of the SKOS data model are classes and properties, and the structure and integrity of the data model is defined by the logical characteristics of, and interdependencies between, those classes and properties. This is perhaps one of the most powerful and yet potentially confusing aspects of SKOS, because SKOS can, in more advanced applications, also be used side-by-side with OWL to express and exchange knowledge about a domain. However, SKOS is not a formal knowledge representation language.

Not being a formal knowledge representation language, inferences are not standardised and there might be less interoperability with other knowledge bases.

I can't speak for dbpedia as to the reasons for the choice, but this seems a good enough reason to me, so I wouldn't be surprised if this was part of them.

I couldn't find anything from google but I find this on github : The answer

I followed his step by downloading the jar into my server/openllet and extracted the file so I could copy them in the new extra folder with all dependencies

Here is my Dockerfile :

So I did this.

First I converted your 2 elements into strings and put them into a list.

The dot serves two different purposes in jq:

• A dot on its own means "the current object". Let's call this the identity dot. It can only appear at the start of an expression or subexpression, for example at the very start, or after a binary operator like the | or + or and, or inside an opening parenthesis (.
• A dot followed by a string or an identifier means "retrieve the named field of the current object". Let's call this an indexing dot. Whatever is to the left of it needs to be a complete subexpression, for example a literal value, a parenthesised expression, a function call, etc. It can't appear in any of the places the identity dot can appear.

The thing to understand is that in the square bracket operators, the dot shown in the documentation is an identity dot - it's not actually part of the operator itself. The operator is just the square brackets and their contents, and it needs to be attached to another complete expression.

In general, both square bracket operators (e.g. ["foo"] or [] or [0] or [2:5]) and object identifier indexing operators (e.g. .foo or ."foo") can be appended to another expression. Only the object identifier indexing operators can appear "bare" with no expression on the left. Since the square bracket operators can't appear bare, you will typically see them in the documentation composed after an identity dot.

These are all equivalent:

Can't say it's less hideous, but yeah, it is possible to do this entirely in JQ.

The insert syntax is incorrect. You should use either insert data or insert {...} followed by where {} (with empty {}). I have not run the query, but it should be something like this: