Followed this intro youtube.com/playlist?list=PLea0WJq13cnAfCC0azrCyquCN_tPelJN1 to create the ontology. It is a little reduced http://prntscr.com/bo4l3w and I added canBeTutor (meaning somebody can become tutor for somebody) object property on my own. As far as I understand, I can add SWRL rules and then launch reasoner to create new knowledge. So I added prntscr.com/bo4lk7 . I started Hermit reasoner prntscr.com/bo4lqx . But obtained inconsistent ontologies warning prntscr.com/bo4lu0 . Clicked Explain button and got the following explanation http://prntscr.com/bo4lyg . My onto is here synoparser.ru/onto/protege.owl
1. Could you please tell what that mean?
2. Just for general understanding. I read that reasoner can create new knowledge. Does that mean just relations, or also individuals and classes?
3. Where can I find readoner added knowledge in Protege 5 ?
The explanation in one of the figures you provided explains the inconsistency. The ontology says that
the classes Student and Lecturer and disjoint (that is, that no individual can be both a Student and Lecturer)
the domain of studies is Student, which means that if x studies y, then x is a Student
the domain of firstname is Lecturer, which means that if x firstname y, then x is a Lecturer
Now, since Student1 has firstname Andrew, Student1 must be a Lecturer. Since Student1 studies cs101, then Student1 must be a Student. But Student and Lecturer are disjoint; no individual can be both. But Student1 is both. That's an inconsistency.
Related
In first place i have to apologize for my very, very poor english.
I've been studying the representation of knowledge in the context of design of experts systems trough ontologies. In particular, i've been using protégé as an OWL ontology editor.
After a large number of fails, finally i've started to realize the huge impact of the OWA on the process of inference and reasoning, mainly when i try to performance some automatic classification task.
I've solve many of the basic problems about that but, going deeper on the idea of making more and more specific classifications, i ran into the need for use cardinality restrictions. (which, at first, i tought that i cleary understand, but in the end, i realize that i'm nowhere close it)
Well, so far i've made a mess. Only a very few classification has been working as i spected. I guess that, as usual, i've been losing sight of the OWA.
Mi concrete doubt is this: What's the point on creating a restriction over an object property with a 'max' and, specially, 'exactly' cardinality in a context where we assume that the world is open?
I bring to you this simple example, based on the Pizza Tutorial, since many concepts can be extrapolated from there: Suppose that i want to define the class of pizzas named "FourChessePizza" and i want that, in principle, any individual that has four "ChesseTopping", i.e., four relationships along the "hasTopping" property with individuals of class "CheeseTopping", are inferred as belonging that class.
So i create an individual and, in "types", i assert this:
hasTopping some MozzarellaToping
hasTopping some ParmesanTopping
hasTopping some FontinaTopping
hasTopping some BlueChesseTopping
All the fillers are disjoints.
(The names of each chesse are merely demostrative; i don't know which cheeses are used)
So far, the reasoner have no way to say that that individual belongs to "FourChessePizza" since, although it has four relationships, the OWA considers the possibility that it can have more relations that might not have been "said". No 'max' or 'exactly' cardinality restriction can be applied since the uncertainty about "how much relations" really have the individual.
So, with only this information i can't found any restriction to my "FourCheesePizza" that clasify this simple individual as own.
Beyond this particular example, my question is more general about the generic process of "counting" asserted relationships with the less possible information.
¿Is there any solution to this kind of problems?¿What is what i'm not thinking in the rigth way to solve this and similar problems?
Thank you very much in advance for your time and your good will.
Cheers!
This is a surprisingly intricate problem! At first sight, it looks like what you need is simply a "closure axiom", something that is describe in the Protégé tutorial with the Pizza ontology. There, the concept of a Margherita pizza is at first described as a pizza that has some mozzarella topping and some tomato topping. But even if you know a pizza has mozzarella and tomato, it is not sufficient to classify it as a Margherita pizza, because other kinds of pizzas have mozzarella and tomato. So the solution is to say that a Margherita pizza only has mozarella and tomato toppings.
Similarly, it would be possible to say that your example pizza only has Mozzarella, Parmesan, Fontina, and Blue Cheese toppings. But would this be sufficient to qualify as a FourCheesePizza? Well, it depends how you define 4 cheese pizzas. If a FourCheesePizza is one that has at least 4 cheese toppings, then yes. But we don't want to have 5-cheese pizzas classified as 4-cheese pizzas, right?
A simple conceptualisation of 4-cheese pizzas would be that it has exactly 4 cheese toppings:
FourCheesePizza subClassOf hasTopping exactly 4 CheeseToppings
So, it means that for any instance of FourCheesePizza, there exists x1, x2, x3, x4 four distinct instances of CheeseTopping. The problem is, the four instances could be all distinct instances of MozzarellaTopping.
In the case of Hector Coscia's example, if we have:
FourCheesePizza subClassOf (
hasTopping some MozzarellaTopping and
hasTopping some ParmesanTopping and
hasTopping some FontinaTopping and
hasTopping some BlueChesseTopping and
hasTopping only (MozzarellaToping or ParmesanTopping or FontinaTopping or BlueChesseTopping)
then it is possible that there are 2 mozzarella toppings, 5 parmesan toppings, 16 fontina toppings, and 42 blue cheese toppings. And yet, this woud arguably be fine as a 4-cheese pizza because what matters is that it uses exactly 4 types of cheeses. But how to express that a pizza only has 4 types of toppings?
In OWL, it is not possible to restrict the number of classes used in a definition. For instance, it is not possible to say: the instances that are member of only 2 classes. Even if it was possible, it would be useless, because every instance X belongs to infinitely many classes: it belongs to the singleton class {X}, it belongs to every superclass of this singleton, and it belongs to the union of {X} with all the classes that are disjoint from {X}.
So the only option is to change the modelling pattern: to make TypeOfCheese a class, and to make Mozzarella, Parmesan, Fontina, Blue Cheese instances of this class. Then it is possible to restrict how many types of cheeses are used. To do so, you may proceed as follows:
create a property typeOfCheese that connects instances of CheeseTopping to instances of TypeOfCheese
create another propery usesTypeOfCheese that connects pizzas to types of cheeses
define a property chain axiom that says: hasTopping o typeOfCheese subPropertyOf usesTypeOfCheese
define FourCheesePizza as the subclass of usesTypeOfCheese exactly 4 TypeOfCheese
define the instances of TypeOfCheese: mozzarella, parmesan, fontina, blueCheese, cancoillotte, etc.
define MozzarellaTopping subClassOf typeOfCheese value mozzarella, ParmesanTopping subClassOf typeOfCheese value parmesan, etc.
I am currently working on a ontology.
I created a bunch of individuals (every individual should be sorted to a different optimization problem like TSP, VRP and VRPTW).
But I think the open world assumption creates some problems.
In Individuals I want the reasoner to realize that Auftrag 1 is a TSP, Auftrag 2 is a VRP and Auftrag 3 a VRPTW. At the moment it works
but only because for 1 and 2 I use the "exactly" cardinality in types.
I have to do this because if not the reasoner may think that there could be more than one of this kind (in this example warehouse or simpleVehicle).
Because of that I created this "exactly 1" cardinality on types so that the reasoner can only sort it right. But as soon as I am right the closure axiom could help me so to prevent the open world assumption at this point?
I hope you understand my point.
I attached the file, best regards!
File:
https://www2.zippyshare.com/v/loP7YJNP/file.html
I have an example of allocation Result below. I know how to read binary relationships but this triple box marked red in the image confuses me.
When and in what order do we read those roles after slashes inside the box : in, award of?
I assume that we can read this diagram in 3 ways:
First box Student has result of Grade for Unit.
Second box Grade givent to Student in Unit
Third box Unit grants to Student award of Grade (? this one has no sense ?)
Can we read it any more ways?
This is not really a valid ORM diagram (as defined by Halpin), because:
all the fact types lack a reading (entity type names are provided instead),
no uniqueness constraints are shown (every fact type must have at least one uniqueness constraint),
role predicates are shown inside the role boxes (not an ORM practise),
the ternary is not shown as objectified, even though it (and the other fact types) have entity names.
the identifying roles must be mandatory, but this is not shown.
Here, Result is the name of an entity type. This entity type objectifies the ternary fact type, for which no name and no reading are supplied. If you wanted to name the fact type, a suitable name might be "Grading", in reference to the action in which the Result was assigned. The same problem applies to the other fact types; the creator of this diagram is confused as to the difference between a fact type and the object which may objectify that fact type. For example, the fact type "Student identify" is a noun, but the fact type (if it is to be named) should be called "Student Identification", naming the action not the objectification. Similarly for Grade award (Grade Coding), Unit identity (Unit Naming).
However, leaving aside these syntax differences, the possible intended readings for the Result fact type are "Student achieved Grade for Unit", "Grade was awarded to Student for Unit", and the like. In CQL, the objectification is indicated by saying "each Result is where some Student achieved some Grade for some Unit, that Grade was awarded to that Student for that Unit"
The predicate text inside the roles of the Result fact type are not well defined. The intention here is to apply these predicates to the relationship between the Result entity and the object which plays each respective role. These three binary fact types (called Link Fact Types) are not shown, but are implied by the objectification. I would suggest the following readings for these link fact types:
Result is awarded to Student/Student received Result
Result is of Grade/Grade applies to Result
Result is awarded for Unit/Unit received Result
Normally the link fact types and the associated readings are not shown, and the implicit readings provided by the tools are "involved in/is of", for example "Student is involved in Result", "Result is of Student". You can see why it can be better to provide custom readings instead.
I recommend you get a copy of Terry Halpin's book "Information Modeling and Relational Databases" and learn from that, because it's clear that your instructor has non-standard theory and practises.
I am half way reading the OWL2 primer and is having problem understanding the universal quantification
The example given is
EquivalentClasses(
:HappyPerson
ObjectAllValuesFrom( :hasChild :HappyPerson )
)
It says somebody is a happy person exactly if all their children are happy persons. But what if John Doe has no children can he be an instance of HappyPerson? What about his parent?
I also find this part very confusing, it says:
Hence, by our above statement, every childless person would be qualified as happy.
but wouldn't it violate the ObjectAllValuesFrom() constructor?
I think the primer actually does quite a good job at explaining this, particularly the following:
Natural
language indicators for the usage of
universal quantification are words
like “only,” “exclusively,” or
“nothing but.”
To simplify this a bit further, consider the expression you've given:
HappyPerson ≡ ∀ hasChild . HappyPerson
This says that a HappyPerson is someone who only has children who are also HappyPerson (are also happy). Logically, this actually says nothing about the existence of instances of happy children. It simply serves as a universal constraint on any children that may exist (note that this includes any instances of HappyPerson that don't have any children).
Compare this to the existential quantifier, exists (∃):
HappyPerson ≡ ∃ hasChild . HappyPerson
This says that a HappyPerson is someone who has at least one child that is also a HappyPerson. In constrast to (∀), this expression actually implies the existence of a happy child for every instance of a HappyPerson.
The answer, albeit initially unintuitive, lies in the interpretation/semantics of the ObjectAllValuesFrom OWL construct in first-order logic (actually, Description Logic). Fundamentally, the ObjectAllValuesFrom construct relates to the logical universal quantifier (∀), and the ObjectSomeValuesFrom construct relates to the logical existential quantifier (∃).
I am facing the same kind of issue while reading the "OWL 2 Web Ontology Language Primer (Second Edition - 2012)" and I am not convinced that the answer by Sharky clarifies the issue.
At page 15, when introducing the universal quantifier ∀, the book states:
"Another property restriction, called universal quantification is used to describe a class of individuals for which all related individuals must be instances of a given class. We can use the following statement to indicate that somebody is a happy person exactly if all their children are happy persons."
[I omit the OWL statements in the different sintaxes, they can be found in the book.]
I think that a more formal and may be less ambiguos representation of what the author states is
(1) HappyPerson = {x | ∀y (x HasChild y → y ∈ HappyPerson)}
I hope every reader understands this notation, because I find the notation used in the answer less clear (or may be I am just not accustomed to it).
The book proceeds:
"... There is one particular misconception concerning the universal role restriction. As an example, consider the above happiness axiom. The intuitive reading suggests that in order to be happy, a person must have at least one happy child [my note: actually the definition states that every children should be happy, not just at least one, in order for his/her parents to be happy. This appears to be a lapsus of the author]. Yet, this is not the case: any individual that is not a “starting point” of the property hasChild is a class member of any class defined by universal quantification over hasChild. Hence, by our above statement, every childless person would be qualified as happy . ..."
That is, the author states that (assume '~' for logical NOT), given
(2) ChildessPerson = { x | ~∃y( x HasChild y)}
then (1) and the meaning of ∀ imply
(3) ChildessPerson ⊂ HappyPerson
This does not seem true to me.
If it were true then every child, as far as s/he is a childless person, is happy and so only some parents can be unhappy persons.
Consider this model:
Persons = {a,b,c}, HasChild = {(a,b)}, HappyPerson={a,b}
and c is unhappy (independently from the close world or open world assumption). It is a possible model, which falsifies the thesis of the author.
How would you assign objective certainties to statements asserted by different users in an ontology?
For example, consider User A asserts "Bob's hat is blue" while User B asserts "Bob's hat is red". How would you determine if:
User A and User B are referring to different people named Bob, and may or may not be correct.
Both users are referring to the same person, but User A is right and User B is mistaken (or vice versa).
Both users are referring to the same person, but User A is right and User B is lying (or vice versa).
Both users are referring to the same person, and both uses are either mistaken or lying.
The main difficulty I see is the ontology doesn't have any way to obtain first-hand data (e.g. it can't ask Bob what color his hat is).
I realize there's probably no entirely objective way to resolve this. Are there any heuristics that could be employed? Does this problem have a formal name?
I'm not an expert in this field, but I've worked a bit with uncertainties in ontologies and the Semantic Web. There are, of course, approaches to this problem that have nothing to do with the semantic web, but my knowledge ends there.
Two problems that I feel are connected with your question are the Identity Crisis and the URI crisis. Formal representations of the statements above can be issued in RDF (Resource Description Framework).
If I convert the statementss "Bob's hat is blue/red" into triples, this would be:
Fact 1:
X isA Person
X hasName "Bob"
X possesses H1
H1 isA Hat
H1 hasColor Blue
Fact 2:
Y isA Person
Y hasName "Bob"
Y possesses H2
H2 isA Hat
H2 hasColor Red
The problem here is that X, Y, H1 and H2 are resources, which may or may not be the same. So in your example it is unknown if X and Y are the same person or distinct and you can't know without further information. (Same holds for the hats.)
However, the problem is more complex, because User A and B just stated those things, so they are no "real" facts. RDF offer the method of Reification for this, but I won't write this down here completely, it would be too long. What you basically would do is add an "UserA statesThat (...)" to every above mentioned statement.
If you have all this, you can start reasoning. At the university we once used RACER for this kind of stuff, but that was an old version and I'm not familiar with the current one.
Of Course, you can do that stuff without RDF as well, e.g., in LISP.
Hope it helped.
I have heard this kind of thing being referred to as information fusion, mirroring the idea of data fusion. I don't know much about it but it seems there are conferences on the subject.
I'd also add another difficulty here, that of distinguishing between objective and subjective information. If user A says 'Bob is a nice guy' and user B says 'Bob is not a nice guy' then they can both be right while asserting seemingly opposing statements.
Step 1: Make some assumptions. Otherwise, you have nothing to base anything on. A possible assumption would be, "If bob's hat is red, there is a 90% that User A will say his hat is red."
Step 2: Apply relevant math. To relate a conditional probability to its inverse (i.e. to ask the probability that bob's hat is red knowing what A said based on the assumption I proposed), use Bayes Theorem.