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.
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.
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.
OWL | ACE |
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.
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.
OWL RDF/XML | ACE | Index |
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.
The conversion is done in 3 steps.