From: AAAI Technical Report WS-94-02. Compilation copyright © 1994, AAAI (www.aaai.org). All rights reserved.
Global Information Management
via Local AutonomousAgents
Michael N. Huhns, MunindarP. Singh, TomaszKsiezyk, and Nigel Jacobs
MCC
3500 West Balcones Center Drive
Austin, TX 78759-5398
(512) 338-3651 or huhns @mcc.com
Abstract
In this paper we describe howa set of autonomouscomputational agents can cooperate
in providing coherent managementof information in environments where there are
manydiverse information resources. Theagents use modelsof themselves and of the resources that are local to them. Resourcemodelsmaybe the schemasof databases, frame
systems of knowledgebases, or process models of business operations. Modelsenable
the agents and resources to use the appr0~:iate semantics whenthey interoperate. This
is accomplishedby specifying the semantics’ in terms of a common
ontology. Wediscuss
the contents of the models, wherethey comefrom, and howthe agents acquire them. We
then describe a set of agents for telecommunicationservice provisioning and showhow
the agents use such modelsto cooperate. Their interactions produce an implementation
of relaxed transaction processing.
1 Introduction
Business operations, including sales, marketing, manufacturing, and design, can no
longer be donein isolation, but mustbe donein a global context, i.e., as part of an enterprise. Acharacteristic of such enterprises is that their informationsystemsare large and
complex,and the information is in a variet~"6f forms, locations, and computers.Thetopologyof these systemsis dynamicand their content is changingso rapidly that it is difficult for a user or an application programto obtain correct information, or for the
enterprise to maintain consistent information.
Someof the techniques for dealing with the size and complexityof these enterprise informationsystemsare modularity,distribution, abstraction, and intelligence, i.e., being
smarter about howyou seek and modify information. Combiningthese techniques implies the use of intelligent, distributed modules---adistributed artificial intelligence approach. In accord with this approach, we distribute and embedcomputational agents
- 120-
throughout an enterprise. The agents are knowledgeableabout information resources
that are local to them, and cooperateto provide global access to, and better management
of, the information. For the practical reason that the systems are too large and dynamic
(i.e., open) for global solutions to be formulatedand implemented,the agents needto execute autonomouslyand be developed independently. To cooperate effectively, the
agents must either have modelsof each other and of the available information resources
or provide modelsof themselves. Wefocus on the latter in this paper.
For such an open information environment,the questions arise: what should be modeled,
where do modelscomefrom, what are their constituents, and howshould they be used?
Wediscuss the types of modelsthat might be available in an enterprise and howagents
can acquire them. Weuse the ontology developed for the large knowledge-basedsystem,
Cyc, for semantic grounding of the models. This provides a commonontology. Wethen
describe a set of agents for telecommunication service provisioning--a scheduling
agent, a schedule-repairing agent, a schedule-processingagent, and an interface agentm
and describe their modelsand howthey use them to cooperate. Wealso describe the use
of actors [Agha 1986]----one per agent--who manage communications among the
agents. Each actor independently maintains the relationship betweenits agent and the
common
ontology (in the form of articul~i~i0n axioms), and updates that relationship
the ontologychangesor the agent itself evolves.
2 Modeling
Enterprise information modelingis a corporate activity that producesthe modelsneeded
for interoperability. Theresultant modelsshould describe all aspects of a business environment, including
¯ databases
¯ database applications
¯ software repositories
¯ part description repositories :.
.~.~
¯ expert systems, knowledgebases, and computational agents
¯ business workflows, and the information they create, use, maintain, and own,
and
¯ the businessorganizationitself.
The modelsprovide online documentationfor the concepts they describe. They enable
- 121-
application codeand data to be reused, data to be analyzedfor consistency, databases to be
constructed automatically, the impactof changeon an enterprise to be assessed, and applications to be generated automatically.
Anenterprise might have manymodelsavailable, each describing a portion of the enterprise and each constructed independently. For example,
¯ the information present in a database is modeledby the schemafor the database,
whichis producedthrough a process of logical data modeling
¯ the data values present in a database are modeled(weakly,in mostcases) by data
dictionary information, whichis producedthrough data engineering
¯ the information present in an object-centered knowledgebase is modeledby the
ontology of the objects, which is producedthrough ontological engineering
¯ process models,possibly in the form of Petri nets or IDEFxdescriptions, are produced through logical process modeling
¯ STEP(Standard for the Exchangeof Product modeldata) schemas, written in Express, are produced from componentand physical process modeling.
Althoughit might appear that interoper~i~ility wouldrequire all of these modelsto be
mergedinto a single, homogeneous,
globalmodel,this is not the case in our approach. Instead, there are goodreasons for retaining the manyindividual models: 1) they are easier
to construct than a single large model; 2) enterprises maybe formeddynamicallythrough
mergers, acquisitions, and strategic alliances, and the resultant enterprises mighthave inherited manyexisting models;3) becauseenterprises are geographicallydispersed, their resources are typically decentralized; and 4) as enterprises (and thus models)evolve, it
easier to maintain smaller models.
Unfortunately, the models are often mutually incompatible in syntax and semantics, not
only due to the different things being modeled,but also due to mismatchesin underlying
hardwareand operating systems, in data structures, and in corporate usage. In attempting
to modelsomeportion of the real world, in]~ormationmodelsnecessarily introduce simplifications and inaccuracies that result in semanticincompatibilities. However,the individual
modelsmustbe related to each other and their incompatibilities resolved [Sheth and Larson
1990], because
¯ Acoherent picture of the enterprise is neededto enable decision makersto operate the business efficiently and designers to evaluate information flows to and
from their particular application.
¯ Applicationsneedto interoperate correctly across a global enterprise. This is especiaUyimportant due to the increasing prevalence of strategic business applications that require intercorporate linkage, e.g., linking buyers with suppliers, or
intracorporate integration, e.g., producingcompositeinformation from engineering and manufacturingviews of a product.
¯ Developersrequire integrity validation of newand updated models, which must
be done in a global context.
¯ Developerswant to detect and remove
inconsistencies, not only amongmodels,
:; ~.~
but also amongthe underlying business operations that are modeled.
Weutilize a mediating mechanismbased on an existing common
ontology to yield the appearance and effect of semantic homogeneityamongexisting models. The mechanismprovides logical connectivity amonginformation resources via a semantic service layer that
automatesthe maintenanceof data integrity and provides an enterprise-wide view of all the
information resources, thus enabling themto be used coherently. This logical layer is implementedas a networkof interacting agents. Significantly, the individual systems retain
their autonomy.This is a fundamentaltenet of the Carnotarchitecture [Woelket al. 1992],
whichprovides the tools and infrastructure for interoperability across global enterprises.
3 Semantic Integration via a Common
Ontology
0,
In order for agents to interact productively, they musthave somethingin common,
i.e., they
must be either groundedin the sameenvironmentor able to relate their individual environments. Weuse an existing commoncontext--the Cyc common-sense knowledge base
[Lenat and Guha1990]--to provide semantic grounding. The models of agents and resources are comparedand mappedto Cyc but not to each other, makinginteroperation easier to attain. For n models, only n mappingsare needed, instead of as manyas n(n-1)
mappingswhenthe modelsare related pairwise. Currently, Cyc is the best choice for a
common
context, becauseof 1) its rich set of abstractions, whichease the process of representing predefined groupings of concepts, 2) its knowledgerepresentation mechanisms,
whichare needed to construct, represent, and maintain a common
context, and 3) its size:
it covers a large portion of the real world ~nd the subject matter of most information resources.
: :.
The large size and broad coverage of Cyc’s knowledgeenable it to serve as a fixed-point
for representing not only the semantics of various information modelingformalisms, but
also the semantics of the domainsbeing modeled.Carnot can use modelsconstructed using
any of several popular formalisms, such as
- 123-
¯ IRDS, IBM’sAD/Cycle,or Bellcore’s CLDM
for entity-relationship
models
¯ Ingres, Oracle, Sybase, Objectivity, or Itasca for database schemas,and
¯ MCC’sRADor NASA’sCLIPS for agent models.
Cyc’s knowledgeabout metamodelsfor these formalisms and the relationships amongthem
enables transactions to interoperate semantically between, for example,relational and object-oriented databases.
The relationship between a domainconcept from a local model and one or moreconcepts
in the common
context is expressed as an ~iculation axiom [Guha 1990]: a statement of
equivalence between componentsof two theories. Each axiom has the form
ist ( G, tp) ¢:~ist ( Ci,
where¢p and ~ are logical expressionsand ist is a predicate that means"is true in the context." This axiomsays that the meaningof ¢p in the common
context G is the sameas that
of ~ in the local context Ci. Modelsare then related to each other----or translated between
formalisms--via this common
context by meansof the articulation axioms, as illustrated
in Figure 1. For example, an application’s query about Automobilewouldresult in subqueries to DB1about Car, to DB2about Auto, and to KB1about car. Note that each
modelcan be addedindependently, and the articulation axiomsthat result do not have to
changewhenadditional modelsare added. :Also note that applications and resources need
not be modified in order to interoperate in the integrated environment.The Appendixcontains a description of the graphical tool, MIST,that wehavebuilt to aid in the construction
of articulation axioms.
Figure 2 showsa logical view of the execution environment. Duringinteroperation, mediators [Wiederhold 1992], which are implemented by Rosette actors [Tomlinson et al.
1991], apply the articulation axiomsthat relate each agent or resource modelto the commoncontext. This performs a translation of messagesemantics. At most n sets of articulation axioms and n mediators are needed for interoperation amongn resources and
applications. Themediators also apply a syntax translation betweena local data manipulation language, DMLi,and the global context language, GCL.GCLis based on extended
first-order logic. A local data-manipulationqanguage
might be, for example,SQLfor relational databases or OSQL
for object-oriente’d databases. The numberof language translators betweenDML
i and GCLis no greater than n, and maybe a constant because there are
only a small numberof data-manipulation languages that are in use today. Additional details describing howtransactions are processed semantically through the global and local
views of several databases can be found in [Woelket al. 1992].
- 124.
Application1
Interface1
Common Context
TransportationDevice
Context
g
Train
Vehicle
Boat
/ DB~Attribute
OBObject
ss
Context
Truck
Articulation
Automobile
S
s
Car ’j
Car
id
KB1
Context
Art. axiom 3
¯ ,s
~’.
~n_
"..
Articulation
t~Kt~ntlty,*%.****
axiom I
DB1 Context
Jeer"-
s
Car
axiom 2
,-"
¯
ss
Knowledge Base
mnko
car
Auto
Ford
VW
Figure l: Concepts from different modelsare related via a common
aggregate context by
meansof articulation axioms
The mediatorsalso function as communication
aides, by managingcommunications
among
the various agents, databases, andapplicationprogramsin the environment.Figure3 shows
howthey buffer messages,locate messagerecipients, andtranslate messagesemantics. To
implement message transfer,
al blackboard--built
they use a tree-Space
mechanism--a kind of distributed
on the OSI and TCP/IP protocols
- 125-
[Tomlinson et al. 1991].
virtu-
I Application
~
I
Rule-Based Application I
I
[I DML1
--> GCL
I
ocal-to-CommonSemantic Translatio~
by Articulation Axioms
/
iI / , i
~_,ocal-to-CommonSemantic Translatio~
by Articulation Axioms
|
Mediator for agent
Mediator for apt
I
Application [
resource
Common-to-LocalTranslation
by Articulation Axioms
I°~’.V~°~]
Common-to-LocalTranslation
by Articulation Axioms
I°c~~"nl
Local Schema 1
Common-to-LocalTranslation
by Articulation Axioms
I°c"-->~il
I
(~ocal Frame Svste~
Figure 2: Logical view of the execution environment, showinghowmediating agents apply
articulation axiomsto achieve semantic interoperation
- 126-
Tree
ace
L
In,er
ce
/ T--e
Face
In,e
ace
¯ rosmi, 1 ’ 1
IH~ [ Message
Agent
~
Buffer
A
Message
[~
Buffer..... .................
~
/~
]Mediator
Resource
B
~
~Mediator[/’Media
Demand
Figure3: Eachdatabase,application,andreasoning
agenthasa mediator
(actor)that
manages
its communications
througha tree space
4 Application to Transaction Processing
Wehave applied our methodologyto achieve relaxed transaction processing in the provisioning of telecommunicationservices, the task of providing communicationfacilities to
customers.This task is executedin a heterogeneousmultidatabaseenvironment.It is an example of workflowcontrol, in that it provides control and data flows amongtransactions
executing on multiple autonomoussystems [Jin et al. 1993; Tomlinsonet al. 1993]. Service
provisioning typically takes several weeksand requires coordination amongmanyoperation-support systems and network elements. Configuringthe operation-support systems so
that they can performsuch a task often take~ several monthsto complete.
Weinvestigated waysto improvethe provisioning of one type of communicationfacility-digital services (DS- 1). Provisioning DS-1 takes morethan two weeksand involves 48 separate operations--23 of which are manual--against 16 different database systems. Our
goals were to reduce this time to less than two hours and to provide a wayin which new
services could be introduced moreeasily. Our strategy for accomplishingthese goals was
to 1) interconnect and interoperate amongthe previously independentsystems, 2) replace
serial operations by concurrent ones by makingappropriate use of relaxed transaction processing [Attie et al. 1993; Bukhreset al. 1993; Elmagarmid
1992; Ansari et al. 1992], and
3) automatepreviously manualoperations, thereby reducing the incidence of errors and delays. Thetransaction processing is relaxed inthat somesubsystemsare allowed to be temporarily inconsistent, although eventuai’consistency is guaranteed. Relaxing the
consistency requirements allows increased concurrency and, thus, improvedthroughput
and response time.
- 127-
User
~____~
Graphical
Interaction
Agent
Schedule
]l Repairing
/ [_ Agent -
¯ ~.
!~. "~
[
~!
Transaction
Scheduling
Agent
]
I
"~l
J
[
Sched
Processing
Agent
Figure 4: Agentsused for relaxed transaction processing
The architecture of the agents used to implementrelaxed transaction processing is shown
in Figure 4. Theagents operate as follows.Thegraphical-interaction agent helps a user fill
in an order formcorrectly, and checksinver~l~0ries to give the user an estimate of whenthe
order will be completed.It also informsthe user about the progress of the order.
The transaction-scheduling agent constructs the schedule of tasks neededto satisfy an order. Thetasks are scheduled with the maximum
concurrencypossible, while still satisfying
their precedenceconstraints. Someof the rules that implementthe schedule are shownin
Figure 5. Theseparticular rules, whenappropriately enabled, generate a subtransaction to
update the database for customerbilling. Whenexecuting such rules, the transaction-scheduling agent behavesas a finite-state automaton,as shownin Figure 6.
The schedule-processingagent maintains connections to the databases involved in telecommunicationprovisioning, and implementstransactions on them. It knowshowto construct
the proper form for a transaction, based on :the results of other transactions. Thetransac-
- 128-
;; This set of rules (i) executes an external program that
;; translates an Access Service ReqUeSt into a command file
;; to update the database for cnstomer billing, (2) executes
;; the conmmnd file, and (3) checks for completion.
Note that
;; the scheduling agent, due to its truth-maintenance
system,
;; stops processing this subtransaction
whenever an abort of
;; the global transaction occurs.
;; ?grid denotes the global transaction identifier.
Bill-Preparation~
(service-order(?gtid)
If
new-tid(?subtid)
unless(abort(?gtid)))
then (do(,run-shell-progrem
("asr2bill"
~input ("asr-?gtid.out")
zoutput "bill-?gtid.sql"))
bill(?gtid ?subtid)
tell(GIAgent
"Task
?gtid~BILLING
ready"))
Bill-Executionz
If
(bill(?gtid ?subtid)
logical-db(?db))
then (tell(SchedProcAgent
"task-execute ?subtid BILL ?db bill-?gtid.sql")
tell(GIAgent "Task ?grid BILLING active"))
Bill-Completion~
If
(success(?subtid)
bill(?gtid ?subtid))
then (tell(GIAgent
"Task ?grid
BILLING
Bill-Failure:
If
(failure(?subtid)
.~:
excuse(bi11(?gtid
?subtid)))
then (abort(?gtid)
tell(GIAgent "Task ?grid BILLING
Figure 5: Some of the rules used by the transaction-scheduling
for DS-1 workflow
done"))
failed"))
agent to generate a schedule
tions are processed concurrently, where appropriate. If something goes wrong during the
processing of a transaction that causes it to abort or fail to commit, the schedule-repairing
agent provides advice on how to fix the problem and restore consistency. The advice can
be information on how to restart a transaction, how to abort a transaction, howto compen-
- 129-
Start / Preparemessage
Messageready/
Tell Schedule-Processing
Agent
Receivefail from
Receive OKfrom
Figure6: Representative
finite-state automaton
for a telecommunication
service
provisioning
task as implemented
by the transaction-scheduling
agent
sate for a previously committedtransaction, or howto clean-up a failed transaction. The
integrity knowledgethat is stored in the schedule repairing agent comesfrom a comparison
of the models, as expressed in terms of the common
ontology.
The agents, as described above, are simply expert systems whoseexpertise is in processing
orders for telecommunication
services. However,they havethe additional abilities to interact and cooperate with each other. Their interaction is via the mediators shownin Figure 3.
The agents cooperate, at the knowledgelevel [Newell1982], via modelsof themselves. For
example,a conceptual domainmodelfor the graphical-interaction agent is shownin Figure
7. An interface form that provides user access and modifications to the knowledgepossessed by this agent is shownin Figure 8.. Entries on the form, or the form’s completion,
cause queries and transactions to be sent to the other agents or databases in the environment. Note, however, that the modeldoes not capture the procedural knowledgenecessary
- 130-
Customer~
ServiceOrder
Circuit
Figure 7: Semanticmodel(simplified) for the graphical-interaction agent
DS-1 Access Service
Request
--
Order ID
Customer
Date
Phone
Name
wm
----
Quantity
Circuit Information
ALocation
ZLocation
Type
Figure 8: User interface form (simplified) correspondingto the declarative knowledgeof the
graphical-interaction agent
- 131-
subtrans
id
Agent
initiat6~
Transaction
¯l
workDir
binDir
\
\
subclass
\
\
Figure9: Semanticmodelfor the transaction-schedulingagent (dashedarrowsindicate
instancerelationships,andsolid arrowsindicatesubclassrelationships)
to specify the queries and transactions; a technique for modeling processes is needed to
capture such knowledge In other words, the models represent the static knowledge of the
agents, not (unfortunately) their dynamics. Nevertheless, they have proven useful in enabling the agents to interact coherently, as we describe next.
Conceptual models for two more of the ag6nts are shown in Figures 9 and 10. Each model
consists of organized concepts describing the context, domain, or viewpoint of the knowledge possessed by thatagent, i.e., the knowledgebase of each agent contains rules written
in terms of these concepts.
The models in Figures 7, 9, and 10 are related to the commoncontext, and thereby to each
other, via articulation axioms. For example, the concept Transac t d.on for the transaction-scheduling agent and the concept DBTransact: 5.on for the schedule-repairing agent
- 132-
command
DB
DBTransaction
status
Agent
Figure10: Semantic
modelfor the schedule-repairing
agent
/
are each related to the commonconcept DatabaseTransaction via the axioms
ist ( Cyc,DatabaseTransaction ( T) ) ¢=~ist (Scheduler, Transaction (
ist ( Cyc,DatabaseTransaction ( T) ) ¢:~ ist (Repairer, TDBTransaction(
Theaxiomsare used to translate messagesexchangedby the agents, so that the agents can
understandeach other. In the aboveexample,the two agents could use their axiomsto converse about the status of database transactions, withouthavingto changetheir internal terminology. Similar axioms describing the semantics of each of the databases involved
enable the schedule-processing agent to issue transactions to the databases. The axioms
also relate the semanticsof the form shown:in Figure 8to the semanticsof the other information resources in the environment.Suchaxiomsare constructed with the aid of a graphical tool called MIST,for ModelIntegration Software Tool. The operation of MISTis
described in the Appendix.
Operationally, the axiomsare managedand applied by the mediators that assist each agent.
Theyuse the axiomsto translate each outgoing messagefrom their agent into the common
context, and to translate each incomingmessagefor their agent into its local semantics.
- 133-
5 Backgroundand Discussion
Integrating enterprise modelsis similar to integrating heterogeneousdatabases. Twoapproacheshave been suggested previously for this [Buneman
et al. 1990]. Thecompositeapproach produces a global schemaby merging the schemas of the individual databases.
Explicit resolutions are specified in advancefor any semanticconflicts amongthe databases, so users and applications are presentedwith the illusion of a single, centralized database.
However,the centralized view maydiffer from the previous local viewsand existing applications might not execute correctly any more. Further, a newglobal schemamust be constructed every time a local schemachangesor is added.
The federated approach[Heimbignerand McLead1985, Litwin et al. 1990] presents a user
with a collection of local schemas,along with tools for informationsharing. Theuser resolves conflicts in an application-specific manner,and integrates only the required portions
of the databases. This approachyields easier maintenance,increased security, and the ability to deal with inconsistencies. However,a user must understandthe contents of each database to knowwhatto include in a query: there is no global schemato provideadvice about
semantics. Also, each database must maintain knowledgeabout the other databases with
whichit shares information,e.g., in the formof modelsof the other databasesor partial global schemas[Ahlsen and Johannesson 1990]. For n databases, as manyas n(n-1) partial
global schemasmightbe required, while n iii/~ppings wouldsuffice to translate betweenthe
databases and a commonschema.
Webase our methodologyon the composite approach, but makethree changes that enable
us to combinethe advantages of both approaches while avoiding someof their shortcomings. First, weuse an existing common
schemaor context. In a similar attempt, [Sull and
Kashyap1992] describes a methodfor integrating schemasby translating theminto an object-oriented data model,but this methodmaintainsonly the structural semanticsof the resources.
Second, we capture the mappingbetween each model and the commoncontext in a set of
articulation axioms. The axiomsprovide a meansof translation that enables the maintenance of a global view of all information ,resources and, at the sametime, a set of local
views that correspond to each individual resource. Anapplication can retain its current
view, but use the informationin other resources. Of course, any application can be modified
to use the global view directly to access all available information.
Third, we consider knowledge-basedsystems (KBSs),interfaces, and applications, as well
as databases.
Ouruse of agents for interoperating amongapplications and information resources is sim-
mappingsthat result should not have to changewhenadditional objects are integrated.
Theaboveprinciples are incorporated in an integration tool, MIST,for assisting an administrator in generatingarticulation axiomsfor a model,and in a set of agents that utilize the
resultant axiomsto provide users and applications with access to the integrated resources.
Theycan use a familiar local context, while still benefiting from newly addedresources.
Thesesystems constitute part of the semantic services of Camot[Cannata 1991], under developmentat MCC.Theyhelp specify and maintain the semantics of an organization’s integrated information resources.
Extensions of our workare focused on developing additional information-systemapplications for agents, including
¯ intelligent directory service agents
¯ negotiating electronic data interchange (EDI) agents
¯ database triggers--making passive databases active
¯ rule-based database applications
¯ database administration agents
¯ intelligent informationretrieval agents.
i,’7:"
Ourmost important future workis centered on waysin which agents can acquire and maintain modelsof each other in order to improvetheir interactions.
References
[Agha 1986] Gul Agha, Actors: A Modelof Concurrent Computationin Distributed Systems, MITPress, Cambridge, MA,1986.
[Ahlsen and Johannesson 1990] Matts Ahlsen and Paul Johannesson, "Contracts in Database Federations," in S. M. Deen, ed., Cooperating KnowledgeBased Systems 1990,
Springer-Verlag, London, 1991, pp. 293-310.
[Ansari et al. 1992] MansoorAnsari, MarekRusinkiewicz, Linda Ness, and Amit Sheth,
"Executing Multidatabase Transactions," Proceedings 25th Hawaii International Conference on Systems Sciences, Janaury 1992.
[Attie et al. 1993] Paul C. Attie, MunindarP. Singh, AmitP. sheth, and MarekRusinkiewicz, "Specifying and Enforcing Intertask Dependencies," Proceedings of the 19th
VLDBConference, 1993.
- 136-
[Bukhres et al. 1993] OmranA. Bukhres, Ji~san Chen, WeiminDu, AhmedK. Elmagarmid, and Robert Pezzoli, "InterBase: AnExecution Environmentfor HeterogeneousSoftware Systems," IEEEComputer,Vol. 26, No. 8, Aug. 1993, pp. 57-69.
[Bunemanet al. 1990] O. P. Buneman,S. B. Davidson, and A. Watters, "Querying Independent Databases," Information Sciences, Vol. 52, Dec. 1990, pp. 1-34.
[Cannata 1991] Philip E. Cannata, "The Irresistible Movetowards Interoperable Database
Systems," First International Workshopon Interoperability in MultidatabaseSystems, Kyoto, Japan, April 7-9, 1991.
[Ceri and Widom1992] Stefano Ceri and Jennifer Widom,"Production Rules in Parallel
and Distributed Database Environments," Proceedings of the 18th VLDBConference, Vancouver, British Columbia, Canada, 1992, pp. 339-351.
[Collet et al. 1991] Christine Collet, Michael N. Huhns,and Wei-MinShen, "Resourceintegration using a large knowledgebase in Camot," IEEEComputer,Vol. 24, No. 12, Dec.
1991, pp. 55-62.
[Cutkoskyet al. 1993] MarkR. Cutkosky, Robert S. Englemore,Richard E. Fikes, Michael
R. Genesereth, ThomasR. Gruber, William S. Mark, Jay M. Tenenbaum,and Jay C. Weber, "PACT:An Experiment in Integrating Concurrent Engineering Systems," IEEEComputer, January 1993, pp. 28-38.
[Elmagarmid 1992] AhmedElmagarmid,’ ed., Database Transaction Models, Morgan
KaufmannPublishers Inc., San Mateo, CA, 1992.
[Guha1990] R. V. Guha, "Micro-theories and Contexts in Cyc Part I: Basic Issues," MCC
Technical Report NumberACT-CYC-129-90,Microelectronics and Computer Technology Corporation, Austin, TX, June 1990.
[Heimbigner and McLeod1985] Dennis Heimbigner and Dennis McLeod,"A Federated
Architecture for Information Management,"A CMTransactions on Office Information Systems, Vol. 3, No. 3, July 1985, pp. 253-278.
[Jin et al. 1993] W. WoodyJin, Linda Ness, MarekRusinkiewicz, and AmitSheth, "Executing Service Provisioning Applications as Multidatabase Flexible Transactions,"
Bellcore Technical Report (unpublished), 1993.
[Lenat and Guha 1990] Doug Lenat and R. V. Guha, Building Large Knowledge-Based
Systems: Representation and Inference in the Cyc Project, Addison-WesleyPublishing
Company,Inc., Reading, MA,1990.
[Litwin et al. 1990] Witold Litwin, Leo Mark, and Nick Roussopoulos,"Interoperability
- 137-
of Multiple Autonomous
Databases," ACMComputing
Surveys, Vol. 22, No. 3, Sept. 1990,
pp. 267-296.
[Newell 1982] Allen Newell, "The Knowledge
Level," Artificial Intelligence, Vol. 18, No.
1, January 1982, pp. 87-127.
[Sheth and Larson 1990] Amit P. Sheth and James A. Larson, "Federated Database Systems for ManagingDistributed, Heterogeneous, and AutonomousDatabases," ACMComputing Surveys, Vol. 22, No. 3, Sept. 1990, pp. 183-236.
[Smith and Broadwell 1988] David Smith and Martin Broadwell, "The Pilot’s Associate-an overview," Proceedings of the SAEAerotech Conference, Los Angeles, CA,May1988.
[Sull and Kashyap 1992] WonheeSull and,~Rangasami L. Kashyap, "A Self-Organizing
KnowledgeRepresentation Schemefor Extensible Heterogeneous Information Environment," IEEETransactions on KnowledgeandDataEngineering, Vol. 4, No. 2, April 1992,
pp. 185-191.
[Tomlinsonet al. 1991] Chris Tomlinson, MarkScheevel, and Vineet Singh, "Report on
Rosette 1.1," MCCTechnical Report NumberACT-OODS-275-91,
Microelectronics and
ComputerTechnologyCorporation, Austin, TX, July 1991.
[Tomlinsonet al. 1993] Christine Tomlinson,Paul Attie, Philip Cannata, Greg Meredith,
Amit Sheth, Munindar Singh, and Darrell Woelk, "WorkflowSupport in Carnot," IEEE
Data Engineering, 1993.
[Wiederhold1992] Gio Wiederhold,"Mec[~a[~rsin the Architecture of Future Information
Systems," IEEEComputer,Vol. 25, No. 3, March1992, pp. 38-49.
[Woelket al. 1992] Darrell Woelk, Wei-MinShen, Michael N. Huhns, and Philip E. Cannata, "Model-DrivenEnterprise Information Management
in Carnot," in Charles J. Petrie
Jr., ed., Enterprise Integration Modeling:Proceedingsof the First International Conference, MITPress, Cambridge, MA,1992.
Appendix: The Development of Articulation Axioms
Camotprovides a graphical tool, the ModelIntegration Software Tool (MIST),that automatesthe routine aspects of modelintegration, while displaying the information neededfor
user interaction. Thetool producesarticulation axiomsin the following three phases:
1. MISTautomatically represents an enterprise modelin a local context as an instance of a given formalism. Therepresentation is declarative, and uses an extensive set of semanticproperties.
- 138-
ilar to the uses of mediators described in [Wiederhold1992]. However,we also specify a
meansfor semantic translation amongthe agents, as well as an implementedprototype.
Other applications of similar agents, such as the Pilot’s Associate developedby Lockheed
et al. [Smith and Broadwell1988], handcrafted their agents. This is not possible for large
"open" applications: the agents must be such that they can be developedindependently and
execute autonomously.
Ourarchitecture employstwo kinds of computationalagents: finer-grained, concurrent actors and coarser-grained, knowledge-based
systems. The actors are used to control interactions amongthe componentsof the architecture. The knowledge-basedagents are used
wherereasoning is needed, such as in deciding what tasks should be performednext or how
to repair the environmentwhena task has failed. This seemsto be a natural division of responsibilities for our exampleapplication. However,wetook an engineering, rather than a
scientific, approach,in that wedid not investigate any alternative architectures.
6 Conclusion
For years, information-system personnel managedcorporate data that was centralized on
mainframes.The data waskept consistent, but eventually the amountof data increased to
the point that centralized storage wasno longer viable. Also, users wanteda wayto share
data across applications and wantedmoredirect involvementin the management
of the data. So, data then beganproliferating onto w0H~stationsand personal computers,whereusers
could manageit themselves. But this resulted in redundancy,inconsistency, and no coherent global view. Hence,there are nowattempts to reintegrate data. Users still need to manage their owndata, whichremainsdistributed, but they and their applications need coherent
global access and consistency must be restored.
This paper describes Camot’sapproach to enabling interoperation amongenterprise information objects, i.e., amongsuppliers and consumersof information. In this approach, an
enterprise information object is integrated based on articulation axiomsdefined between
two contexts: the context of a modelof the object and a common
context provided by the
Cyc knowledgebase. The methodologyis based on the following principles:
¯ Existing information resources shquld not have to be modified and data should
not have to migrate.
¯ Existing applications should not have to be modified.
¯ Users should not have to adopt a newlanguage for communicatingwith the resultant integrated system, unless they are accessing newtypes of information.
¯ Resourcesand applications should be able to be integrated independently, and the
- 135-
2. Byconstraint propagation and user interaction it matchesconcepts from the local context with concepts from t~e common
context.
3. For each match, it automatically constructs an articulation axiomby instantiating axiomtemplates.
As shownin Figure 11, MISTdisplays enterprise modelsboth before (lower right) and after
(lower left) they are represented in a local context. MISTenables the Cycknowledgebase
to be browsedgraphically (middleright) and textually (upper left), in order to allowthe
rect concept matchesto be located. It enables a user to create framesin the common
context
or augmentthe local context for a modelwith additional properties whenneededto ensure
a successful match. MISTalso displays the articulation axioms(upper right) that it constructs. Therest of this appendixdescribesthe three phases of articulation axiomdevelopment in more detail.
~""
rd,:
In the modelrepresentation phase, werepresent the modelas a set of frames and slots in a
Cyccontext created specially for it. These frames are instances of frames describing the
metamodelof the schema, e.g., (for a relational schema) Relation and DatabaseAttribute.
In the matchingphase, the problemis: given a (Cyc) representation for a conceptin a local
context, find its correspondingconcept in the common
context. The two factors that affect
this phase are (1) there maybe a mismatchbetweenthe local and common
contexts in the
depth of knowledgerepresenting a concept, and (2) there maybe mismatchesbetweenthe
structures used to encodethe knowledge.For example,a concept in Cyccan be represented
as either a collection or an attribute [Lenat’andGuha1990, pp. 339ff].
If the common
context’s knowledgeis morethan or equivalent to that of the local context’s
for someconcept, then the interactive matchingprocess described in this section will find
the relevant portion of the commoncontext’s knowledge.If the commoncontext has less
knowledgethan the local context, then knowledgewill be added to the common
context until its knowledgeequals or exceedsthat in the local context; otherwise, the common
context
wouldbe unable to modelthe semantics of the resource. The added knowledgerefines the
common
context. This does not affect previously integrated resources, but can be useful
whenfurther resources are integrated.
Finding correspondences between concepts in the local and commoncontexts is a subgraph-matchingproblem. Webase subgraph!0atching on a simple string matching between
the namesor synonymsof frames representing the model and the names or synonymsof
frames in the common
context. Matchingbegins by finding associations betweenattribute/
link definitions and existing slots in the common
context. After a few matcheshave been
- 139-
View Micro
Filter
Info
:: :Integration
postalAddress
instanceOf
Slot
allInstanceOf
BinaryRelation
makesSenseFor
Agent
entryIsA
Addres sTheFormat
inverse
postalAddressOf
entryFormat
SetTheFormat
allGenlSlots
postalAddress
allSpecSlots
postalAddress
Suggestions Inconsistencies File
> Create Articulation Axiom:#%address II
Articulation axiomcreated for address:
ERMASS35Mt:"
MASSInfo.address
<--->
LodgingOrganization.postalAddress
address
Q
Clear
Kill
File
~
Misc
*** Using pointer
over panning area,
place object in
graph inspector
ostalAddress
i
L - create new node and place it under pointer
Integer
numberOfFloors
String
Figure 11: MISTdisplays an information modelboth before and after it is integrated,
and showsthe mappings(articulation axioms)that it constructs
- 140-
I
identified, either by exact string matchesor by a user indicating the correct matchout of a
set of candidate matches, possible matches for the remaining modelconcepts are greatly
constrained. Conversely,after integrating an entity or object, possible matchesfor its attributes are constrained.
In the third phase, an articulation axiomis constructed for each matchfound. For example,
the match betweena relational attribute phone in modelAAAand the Cyc slot phoneNuraber yields the axiom
ist ( Cyc, phoneNumber
( L, N) ) ¢:~ ist ( AAA,phone( L,
which means that the phone attribute definition determines the phoneNumberslot in
the common
schema, and vice versa. Articulation axioms are generated automatically by
instantiating stored templates with the matchesfound.
--
_
__
- 141-
_
.