Frequently Asked Questions on the OWL Plugin

edited by Holger Knublauch, last update 19.08.2005

What is Protege?

Protege is an open-source ontology modeling and knowledge acquisition environment. There are many pages and publications about it on the web, so there's no need to repeat all this here. For the OWL community it is important to know that Protege is a very flexible and powerful platform which can be extended with additional components and editors. The OWL Plugin is such an extension, and as such it requires Protege to live in.

Working with Open Source software

Protege is an open-source project. This means that you basically get everything for free. This also means that the Protege developers rely on your feedback and contributions to improve the system. Many user around the world have successfully created applications on top of Protege. Some of these users have contributed parts of their work back to the community by means of Plugins. Feedback and plugins have helped us optimize the system and contribute to the continuous evolution of the system.

Working with evolving software

Protege is being further developed continuously. We are working on it almost permanently and will continue to do so for the foreseeable future. There will be frequent updates of the software so that you can benefit from the latest features and bug fixes. A new build of Protege typically made available once a week (on Fridays). Each version of both Protege and the OWL Plugin have a build number. It is important to use the correct Protege version with the correct OWL Plugin version. These are mentioned on the download page.

How to install Protege-OWL

Please download the Full version of Protege, and during the installation wizard select "Basic + OWL". This will install Protege, the OWL Plugin and selected other plugins that are suited for OWL. If your installation has been successful, then you should see the entries "OWL Files" and "OWL Database" in the listing of project formats at Protege's startup screen.

Is it a bug or a feature?

Protege-OWL is certainly not free of bugs. It is evolving so rapidly that from time to time new features break the behavior of existing functionality. We are doing our best to ensure the software's quality, especially through so-called unit tests. Unit tests are small Java programs that simulate certain use cases and report errors if unexpected situations have occured. I usually execute all of the several hundred unit tests before a new version is released. However, unit tests cannot cover all possible scenarios. Especially, it's very hard to write automatic tests for graphical user interface components. So these may be broken occasionally.

If you find a bug, please tell us. If you are not sure whether it's a bug or a feature, tell us as well. Bugs usually throw an error message (or exception), either by means of an error window or as an exception trace in the console window. Please try to locate this window - it is started together with Protege on your system and may be minimized by default. This may contain important error messages. If you report a bug, please send us the whole contents of the console window.

Where to send questions and report bugs

Protege has a very active user community, which basically comes to life by means of email-based discussion lists and Protege workshops and conferences once a year. For general questions about the Protege base system or non-OWL related topics, please send an email to protege-discussion@smi.stanford.edu. You need to be subscribed to this list before you can post. For questions concerning the OWL Plugin, please use the protege-owl@smi.stanford.edu list, which does not flood the inboxes of users that are mainly interested in Protege but not necessarily in OWL. By the way, we always try to answer all questions. There is no need to send questions twice or to multiple lists. Unless I really don't know the answer, I don't leave anything unanswered. If you want to contact me privately, please keep in mind that I am willing to help, but I prefer mails to the protege-owl list so that others can also read and respond. In some situations, you should contact me directly though, for example when you have an error report which requires to send large or confidential files. Anyway, before you send a message, please check whether a similar issue has already been reported by others in the discussion list archive.


Known Bugs

We maintain a list of known bugs on our Mantis Repository.


How can I load an OWL File?

With version 3.1, opening an OWL file is admittingly confusing. You actually need to create a new project, and then select "From Existing Sources". This will take you to the next wizard page where you can select an OWL file, either from the Web or from a remote location. We will optimize this in the future beta versions.

I cannot load a certain OWL or RDF file

If Protege-OWL fails to load a given .owl or .rdf file, then either the file is not in a well-formed state, or Protege has a bug. If you encounter an ontology that fails to load with Protege-OWL, then

  1. Run it through Manchester's OWL Validator with OWL DL mode. This may point you at some OWL Full constructs which may lay beyond the capabilities of Protege. Protege does support a large fraction of OWL Full, but not every arbitrary use or misuse of resources.
  2. Try to convert it with the OWL Syntax patcher and try to reload the result.
  3. If it still does not load, then post a question with a link to your ontology to the protege-owl list.

How can I work with multiple files and the import mechanism

A major cornerstone of the Semantic Web architecture is that ontologies can be split into multiple files and then used indepedently. Protege supports this notion of modularity, although it's not trivial to use. Here are guidelines on how to maintain and publish an ontology for the Semantic Web.

  1. Select and declare a unique default namespace for your project. This can be done on the Metadata tab, and should end with # such as in "http://protege.stanford.edu/plugins/owl/owl-library/import-demo.owl#". The default namespace should correspond to the official physical URL under which the file will be found later. Even if you don't plan to publish it, you should select a unique URL starting with "http://".
  2. If you want to import an existing ontology from the web, you should use the Metadata tab and add the namespace of the ontology to import.
  3. If you are actively working on the imported ontologies as well, and you want the system to do imports from the local file instead of the http address, you should NOT use local file URL's such as file:/c:/... to import them. Instead, use the so-called ont-policy file to specify an alternative entry for a remote file. The ont-policy file defines that whenever an ontology wants to import a certain remote ontology (http), then you can redirect the import to a local file. You can modify these settings in the Import Policy dialog from the OWL menu. For example, you could add "file:/c:/projects/owl/local-koala.owl" as an alternative entry for the remote file. Note that you should never directly import local files - always use the ont-policy trick. We have recently added a button to the Metadata tab that allows you to import local files that have an external http base namespace. This can be used as a convenient short cut.

A demo ontology for this import scenario can be found at http://protege.stanford.edu/plugins/owl/owl-library/import-demo.owl. Note that you can directly load ontologies from the web into Protege - you don't need to make a local copy first.

More information on this issue are available in the discussion list archive (search for OWL Import or so).

My OWL/RDF File looks strange and irregular

Many people examine the resulting OWL files produced by Protege/OWL and recognize that they look strange and irregular. In particular many people find the resulting difficult to parse back with an XML parser. It is important to note that Protege uses the Jena parser library to save files, and thus we have little impact on all the details of the output. This also means that however complex or irregular the OWL file looks, you can always use Jena to parse the file for your Java application. The reason why the files may look strange is that Jena does some optimizations to shorten the files, e.g. to remove duplicate links and to streamline parsing. You could try alternative output formats such as N3 or RDF/XML (without abbrev) and see whether you prefer them to the RDF/XML abbrev.

How can I execute a reasoner such as Racer?

If you want to exploit OWL's awesome reasoning capabilities such as consistency checking and classification, you can easily do this with Protege. All you need to do is download the Racer server (under Windows this is a simple .exe program that you need to execute with Protege) and then the classifier should only be a mouse click away. If you cannot connect to Racer, you may have some weird server settings (double check the OWL/Preferences), but usually it works right from the start.

Another source of confusion is the stuff of the OWL species. OWL ontologies can be in OWL Full, OWL DL or OWL lite. OWL Full basically means that an ontology could contain arbitrary OWL statements, i.e. anything could link to anything else in the ontology, etc. If your ontology uses some of the advanced features of OWL Full, especially metaclasses, then the classifier will reject the ontology and not classify it. In these cases you can use the Test Ontology button to get a list of OWL DL violations, which you can then try to remove. If this does not help, your ontology may import other ontologies, which are OWL Full.

Can I create numeric value restrictions such as "wheels with diameter over 10?"

OWL restrictions are optimized for cardinality expressions, i.e. you can easily say that a property must have at least 1 and at most 4 values. However, it is currently not possible to specify numeric range constraints such as "wheels with diameter over 10". An OWL working group is currently collaborating with the XML Schema group to allow for the definition of user-defined datatypes such as (integer greater than 10) which will then be used in allValuesFrom restrictions in OWL. As soon as this feature is standardized, the OWL Plugin will support it.

Update: The first 3.2 beta release of Protege will include support for user-defined XML Schema datatypes, albeit with a native solution first.

[Response from Bernard Vatant] OWL makes provision for logical 'qualitative' definition of classes, but definitely not for 'quantitative' definition, like "wheels with diameter over 10". This is not a bug, it's a feature :)) Cardinality is a logical feature, but numerical value of a DatatypeProperty is not one. There are arcane reasons for this dealing with structure of integers vs real numbers. There are some workarounds, though. You can define properties minDiameter and maxDiameter and define subclasses of Wheel by hasValue restrictions on those. But this will be only declarative - logical reasoners will not detect any inconsistency if you have set minDiameter to 10 for BigWheel class, and an instance of BigWheel has declared a diameterValue of 9.

How can I create properties with duplicates and/or ordered values (with rdf:Lists)

OWL/RDF property values are normally unsorted, i.e. the order of values for a property may be different the next time you load your ontology. Also, OWL/RDF does not allow to assign duplicates to property values. Trying to assign a duplicate value is usually prevented from the user interface. However, if the order of values or duplicates are important for you, you can use rdf:Lists. rdf:List is a predefined system class in RDF, and it is normally hidden in Protege. You can activate rdf:List in OWL/Preferences. Then you can change the range of your property to rdf:List and set "Functional" to true, so that the property can take exactly one rdf:List as value. Then, if you create an instance of a class where the property is used, you will get a RDFListWidget to create/add/remove/delete values for the property. This creates an rdf:List in the background.

An advanced scenario is illustrated in the OWL file http://protege.stanford.edu/plugins/owl/testdata/list-example.owl. You can import this into Protege to see how it looks. This defines a subclass of rdf:List in which the entries in the list are restricted to the class Person. While rdf:List would allow values of any owl:Thing, this solution restricts the list entries, similar to a range definition on the property.

I like the traditional Protege interface, but OWL looks completely different...

For those users who know the traditional Protege user interface (i.e. the CLIPS or RDF modes), the look and feel of the OWL Plugin may look like a shock. There are many new symbols and widgets on the screen, and some of the old features are moved or obscured. Sorry, but OWL is different. We tried to build an editor that does provide access to all the advanced OWL features such as logical class definitions and so on, and this means that the OWL Plugin has much more functionality than the other Protege backends. Also, the language paradigms are different. While Protege is traditionally rather object-oriented (frame-based) with classes and slots, OWL is based on Description Logics. As a result, the usual metaphor of building a class with its attributes is not directly applicable in OWL. Rather, you can use OWL to define classes by their logical characteristics and then get much more powerful reasoning support than any frame-based system could provide by default.

If you want to use OWL, but still want to use the traditional Protege UI, then you have many options:

  1. Work in one of the other Protege modes and only export your file into OWL when you want to export it. Using the Export to Format menu you could maintain two copies of your project. This means though that you cannot exploit the advanced OWL features, not even namespaces. Furthermore, you may run into the risk that you would use features that are not really supported by OWL, such as Abstract classes.
  2. Use the simple "Properties View" on the classes tab, instead of the "Logic View". This has a look and feel similar to conventional Protege.
  3. Modify the user interface to make it simpler. Protege can be used to adjust the forms that you see to create classes etc. For example, go to OWL/Preferences and activate the display of owl:Class. Then you can see the form of classes in the Forms tab, where you can easily replace or remove the widgets you don't like. For example, you could remove the conditions widget and the disjoint classes widget, and then make the properties at class widget bigger.
  4. Only use RDF(S) concepts in your project (see next question).

How can I edit RDF(S) files with the OWL Plugin?

OWL is an extension of RDF. Therefore, any RDF project can also be regarded as an OWL project which simply does not use the advanced OWL features. While the focus of the OWL Plugin is on OWL ontologies, it can also be used to edit RDF ontologies and RDF Schema files or databases. To activate this support, you should go to the OWL/Preferences dialog and activate an RDF profile. When RDF is activated, then the OWL Plugin will display additional buttons to create pure RDFS classes and RDF properties. In particular there will be a new button on the Properties tab, which can be used to create RDF properties. You can also decide whether new classes shall be RDFS classes or OWL classes using "Create class using metaclass", or you can make rdfs:Class the default metaclass (both with a right-click on the classes tree in the OWLClasses tab). If you create a new project, you can select an RDF profile in one of the wizard pages.

Note that we generally don't recommend mixing pure RDF(S) elements with OWL elements in OWL ontologies, but the OWL Plugin at least allows you to load, import and edit RDF if needed. This may be particularly important if your project needs to access ontologies or structured data that is only available as RDF(S).

Also note that this use of RDF is not necessarily compatible with the RDF Plugin for Protege. The RDF Plugin has been developed years ago and is only maintained since many users still need it. However, some of the design decisions then were made with an older version of RDFS. In those days, OWL was not defined yet, and thus some features had to be built differently than they could be built now. If you use the RDF Plugin, you should seriously consider moving to OWL, as this language provides much cleaner semantics and a much richer set of modeling elements.

 

 

HomeDocumentationDownloadOntologiesCommunity © 2006 Stanford Medical Informatics