I'm new in "ontology world". I've been practicing Protegé and ontologies for 2 months and now I would like to understand (and if it is possible to create) a reasoner. But I don't know what is its structure, the language used by it and so on.
Can you please me provide me a piece of information and something to read? Thank you.
The task of a reasoner is to produce inferences. Standard reasoning tasks are consistency check, realization, instance check and satisfiability. You can find all these defined in a number of books and articles about description logic.
Protege uses the OWL API to interface to reasoners so they are implementations of OWLReasoner. Not all of them are written in Java (e.g., FaCT++ is written in C++).
They are quite complex systems, so describing how to implement one takes chapters - too big for an answer here.
I'd recommend exploring the source code of a few of them. Open Source ones, off the top of my head: HermiT, FaCT++, Pellet, JFact, ELK.
Related
could you please explain the difference between interface and API?
I was looking for this information here and using google but I only find a special information for Oracle.
What I'm looking for is the general difference.
Much appreciated!
Update:
thank you all for the answers. My question was kept deliberately general because I
1) do not have the detailed information about the used programming languages (question based on a short information about one vendor's implementation in my project);
2) I wanted to understand the general high-level difference between the both terms.
Without further context, your question is a bit broad; but lets try; by looking up the definition of API on wikipedia:
In computer programming, an application programming interface (API) is a set of subroutine definitions, protocols, and tools for building software and applications.
Then: API stands for application programming interface; indicating that well, an API contains all elements (plural!) required to create an application which wants to interact with the component behind that API.
Whereas an interface in its stricter sense typically denotes a "single specific entity"; like the List interface in java describes an ordered collection (without providing details about specific implementation).
But of course, there are certain commonalities - both terms are about the description of the "boundary" of a "system". Long story short: there is simply no sharp, precise separation between those two concepts. Thus, when using those words within a group of people, you might want to first "step back" and discuss terminology - to ensure that all people involved have the same understanding of such terms. Or as DDD puts it: you want to create a Ubiquitous Language in which such terms have a clear, well defined meaning.
Finally: it is also worth mentioning that the term interface has different meanings when using different programming languages. In Java, an interface is really a concept embodied within the language core; where as in C++, an "interface" would probably be seen as the content of a single header file; leading to subtle but important "flavors" of "interface" for those two languages.
Edit:
Both, interface and API should not expose (too much?!) of the internals to the outside world.
Generally speaking, an API outlines a "component" (a complete "application" for example); whereas an interface might outline a "smaller" entity".
For your other refinement, about one company providing the API, and another the interface - I cant say anything. Because; as others have explained too: the definitions for those terms are really to unclear/fuzzy. We would need to know much more about the application and its requirements to even comment on your statement here.
The question "what is the difference between X and Y" is only meaningful when X and Y have single meanings and strict definitions. But "interface" and "API" do not have either single meanings nor strict definitions, so one cannot tell what is the difference between them.
For the most part, there is no difference, but there exist certain contexts where one would be suitable to use, while the other would be less suitable, or even unsuitable.
So, for example, a class implements an interface, never an API. On the other hand, an entire software system is more likely to be said to expose APIs rather than interfaces, though to say interfaces in this case would not be wrong either.
I wish there was some easy distinction, like "interfaces are small-scale, APIs are large-scale", or "interfaces are more specific, APIs are more nebulous", but there is no such distinction.
I have found some promising (old) articles but the trail has run cold.
Ideally I am looking for working plugins/code, but if they are simply not available, then any concrete directions on how to build probabilistic and/or defeasible reasoning for integration into Protege would still be useful.
RaMP Defeasible Reasoning plugin for Protege. Appears to be dormant/abandoned. Perhaps project/code was lost along with http://code.google.com/p/nomor/
PR-OWL http://www.pr-owl.org/. Extends OWL to support probabilistic ontologies. Appears to be dormant/abandoned.
Defeasible RuleML looked interesting, but I cannot find any concrete implementations/plugins/code. http://ruleml.org/1.0/defeasible/defeasible.html.
Defeasible Logic RuleML-compatible Rule
Language. Even if code can be found, this implementation looks experimental, and does not leverage more recent standards and formats. Paper: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.103.5914&rep=rep1&type=pdf Resources: http://lpis.csd.auth.gr/systems/resources.html#drdchairruleml2010
There's Pronto (available here), which is built on top of Pellet. I cannot recall if it comes as a Protege plugin, but as it is tied to Pellet I imagine it shouldn't be too hard to implement an OWLReasoner wrapper for the two.
What is the formal and complete definition of the words "meta-logic" and "object-logic" in Isabelle? I see people keep using these but could not find any definition for these.
You don't find them because they are specific to Isabelle (as far as I know). "Object-logic" and "meta-logic" are terms introduced by Larry Paulson (as far as I can tell). In general, though not specifically, they are related to the general terms "metalanguage" and "object language", for disciplines like logic and set theory. Do a search on those and you'll get the standard wiki pages, because they're a standard part of logic.
Here, I'm looking at page 16, 2.2.3 Meta and object language of Logic and Computation - Interactive Proof with Cambridge LCF, by Larry Paulson, published 1987. At that time he was still conforming to standard terms, but then he switched. I forgot where I read it, but he made the switch somewhere to "meta-logic" and "object-logic", to clarify things for his own purpose. The two terms are in his papers and in the Isabelle distribution docs.
Others can give you their expert knowledge, but the meta-logic specifically is what you get when you import the theory Pure, in particular, a minimal set of logical connectives, ==>, \<And>, &&&, and ==. Discussion of these are spread throughout the Isabelle distribution documentation.
I know nothing much about intuitionistic logic, other than it doesn't provide the law of excluded middle, but you will read that they provide a minimal, intuitionistic logic.
Don't thank me. I've just read some things here and there, and listened. Others can provide expert knowledge.
My findings with regard this question are below.
I found in the Clemens Ballarin slides, slide 20.:
Meta logic: The logic used to formalize another logic.
Example: Mathematics used to formalize derivations in formal logic.
and it is put in parallel with:
Meta language: The language used to talk about another language.
Examples: German in a Spanish class, English in an English class.
Wikipedia has an entry on Metalogic, one section is Metalanguage - Object language:
In metalogic, formal languages are sometimes called object languages.
The language used to make statements about an object language is
called a metalanguage. This distinction is a key difference between
logic and metalogic. While logic deals with proofs in a formal system,
expressed in some formal language, metalogic deals with proofs about a
formal system which are expressed in a metalanguage about some object
language.
And here is slide 21 from Ballarin:
I'm working on an OWL ontology and I need some specific issues
I only need ontology schema (TBox) and I got lost, what are the operations that can be
completed using reasoning and sparql and OWL API?
More specifically, I need the following:
1- check cardinalities between classes and properties.
2- find subsumption relationships for a specific class.
3- check whether specific facts hold (e.g. are two classes are disjoint)
4- find the paths (a class-property series) between a set of classes.
What each of reasoning, sparql and OWL API used for? and which one is suitable for my situation?
Actually I don't know how to start and what technique to use.
In addition. Would you please refer me to some reference?
Thanks.
Number 1 is not clear: do you want to know which cardinality axioms are asserted? This can be done without a reasoner. Number 4 is a bit vague as well, can you provide an example?
2, 3 and 5 require a reasoner to be perform accurately.
A reasoner is a program that will explicit implicit information: subsumption, realisation, consistency checks are all operations for which a reasoner is needed. In your tasks, subsumption is clearly needed.
OWLAPI is a Java API to manipulate OWL ontologies; in your case, it could be useful to write the connecting code to use a reasoner for your tasks. Compatible reasoners are Pellet, HermiT, FaCT++, and a few more.
SPARQL is an RDF query language. OWLAPI does not support it. You could use it for your tasks, but they look more OWL oriented than RDF oriented to me. Jena is a Java library supporting RDF, OWL, SPARQL and interfaces with reasoners such as Pellet. Depending on how you decide to solve the above tasks, it might fit more of your requirements than the OWLAPI.
Jena tutorials:
https://jena.apache.org/tutorials/index.html
OWLAPI documentation:
https://github.com/owlcs/owlapi/wiki/Documentation
Although i have a little bit of experience in developing dynamic websites using ASP technologies, but I am new to semantic web programming, and i intend to implement a website based on semantic web technology.I would like to develop a search engine, where a web user can query for keywords from the backend RDF triple store.I want to implement the website using Java and JSP.I have following questions:
I am currently studying Jena framework and SPARQL to start with,but
i am not sure what other technologies i need to study in order to
implement the website.
What is the difference between RDF and OWL, I have gone through a
lot of web resources but i am still confused.As per my understanding
RDF and OWL both define relationship between concepts but OWL is
more rich in terms of defining relations.
What is meant by different OWL Vocabularies like FOAF, SIOC etc.Why
do we need these vocabularies?
What exactly is the purpose of Virtuso Open Link
Software(http://ods.openlinksw.com/dataspace/dav/wiki/Main/VirtJenaProvider)
Any help would be highly appreciated.
Thanks!
I would definitely like to be kept up to date of your progress. I'm not experienced with java or jsp. I wonder if this could be done in php? I know that some work has been done in python on this kind of thing.
There are some extensions to drupal that work with these semantic web technologies and Semantic Media Wiki is good too.
Check out this and the related links at the bottom. The difference between microformats and vocabularies can be difficult to understand but I think there is a difference, say between a vocabulary like FOAF and a microformat like hCard, hCalendar or hResume. Oh, the link:
http://en.wikipedia.org/wiki/FOAF_(software)
Anyway these related terms are included.
Thanks,
Bruce
http://futurewavedesigns.com
Re: your first question - why do you want to use RDF to implement a keyword search? Keyword search isn't semantic, and there are many established frameworks and APIs for keyword search, such as Lucene.
Re: your second question, comparing RDF and OWL is comparing apples and oranges. RDF is basically for declaring data, but OWL is a layer on top of RDF that is for declaring ontologies (schemas). A more meaningful comparison would be between RDFS (RDF Schema) and OWL, which both address the ontology layer.
Example:
In RDF you might state that John Smith is a Person who hasAge "42" and is marriedTo Jill Smith.
In RDFS or OWL you would declare that Person is a class, hasAge is a property (with domain of Person and range of xsd:integer) and marriedTo is a property (with domain and range of Person).
In OWL you can also declare that marriedTo is a symmetric property (if A is marriedTo B, then B must be marriedTo A). RDF isn't this powerful, so you can't make this particular statement, so can't make inferences about symmetric properties etc.