[MUD-Dev] OpenCyc, design implications of ontological systems?

[Bruce Mitchener]

Hello all,

Something that I've been interested in for a while are ontological
systems (from the AI, not philosophical perspective):

   http://agora.cubik.org/wiki/view/Main/OntologicalSystems

Today (finally!), OpenCyc had their first beta release (for Linux
only at this point, but Windows by 1.0):

   http://www.opencyc.org/
   http://www.sf.net/projects/opencyc/

Some explanation though ...

     An ontology is a specification of what exists within a system
     and what is true about those things.

According to the Stanford Knowledge Systems Laboratory [1]:

     "An ontology is an explicit specification of some topic.  For
     our purposes, it is a formal and declarative representation
     which includes the vocabulary (or names) for referring to the
     terms in that subject area and the logical statements that
     describe what the terms are, how they are related to each
     other, and how they can or cannot be related to each
     other. Ontologies therefore provide a vocabulary for
     representing and communicating knowledge about some topic and a
     set of relationships that hold among the terms in that
     vocabulary."

Some further explanation can be found at:

   http://www-ksl.stanford.edu/kst/what-is-an-ontology.html

You could view the item hierarchy (if you have one) of a mud as the
start of an ontology in a primitive form.  Those who have read _Game
Architecture and Design_ by Rollings and Morris may be familiar with
their discussion of the tokenization of a game design (Chapter 17 I
think).  That's also like an ontology.

Something that I've noticed when working on The Eternal City and
some other projects is that a lot of what I'm writing is something
that I think I should be able to just write as a couple of logic
statements and let the system handle it.

Instead of having to spread rules out into the code, and modify the
Ostrich object to prevent it from being able to fly, I could state
it as a rule, with [Rule1] corresponding to the rule that states
that birds are able to fly:

   (#$exceptWhen (#$isa ?BIRD #$Ostrich) [Rule1])

or, in English:

     Birds can fly, except when the bird is an ostrich.

And, from that, rather than checking all of those rules at runtime,
have the ontological system output a body of code that implements
the ruleset, including the correct inheritance relations and any
properties and methods that are necessary.

There's some research being done in that direction by Kris De
Volder:

   http://www.cs.ubc.ca/people/profiles/kdvolder.html

     "My main research interests are in the area of
     programming-language design. I am mostly working on applying
     logic meta programming to programs written in procedural and
     object-oriented programming languages, mainly for the purpose
     of achieving higher degrees of genericity and better separation
     of concerns through code generation.

     "From the work I have done on this, I believe it is a very
     powerful and interesting combination of programming paradigms
     which complement each other in many ways. It allows a very high
     degree of abstraction and genericity in program code in
     comparison to 'plain' procedural or object-oriented
     programming. The biggest challenge in this research is to make
     it not just powerful, but also easy and natural to use in day
     to day programming."

In writing complex systems with a lot of interactions between the
components, consistency is much more difficult, especially when the
implementation of the logic is scattered throughout the
source. Centralizing the logic and providing a simpler, more
straightforward way to edit that logic, and with the addition of
tools to validate the logical structure, would make the construction
of the more complex interactions simpler and (hopefully) more
consistent.

Another possible advantage to that sort of set up is that it might
allow for any AI that you have to have a straightforward way of
querying the knowledge base (ontology) to use that information (that
also defines the nature of the game world) in making decisions.

Has anyone gone down this path or been looking into similar things?

  - Bruce

1. 
http://www-ksl-svc.stanford.edu:5915/doc/frame-editor/what-is-an-ontology.html

_______________________________________________
MUD-Dev mailing list
MUD-Dev at kanga.nu
https://www.kanga.nu/lists/listinfo/mud-dev