This document is deprecated. Read Verbalizing OWL in ACE instead.

Verbalizing OWL in (controlled) English

1 Introduction

We describe how an ontology that is written in OWL RDF/XML is verbalized in Attempto Controlled English (ACE). This conversion is designed to be reversible, i.e. one can convert the ACE representation back into OWL RDF/XML so that no loss in meaning occurs.

Note that at the moment we do not support data properties. Also, very complex class descriptions that involve coordination are not supported. An example of such a complex description is e.g. (∃ p1 (∃ p2 C1)) ∩ (∃ p3 (∃ p4 C2)). Note also that only the logical content of the OWL file is verbalized, and not the information about annotations, versioning, import-structure, etc. Also, most of the URIs are truncated to preserve only the part that comes after the #-sign. As this can cause ambiguity in the names, some names are preserved as URIs.

2 Try it out!

Enter a URL of an OWL RDF/XML ontology:

Specify whether the output is plain ACE text (text/plain) or in an index-like format (text/html):

Plain ACE Indexed ACE text

Specify whether the imported ontologies should be verbalized as well:

Verbalize imports

... and press .

There is a 10-second timelimit. In case the ontology cannot be verbalized within this time-period, an error message is returned. This webservice is currently only for demo purposes, please do not use it to verbalize large ontologies.

3 How is the verbalization done?

We first rewrite the class descriptions and axioms via a limited number of more basic class descriptions and axioms. The motivation behind this step is to remove axioms like

ObjectPropertyDomain(R C)

which have very little syntactic structure and contain logic-specific words like `domain'.

The remaining class descriptions are mapped to ACE noun phrases and the remaining axioms to ACE sentences. OWL properties are ACE verbs and OWL individuals are ACE proper names. The following table shows an example how the OWL 2 constructs are mapped to ACE constructs.

Named property Transitive verb, e.g. like
InverseObjectProperty(R) Passive verb, e.g. is liked by
Named class Common noun, e.g. man
owl:Thing something, thing
ObjectComplementOf(C) something that is not a man; something that does not like a cat
ObjectIntersectionOf(C1 ... Cn) something that is a person and that owns a car
ObjectUnionOf(C1 ... Cn) something that is a wild-animal or that is a zoo-animal
ObjectOneOf(a) Propername, e.g. John
ObjectSomeValuesFrom(R C) something that loves a person
ObjectExistsSelf(R) something that likes itself
ObjectMinCardinality(n R C) something that is-friend-of at least 2 hackers
SubClassOf(C D) Every man is a human.
SubObjectPropertyOf(SubObjectPropertyChain(R1 ... Rn) S) Everything that owns something that is-part-of something X owns X.
DisjointObjectProperties(R S) Nothing that is-child-of something X is-spouse-of X.

Note that in the beginning of a sentence the complex noun phrases start with `Everything that' or `Nothing that'.

The next step is to make sure that we can verbalize more complex class descriptions which are built from the basic ones, e.g.

ObjectSomeValuesFrom(eat ObjectComplementOf(ice-cream))

ACE allows relative clause coordination and embedding of relative clauses into other relative clauses. This gives us quite a bit of flexibility, e.g. the above class description example would be verbalized as an ACE noun phrase

something that eats something that is not an ice-cream

Still, verbalizing very complex class descriptions would require a support for parentheses which ACE does not offer. We do not see it as a shortcoming, rather it is a natural restriction on the complexity of class expressions (which should be readable for others to understand).

Finally, we apply some simple modifications to make the sentences more readable, e.g. we try to remove negations and reorder the elements in coordination.

4 Examples

These example ontologies mostly originate from the Protege Ontology Library. Note that some ontologies import other ontologies. The ACE file is also "visualized" in HTML as an index: all names occurring in the ontology have been ordered alphabetically and each name is "explained" by listing all the sentences that contain the name.

pizza.owl ACE html
wine.owl ACE html
miniTambis.owl ACE html
amino-acid.owl ACE html
koala.owl ACE html
people+pets.owl ACE html
foaf.owl ACE html
patricide.owl ACE html

The quality of the verbalization depends somewhat on the morphologic and orthographic nature of the names used for individuals, classes and properties in the input ontology. The verbalization assumes that all individuals are denoted by singular propernames (preferably capitalized), classes by singular common nouns, and properties by transitive verbs in their lemma form (i.e. infinitive form). Examples of individual names are `John', `London'; examples of class names are `man', `carnivore'; examples of property names are `own', `drink', `look-at'.

Those restrictions are needed because the names will be used in certain syntactic constructions or will undergo certain morphological changes.

5 Implementation

The conversion is done in 3 steps.

  1. From OWL RDF/XML to OWL Abstract Syntax, by Thea — An OWL library for [SWI] Prolog
  2. From OWL Abstract Syntax to Attempto DRS, by a simple SWI-Prolog program
  3. From DRS to ACE, by a DRS verbalizer described in

6 Known restrictions of the implementation

Kaarel Kaljurand 2007-07-18