Search Mailing List Archives


Limit search to: Subject & Body Subject Author
Sort by: Reverse Sort
Limit to: All This Week Last Week This Month Last Month
Select Date Range     through    

[protege-owl] Rules to modify/create ontologies from ontologies?

Johann Petrak johann.petrak at chello.at
Tue Oct 7 05:49:17 PDT 2008


Thank you for those pointers!

OPPL looks fairly high-level and it implements a way to
create and modify ontologies in an operation way.
However, it seems to have a limited way of selecting
the entities to modify and to create new facts from
existing ones.
If I understand LSW correctly, the selection of
existing facts and the creation of new facts has to be
done on the level of LISP functions (which I like
personally as I used to program in LISP a lot) and
hence, on a rather low, programming-language close
level.

Is anyone aware of any other high-level tools for
manipulating and creating ontologies from existing
ones, based on some high-level rule language?

I think many ontologies will be created or populated in an
automatic or semi-automatic way or derived from maybe
several existing ontologies in a (semi-)automatic way.
For such cases, wouldn't it be good to have something
that allows for a high-level description of conditions
or query/resonining results that can be associated with
consequents that actually carry out fact assertions
or operations on e.g. literar values?

I wonder who else has been hitting similar requirements
and whether there is some agreement on whether such a
tool (unless it already exists) would be feasable or
useful.

Regards,
   Johann

On 10/02/2008 12:10 PM, Alan Ruttenberg wrote:
> You might look at GONG - http://www.gong.manchester.ac.uk/
> 
> There is the OWL API, which can be used to read and write ontologies - 
> It's a java library. 
> http://owlapi.sourceforge.net/
> 
> I use a lisp based tool called LSW which is based JENA and Pellet to do 
> things like this - a combination of SPARQL queries and direct reasoner 
> queries, followed by construction of OWL statements based on it. 
> http://esw.w3.org/topic/LSW
> 
> As an example, see
> 
> http://obi.svn.sourceforge.net/viewvc/obi/trunk/src/tools/build/add-assumed-individuals.lisp?view=markup
> This file generates an anonymous individual that is an instance of each 
> class that has no subclasses.
> 
> http://obi.svn.sourceforge.net/viewvc/obi/trunk/src/tools/build/add-disjoints.lisp?view=markup
> This file creates disjoint class assertions based on OBI's policy.
> 
> Hope this helps,
> Regards,
> Alan
> 
> 
> 
> On Thu, Oct 2, 2008 at 5:14 AM, Johann Petrak <johann.petrak at chello.at 
> <mailto:johann.petrak at chello.at>> wrote:
> 
>     Since I got no answer yet I will broaden my question:
>     what ways exist to systematically change or merge
>     the knowledge in one or more ontologies into
>     a new ontology?
>     Is the only way to do this to hand-code it or
>     do tool or more formal, e.g. rule-based, approaches
>     exist?
>     I'd highly apreciate any feedback about this, even
>     if it is not a solution -- I'd also apreciate hearing
>     from people who face similar problems.
> 
>     Cheers,
>       Johann
> 
>     On 09/29/2008 04:24 PM, Johann Petrak wrote:
>      > I am wondering if there is some high-level, possibly rule-based
>      > way (as opposed to hacking it in Java or similar) to modify
>      > an ontology or create a new ontology from an existing one.
>      >
>      > Here is the background and motivation: I have a process that
>      > creates an ontology automatically and due to the sequential
>      > process and other factors, the created ontology has several
>      > problems that need to be fixed:
>      > - several individuals might turn out to be known to be different
>     or equal
>      > - properties might need processing and get split up or merged into
>      > other properties, or data properties might need to get converted
>      > into one or more object properties filled with individuals that
>      > need to created or modified.
>      > - one or more individuals might need to get converted into
>      > individuals of a different class (representing a different
>      > abstraction layer).
>      > - etc.
>      >
>      > For all these actions that would modify the ontology or
>      > create a new one there exists a domain theory that could
>      > be represented in a rule language where the rule head
>      > matches conditions in the original ontology and the
>      > rule body is a sequence of operations on property values
>      > and on the target ontology.
>      >
>      > Does anyone know about a way to (at least partly) achieve
>      > this or about people who work on similar things?
>      > Are there others who want to solve this or similar problems?
>      >
>      > And as usual: are you aware of other forums, mailing lists
>      > or places on the internet were questions like this one
>      > can be discussed?
>      >
>     _______________________________________________
>     protege-owl mailing list
>     protege-owl at lists.stanford.edu <mailto:protege-owl at lists.stanford.edu>
>     https://mailman.stanford.edu/mailman/listinfo/protege-owl
> 
>     Instructions for unsubscribing:
>     http://protege.stanford.edu/doc/faq.html#01a.03
> 
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> protege-owl mailing list
> protege-owl at lists.stanford.edu
> https://mailman.stanford.edu/mailman/listinfo/protege-owl
> 
> Instructions for unsubscribing: http://protege.stanford.edu/doc/faq.html#01a.03 



More information about the protege-owl mailing list