Cyc+Jamud This Site is Still under Heavy Construction |
|
Jamud Plugin: Integrates a Java MUD with an OpenCyc Server |
|
Jamud Tools
Proxy MudObject that stores and queries in OpenCyc
Complete readability of all Jamud primitive types into logical paradigms (To better export to KIF/CycL)
With Christopher, the OLC interfaces to JaMUD
Our mission is to increase number of ways to produce stylistic creations from the telnet
Persisted
Data Model
JaMUD is saved an loaded from an XML pages. This means at any time we can serialize the 'MOOState' context (Microtheory).
This is meant to be a solid context comprising of instances and sets. The other ontologies about understanding and using these can stored as well as hypothetical rooms and objects. They in could be called 'Exemplars' for example the Unicorn Pegasus is a mythological creature and could live cut off in in the 'Giant Room Of Mythological Creatures' and looks and save like an instance of Unicorn. But Pegasus' room may not be part of the relevant KB and therefore not effecting to the rest of the system. But how would we persist information that does not fit into a 4D space? For example these two rules:
(implies
(and
(isa ?PERSON Human)
(acquaintedWith ?OTHER ?PERSON))
(acquaintances ?PERSON ?OTHER SimpleContactAcquaintance))
(implies
(spouse ?X ?Y)
(friends ?X ?Y))
Each rule is kept in an instance of an Assertion. Physical Regions of the MOO may be effected by any 'Set' of instances from the Assertion Class. Assertions can be divided into Microtheories that can be believed by agents (or Mobs). The MOO reserves no special entity for enforcement of rules unless an agent has been assigned specifically to a room to do so. Most cases agents in the room are picking from there own private array of Assertions which is separate from an entity using the room's set.
+------------------------------------------------------------------------------+ _)\.-. .-.__,___,_.-=-. )\` a`\_ .-.__\__,__,__.-=-. `/ \ `\ {~,-~-,-~.-~,-,;;;;\ | '--;`)/ \-,~_-~_-,~-,(_(_(;\/ ,;/ ",-.~_,-~,-~,)_)_)'. ;;( W E L C O M E `~-,_-~,-~(_(_(_(_\ `;\ t o , `"~~--,)_)_)_)\_ \ J a M U D |\ (_(_/_(_, \ ; \ '-. _.--' /_/_/_) | | '--.\ .' /_/ | | )) / \ | /.' // /, | __.'| || // || /` ( || the java-based mud in || || .' \ \\ T E C H N I C O L O R || || .'_ \ \\ \\ // / _ `\ \ \\__ jgs '-'/( _ `\,; \ '--:, `"` `"` `-,,; `"`",,; +------------------------------------------------------------------------------+ Player Name:
Stage 1
Deliverable: A small lightweight installation and demo world.
Goal: To test and do practical Knowledge Engineering about a
virtual realm:
1) Build an existing simple realm inside of Jamud.
2) Create rules that interface to the realm Jamud mapping
existing object types into cyc Collections
a) Enumerate the possibilities and confirm the
ontology of how
things work or exist.
b) Map/Align to Cyc's ontology
c) Create a BroadMicrothery to reflect this
d) Create an import routine to build the world
into a
DataMicrotheory
3) Inference in Cyc about the DataMicrotheory and see how
many
commonsense rules we can make about our possible world.
4) Complete the interface for querying/asserting to OpenCyc
from
Jamud telnet interface.
5) Create synchronization: (choices)
a) Each time a subscribed event occurs in Jamud,
use the
existing OpenCyc Java API to update Cyc (current)
b) Make each object instance get/set methods
query/assert into
OpenCyc into a DataMicrotheory (could easily be
done)
c) Create HL interface predicates to query the
existing Jamud
objects into a DataMicrotheory (supported yet?)
Stage 2
Deliverable: Above with web interfaces to speed up the process below.
Goal: To animate non-player character agents from Cyc rules
1) Create an ontology of non-player character roles and jobs.
2) Leverage commonsense rules from stage 1 into rules about
how
to conduct actions
a) Create cyc queries (and the rules to satisfy)
that
consequent in a form of (actorStateAction ?Actor
?State
?ActionsToGetThere)
b) Map the agent categories into partitions of
background
commonsense required
c) Create a Microtheory system for single agents
based on
'knows about' and 'know how to' that can instance
individual's
current knowledge states.
3) Interface!
a) Create methods in Jamud that builds and
initializes a new
Cyc microtheories per agent.
b) genlMt the agent character ?Mt based on job
types for their
commonsense
c) Agent character enumerates his intrinsic goals
by making a
query to OpenCyc
d) Agent character per-tick initiates query about
its goal and
gets bindings back for his next action
e) Perform action inside Jamud and update states
4) Practice and refine knowledge engineering for stage 1 and
2
Stage 3
Deliverable: Expertly build rooms with objects based on rules. With
rules below, we should
be able to telnet into Jamud, enter a "damp
room" and find and take parts of mold.
(isa Mold FirstOrderCollection)
(isa Mold ExistingObjectType)
(isa Mold StuffType)
(forAll ?Rooms
(implies
(and
(isa ?Room Room)
(hasProperty ?Room Damp))
(thereExists ?Mold
(and
(isa ?Mold Mold)
(objectFoundInLocation ?Mold ?Room)))))
(forAll ?Action
(implies
(and
(isa
?Action TakingPartOfObject)
(occursAt
?Action ?Room)
(objectFoundInLocation
?Object ?Room)
(rolePart
?Action Actor ?Actor )
(rolePart
?Action Object ?Object)
(rolePart
?Action Region ?Room)
(isa
?Object StuffType))
(thereExists ?PartStuff
(and
(part ?Object ?PartStuff)
(objectControlledBy ?PartStuff ?Actor))))
1) Use the information from above stages to 'reflect back'
into
Jamud.
a) Find which state-action-state rules from stage
2 are
administrative tasks
b) Write a Microtheory that contains rules that
both antecede
and consequent in the DataMicrotheory like the
first of the
rules shown above.
c) create a robust colorful environment that may
go beyond
persisted Jamud
Practice running queries until the results make good sense
2) Interface
a) Jamud queries the DataMicrotheory (leveraging
the above
rules) and gets a map of the expected state.
b) Confirm that each object exists and has the
expected
properties in Jamud.
c) Make sure that the world transitions make
sense to players
in the MUD.
Stage 4
Goal: Apply virtual environments beyond this MUD/MOO/RPG
analogy.
1) Confirm the constancy, soundness and operational
completeness
of the above.
2) Create agents/objects in Jamud that will propagate/query
state to another application realm
3) Do knowledge engineering like the above for the new
application
4) Evaluate and improve tools used.
The project is realized into finite number of non-vague tasks and
diverse enough.
Supported configurations
LINUX (currently developed on Redhat 7.x)
JDK 1.4
Jakarta Tomcat 4.x
OpenCyc 0.6.0