From: AAAI Technical Report FS-96-03. Compilation copyright © 1996, AAAI (www.aaai.org). All rights reserved.
AN AGENT ARCHITECTURE AND ALGORITHM FOR SOLVING
DISTRIBUTED CONFIGURATION-DESIGN PROBLEMS
Timothy P. Darr (timd@eecs.umich.edu)
http://ai.eecs.umich.edu/people/timd/timd.html
William P. Birmingham(wpb@eecs.umich.edu)
http://ai.eecs.umich.edu/people/wpb/home.html
AdvancedTechnologies Lab
The University of Michigan
AnnArbor, M148109
Fax: (313)763-1260
1.
INTRODUCTION
Configurationdesign is a type of design problemin whichparts are selected from catalogs
and connectedto meet the following problemrequirements:functionality, specifications, and
constraints [7-9, 12]. Functionality defines whatthe design is supposedto do, specifications
define optimality goals, and constraints def’methe feasibility relationships that mustbe satisfied for
the designto operate correctly. A designis a collection of parts evaluatedwith respect to the
problemrequirements(functionality, specifications and constraints). A design that meets these
requirementsis a solution to the problem.Configurationdesign is a ubiquitous and economically
important task, playing a prominentrole in complexproducts such as automobiles, airplanes or
computersystemsthat contain millions of parts, including resistors, light bulbs, screws,
microprocessors and engines.
Parts are described by attributes and implementone or morefunctions. Configuration
design is difficult becauseparts can implementmanyfunctions (the multi-function part problem)
[7, 8], functions can be implementedby manyparts, parts maydependon other parts for their
correct operation (the supportfunction problem)[9], and constraints and specifications defined
over part attributes restrict the allowedconfigurations, introducinghorizoneffects. Thereexist
several techniques to reducethe numberof designs to explore. If the functionality requirementis
decomposed
into required functions that individual parts implement,designs are constructed by
selecting parts that implementeach required function. Heuristics based on design experienceor
properties of the design problemcan be used to reduce the search space by ruling out certain part
selections.
Large-scale configuration design problemsthat consist of thousandsof required functions
and millions of parts are too complexfor a single agent1 or small group of agents to manage.Such
problemsare recursively decomposed
into sub-problems,until they are manageable.At this level,
parts are selected to implementa small numberof required functions, subject to constraints on the
selected parts. However,manyof these constraints are shared amongsub-problems, the agents
responsible for solving the sub-problemsare often geographicallydistributed, and the catalogs
from whichparts are selected often reside outside the organization. Thus, solving large-scale
problemsrequires communicationamongagents, and algorithms to resolve constraint violations on
the shared constraints that link the sub-problems.Computernetworks,such as the Internet,
facilitate communication
amongagents makingalgorithms possible to resolve constraint violations,
and provide a wayto makethe contents of part catalogs outside the design organization available to
design agents.
This paper describes the AutomatedConfiguration-Design Service (ACDS)[1-3], a system
for solving large-scale configuration design problemsusing a networkof design agents that
1 In this work,an agentis a human
or computer
processpossessing
designknowledge
withthe capabilityto
communicate
withotheragents.ACDS
agentsare computational
processesthat reside ontheir owncomputer
host,
communicating
with other agentsby passingmessages.
84
represent part catalogs and design constraints. TheACDS
algorithm is guaranteedto terminate,
with a solution if one exists. ACDS
agents communicateusing design protocols and an attributespace representation that boundsthe space of all possible designs. ACDS
agents concurrently
shrink the space by applying local knowledge,properties of the domain,and heuristics, until a
solution is found.
Thecontributions of this workare divided into three areas: (a) distributed design algorithms
and networks,(b) distributed design representations, (c) distributed design agents, and
distributed configuration design problemrepresentations. Eachof these contributions is described
briefly below,and in detail in the followingchapters.
2.
ACDS ALGORITHM AND NETWORK
The ACDS
algorithm is executed by a network of computational design agents to solve
configuration design problems.There are four basic ACDS
agents: catalog agents, that represent
part catalogs; constraint agents, that represent feasibility constraints; the systemagent, that
represents a user interface to the ACDS
network;and the search-control agent, that monitorsthe
algorithmto assist the networkin recovering fromdead-endsand to ensure that a solution will be
found, if one exists. In an ACDS
network, a communicationlink exists betweena catalog agent
and constraint agent if the feasibility constraint representedby the constraint agent restricts the
selection of parts fromthe catalog represented by the catalog agent.
Figure 1 showsan ACDS
network for an exampleelevator configuration design problem.
In this examplenetwork, there are two catalog agents and two constraint agents. Thecatalog agents
represent sets of motors and machineunits. Themachine-unitis an assemblythat houses the motor
that drives the elevator cab up and downthe elevator shaft. Theconstraint agents represent
feasibility constraints betweenthe motorhorsepowerand machine-unit allowed horsepower, and a
feasibility constraint specifying the maximum
total weight. Asolution to the problemis a selection
of a motorand machine-unitsatisfying the constraints that the horsepowervalue of the selected
motor must lie within the minimumand maximum
allowed horsepowervalues of the selected
machine-unit, and that the total weightbe no morethan 2760lbs. Theseconstraints are represented
by the expressions:
¯ machine-unit.min_hp < motor.hp,
¯ motor.hp < machine-unit.max_hp,
¯ machine-unit.weight ÷ motor.weight < 2760.
Figure 2 showsthe set of parts for each catalog.
Machine-Unit
Min
Horse
Power
~
~ machine-unit
k
I k
klf
.eight
_<
l \~\ L
f Machine-Unit Max Horse Power
~ motor blO < machine-unit
max-hp
I
motor
/-~’’"~"~
~
~
Legend
~--~
Catalog
Agent
~--~
Constraint
Communication Link
Agent
Figure 1: ACDSNetwork
The ACDS
algorithm is based on the concurrent engineering (CE) design paradigm.
transformsthe design process froma serial to a parallel one by concurrentlyapplyingall relevant
knowledgeto the problem. Theresult of this methodis the shortening of the product development
85
cycle. The ACDS
algorithm and network of distributed agents achieves concurrency through
constraint-based decomposition.In constraint-based decomposition,constraint agents define
problemdecompositionsand use properties of the domainand heuristics to concurrently eliminate
designs fromconsiderationthat do not satisfy their constraint.
part_name
modell8
model28
model38
model58
min_hp
i0
15
20
40
max_hp
15
20
40
40
weight
ii00
1700
2400
2750
part_name
hp
weigh t
10HP
15HP
20HP
25HP
30HP
i0
15
20
25
30
374
473
534
680
715
(b) motorcatalog
(a) machine-unitcatalog
Figure 2: ExampleConfiguration Design Catalogs
The ACDS
algorithm operates on spaces of designs. ACDS
agents use operations to shrink
this space until a set of solutions are found. TheACDS
algorithmconsists of concurrentcatalogagent operations to construct the space from the agent’s individual parts, followedby concurrent
constraint-agent operations to shrink the space, followedby concurrentcatalog-agent operations to
removeparts that lie outside the constraint-agent generatedspaces. This cycle is repeated until a
solution or set of solutions is found.
3.
ACDS DESIGN REPRESENTATION
Thesolution to a configuration design problemis described as an assignmentof values to a
set of design attributes. In the examplepresentedin Section 2, the attributes that describe the
design are {motor horsepower,total-weight}. Thus, one possible design is { 10, 1474}
({modell8, 10HP}).ACDS
represents the design as an attribute space. The attribute-space
representationis a set of intervals that compactlyrepresent the spaceof all possible designs[1-3].
In this representation, eachdesign attribute is an interval. Thecompleteset of intervals is an
abstract, m-dimensionalspace, wheremis the numberof attributes that describe the design. As the
following exampleshows, the attribute space representation has several desirable properties when
applied to problemswhoseconstraints are monotonicand part attributes can be partially ordered.
Figure 3 showsall possible designs for the exampleas points, and the attribute-space as a
rectangle, given by {motorhorsepower= [10 30], total-weight = [14743465]}, that encloses the
points. Clearly, someof the designs in the attribute space exceedthe weightconstraint. The
attribute-space representation is also usedto represent the possible part selections fromthe catalogs
shownin Figure 2. For example,the possible choices for the machine-unitcatalog are given by the
attribute space {min_hp= [10 40], max_hp- [15 40], weight = [1100 2750] }. The first advantage
of the attribute-spacerepresentationis that it is a compactrepresentationof a potentially large
numberof designs. Eventhough there are only a small numberof possible configurations m
Figure 3, the attribute space as shownencompassesany design within its boundaries.
Thesecondadvantageof the attribute-space representationis that it facilitates certain
inferences. Assuming
that the constraints are monotonicand the part attributes can be ordered, sets
of parts that cannotbe in any solution (inconsistent parts) can be identified and eliminated.
Considerthe total-weight constraint. Solving for each term yields the equivalent expressions:
¯ machine-unit weight < 2760 - motor weight
¯ motor weight < 2760 - machine-unit weight
Theseexpressions restrict the allowed assignmentsto machine-unit weight and motor
weight, respectively, giventhe set of assignmentsto the other attribute. Usingthe attribute-space
representationfor the weightattributes of eachcatalog, and interval arithmetic to evaluate the
expressions, sets of infeasible weightscan be eliminated. For example,[374 715] is the set of
86
possible assignmentsfor the motorweightattribute. Inserting this value into the expression for
machine-unitweight yields:
¯ machine-unit weight < 2760 - [374 715]
< [2045 2386]
Attribute Space (machine-unit, motorexample)
400O
..o.,,o°°O.-,,o,..,,,,,Oo°.,°,,.,,,,,,,,.%,,,o-,~
¯ :.:-:.:.:.:ik:.:.:.:.:~..:.:.:.’.;.:.:.:.:.:.
-:
~’":’:-".’.-’.:.":-:-:.:.’.:.:.’".’.:.’.:.:0
3000
2
.:.:.;.;.;.:~.:.:.:.:.:~.:.:.:.:.:.;.:.:.:.:.:.:
~ii!!iiiii:::!!iiiii~i:!:iiiiiii~ii!iiiiiiiiiii!i:"
¯ ....°,°°o,.°.....°°.Oo%.,.o.°..o.°,,,o.
°
iiiiiiiiiii:~iiiiii:ii~iii:i:i:iiiiiiiii:i:K
~:::::::::.:======================================
:::::::::::::::::::::::::::::::::::::::::::::::::
~
. 2000
+
1000
o
I
Horsepower
(motorI-IP)
Figure 3: ExampleAttribute Space
This result indicates that givenany possible motorselection, the mostthat the machine-unit
can weigh is 2386 lbs Fromthis, the parts model38and model58can be eliminated from
consideration withoutlosing any solutions, since if either model38or model58is selected, there is
no motorlight enoughto satisfy the total-weight constraint Notethat this inference waspossible
without knowinginformation about specific parts In fact, any machine-unitwhoseweight is in the
range 2386 < machine-unitweight < 2750, whichcould be a large numberof parts, is not
consistent and should be removedAnattribute space that contains only consistent parts is a
consistent attribute space [1-3, 10, 11, 16, 17]
Figure 4 showsthe samecatalogs in Figure 2 with inconsistent parts removed.Any
configurationof the remainingparts satisfies the weightconstraint, but there are still configurations
that violate the constraint betweenthe minimum
and maximum
allowed horsepowerof the selected
machine-unit and the horsepowerof the selected motor (for example, {modell8, 20HP}).The
attribute-space representationsuggestsa heuristic for further eliminatingparts to identify a set of
solutions. Anattribute space that contains only solutions is a decomposable
space.
partname
modell81
model2B
I
minhp
i0
15
max_hp
weight
[5
20
II00
1700
part_name
10HP
15HP
20HP
(a) machine-unitcatalog
hp
i0
15
20
weight
374
473
534
(b) motorcatalog
Figure 4: Catalogswithout Inconsistent Parts
87
To illustrate the heuristic for fmdinga decomposable
space, consider the constraints
between the machine-unit minimumand maximumhorsepower and the motor horsepower shown
below:
¯ machine-unit.min_hp_< motor.hp,
¯ motor.hp _< machine-unit.max_hp,
Replacingthe terms in the In’st expressionwith their interval values yields the expression:
¯ machine-unit.min_hp < motor.hp,
¯
[10 15] <[1020]
In a decomposable
space, every value in the interval on the left-hand side of this expression
must be less than or equal to every value on the right-hand side. Byexamination,the space is not
decomposable,since there exists an assignmentthat violates the constraint, namelymachineunit.min_hp= 15 and motor.hp= 10. Thus, to satisfy this constraint, an effective heuristic is to
removethe machine-unit with value min_hp= 15 and the motor with value hp = 10. Removing
infeasible designs using this heuristic movesthe attribute-space towarda decomposable
space.
4.
ACDS DESIGN AGENTS
ACDS
agents possess a set of operations to navigate attribute spaces. Catalog agent
operations mapfrom the catalog agent’s parts, to an attribute space representation; and mapfrom
an attribute spaceto a set of parts that lie within that space. Constraintagent operationstransform
one attribute spaceinto a smaller attribute spacewith certain properties. This section outlines the
agent properties and operations.
Catalogagents havethe capability to:
¯ identify parts that implementrequired functions,
¯ create an attribute-space representationof the parts in its catalog,
¯ communicate
its attribute space to constraint agents to achievedesign goals,
¯ apply an attribute spaceto its catalog to removeparts.
Catalog agents use operations to mapfrom parts to the attribute-space representation and
back. To illustrate, wereturn to the examplepresented in Section 2. Themachine-unitcatalog agent
constructs the initial attribute-space representation by mappingfrom the parts shownin Figure 2 to
the space {min_hp= [10 40], max_hp= [15 40], weight = [1100 2750]}, which bounds all
possible part selections. To removeinconsistent parts identified by the consistencyoperation
illustrated in Section 3, the machine-unitcatalog agent mapsfrom the constraint-agent generated
space weight = [1100 2386] to the set of parts {model18,model28} by removingthe parts
{model38,model58} since their weights exceed2386 lbs. Oncethe inconsistent parts are
removed,the newmachine-unit catalog attribute space is {min_hp= [10 15], max_hp= [15 20],
weight = [1100 1700]}.
Constraint agents havecapability to:
¯ construct a consistent attribute space,
¯ movean attribute space toward a decomposablespace.
Theconstraint agents use operations to create a consistent space, and create a space that
movesin the direction of a decomposablespace. Theseoperations are implementedusing interval
techniquesdescribedin Section 3. This section illustrates these operations graphically as spaceshrinking operations.
Figure 5 illustrates the constraint-agent operations for the constraint betweenthe machineunit minimum
horsepowerand the motorhorsepower.Theinitial attribute space for the constraint
in Figure 5: is {motorhp = [10 30], machine-unitmin_hp= [10 40] }.
Viewedas a projection onto the feasible space, there are slices along each dimensionof the
initial attribute spacethat do not intersect the feasible space. In particular, the slice alongthe
machine-unitmin_hpdimensionjust greater than 30 up to the value 40 does not intersect the
feasible region at all, so any machine-unitwhoseminimum
required horsepowerlies within this
88
slice can be removedas they are not consistent. Theconsistent space {motorhp = [10 30],
machine-unitmin_hp= [10 30] } is shown.Theupdated space after the catalog-agent operations
have been applied is {motor hp = [10 30], machine-unit min_hp= [10 20]}, shownas the space
boundedby dotted lines. Eventhough this space intersects the feasible space along each
dimension,it is not enclosedby the feasible space.
Constraint Agent Shrinking Operation
35
3o
::::::::::.:.:.:.’
25
iiiiiii.iiiiiiil
Legend
Current Space
Consistent Space
Updated Space
Feasible Space
Figure 5: Constraint-Agent Shrinking Operations
Tofurther shrink the spaceso that it is enclosedwithin the feasible space, a second
constraint-agent operation using the space-shrinkingheuristic described aboveis used. This
operation directs the attribute space towardthe feasible region by examiningthe boundsof the
current attribute space. In this example,the comerof the current attribute space defined by {motor
horsepower= 10, machine-unitmin_hp= 20} lies outside the feasible space. To direct the space
towardthe feasible space, the boundsthat define this comerare tightened by creating the space
{motor hp = (10 30], machine-unit min_hp= [10 20)}, where the interval motor hp = (10
meansthe horsepowermust be greater than 10 and less than or equal to 30.
Thesystemagent represents the user interface to ACDS,
and has the capability to:
* collect and broadcast design requirements,
¯ identify whenthe design process is complete.
Thesearch-control agent monitorsthe design process, and has the capability to:
¯ detect dead-endconditions whenbacktracking is necessary,
direct the agents to a newattribute spaceto explore,
¯ guarantee complete coverage,
¯ identify whenno solution exists.
ACDS
agents communicatethrough design protocols to achieve design goals. These
protocols specify the format of messagessent and received, and the sequenceof messagesused
within the protocol. For example,consistency and feasibility protocols allow catalog and constraint
agents to achieve consistent and decomposablespaces by sending messagesfrom the catalog
agents to the constraint agents to define the current space. Theconstraint agents use this spaceto
construct newspaces whichare sent backto the catalog agents, whoremoveparts that lie outside
the space.
89
5.
ACDS DESIGN PROBLEM REPRESENTATION
ACDS
includes a precise definition of the configuration design problem, whichis mapped
to a distributed, dynamic,multi-attribute domain,interval constraint-satisfaction problem(CSP)
computationalmodel[14, 15]. ACSPis a general problem-solvingrepresentation given by a set of
variables, a set of domainvalues for the variables and a set of constraints that restrict the possible
assignment of values to variables. The ACDS
CSPcomputational modelhas the following
additional properties:
1. the variables and constraints havepreconditions that specify whenthey are active
(dynamic CSP),
2. each variable or constraint is a separate computationalprocess that communicate
by
sending messages (distributed CSP),
3. the domainelementsare described by an attribute tuple (multi-attribute domainCSP),
4. constraints are evaluated over interval-valued variables (interval CSP).
5. Variable represent parts that cover the sameset of functions.
The ACDS
CSPcomputational model provides a precise frameworkfor applying
established CSPproperties and heuristics to configuration design problems. For example,ACDS
uses arc-consistency [4, 5, 16, 17] to reduce the numberof combinationsby efficiently removing
certain configurations that violate constraints, and the forwardcheckingheuristic to propagatethe
effects of design decisions [6J. Bymappingrequired functions to CSPvariables and design
constraints and specifications to CSPconstraints, the ACDS
CSPframeworkencompassesall
types of configuration design problems,including those with multi-function parts and support
components.This workextends the class of problemsto which a CSPmodel applies by defining
the multi-attribute CSP, whichis a CSPwhosevariable domainelements are described by an
attribute tuple. In the multi-attribute CSP,parts mapdirectly to CSPdomainelements.
Anadditional property identified by the ACDS
CSPcomputational modelis the boundarypart property. This property applies to a class of configuration design problemsin whichthe parts
can be orderedfor each part attribute and in whichthe constraints that are definedover the part
attributes are monotone.This property states the conditions under whicha single part can be
selected to implementa function without losing any solutions. This property is used as a basis for
the conditions for backtrack-free search, namelya boundarypart implementseach required
function.
5"
6.
ACDS CONTRIBUTIONS
This section summarizesthe contributions of this workand describes the experimentaland
theoretical results that supportthese contributions. Thecontributions of this workfall into three
areas: distributed design algorithms and networks, distributed design problemrepresentations, and
distributed design agents.
6.1.1
Distributed Design Algorithm Contributions
Aneffective algorithmfor large-scale distributed design is guaranteedto terminate, uses
heuristics to managethe problemcomplexityand is scaleable. This workdefines a distributeddesign algorithmfor solving configuration design problemsthat is guaranteedto terminate. The
contributions are the following:
¯ ACDSAlgorithm
¯ Soundand complete,
¯ Uses heuristics for particular design domainsand classes of designs,
Scales to over 200 agents.
This workprovesa theoremthat states the properties of the search-control agent that must
hold for the algorithmto terminate, with a solution if one exists. Weshowthat for the VTelevator
9O
configuration design problem[13], the space-shrinkingheuristics reduce the time to solve the
problemover binary-search methods. Finally, we demonstrate that the ACDS
algorithm solves an
elevator design problemwhenscaled to over 200 agents, which is a limit on the numberof
computerhosts available at the University of Michigan.
6.1.2
Design Problem Representation Contributions
To incorporate domain-independent
heuristics and into design algorithms, it is necessary to
have a precise problemdefinition and a domain-independentcomputational model. This work
precisely defines the distributed configurationdesign problemand casts it as a dynamic,
distributed, interval constraint-satisfaction problem(CSP).Thecontributions are the following:
¯ Precise defmition of the distributed configuration design problem,
¯ Theattribute-space representation.
¯ Facilitates efficient reasoningfor a large class of problems,
¯ Effective for communicatinglarge design spaces.
¯ CSPmodelfor configuration design represents
¯ Multi-function parts,
¯ Support components,
¯ Multi-functioncatalogs.
¯ CSPtechniques reduce the search space using node- and arc-consistency.
This workdefines the distributed configuration design problem, and mapsit to a CSP
computationalmodel. Multi-function part, support componentand multi-function catalog design
problemsare solved using ACDS
to demonstrate that the CSPmodelcan be used to solve these
problems.Experimentsare performedto demonstratethe effectiveness of node- and arcconsistency properties in solving design problems.
Themulti-attribute domainCSPintroduces uniqueproperties that must be satisfied to
extend the class of backtrack-free search problems.This workextends the class of problemsto
whichthe basic CSPrepresentation applies to include problemswith multi-attribute variable
domainelements. Thecontributions are the following:
¯ Multi-attribute CSP:
¯ Boundaryelement property reduces the numberof domainelements to a single
elementwithout losing solutions,
¯ Precise characterization of the conditions for backtrack-free search.
This workprecisely defines the multi-attribute CSP, and the boundaryelement property,
and proves the properties of the boundaryelement. Theconditions for backtrack-free search are
stated and a theoremproven.
6.1.3
Design Agent Contributions
To create flexible design networksfor solving a variety of design tasks, design agents must
be able to interact with other agents in well-definedwaysto achieve joint design goals. This work
describes a set of generic design agents at the knowledgelevel, and a set of design protocols these
agents use to achieve specific design goals. Thecontributions are the following:
¯ Knowledge-leveldescription of agent capabilities, design messageclasses, agent
operations for distributed design.
¯ Protocols to achievespecific design goals.
Theseagents and protocols are specialized for configuration design and incorporatedinto
the ACDS
algorithm to demonstratetheir effectiveness in solving distributed configuration design
problems.
91
7.
REFERENCES
1.
Dart, T.P. and W.P. Birmingham,AutomatedDesign for Concurrent Engineering, IEEE
Expert, 1994, Vol. 9, No. 5, p. 35-42.
2.
Darr, T.P. and W.P. Birmingham,An Attribute-Space Representation and Algorithm for
Concurrent Engineering, A/EDAM,
1996, Vol. 10, No. 1, p. 21-36.
3.
Darr, T.P., Ph.D. thesis in preparation, 1996, TheUniversity of Michigan,
4.
Mackworth,A.K., Consistency in Networksof Relations, Artificial Intelligence, February
1977, Vol. 8, No. 1, p. 99-118.
5.
Freuder, E.C., Synthesizing Constraint Expressions, Communicationsof the ACM,1978,
Vol. 21, No. 11, p. 958-966.
6.
Haralick, R.M.and G.L. Elliott, Increasing Tree Search Efficiency for Constraint
Satisfaction Problems,Artificial Intelligence, 1980, Vol. 14, No. 3, p. 263-313.
7.
Mittal, S. and F. Frayman,Towardsa generic modelof configuration tasks, Eleventh
International Joint Conferenceon Artificial Intelligence (IJCAI-89), 1989, Detroit, MI, Morgan
Kaufmann,p. 1395-1401.
8.
Haworth, M.S., W.P. Birmingham,and D.E. Haworth, Optimal Part Selection, 1EEE
Transactions on Computer-AidedDesign of Integrated Circuits and Systems, 1993, Vol. 12, No.
10, p. 1611-1617.
9.
Mittal, S. and F. Frayman, COSSACK:
A Constraints-Based Expert System for
Configuration Tasks, Proceedingsof the 2nd lnternational Conferenceon Applications of AI to
Engineering, 1987, Boston, MA.
10. Hyvt~nen,E., Constraint reasoning based on interval arithmetic: the tolerance propagation
approach, Artificial Intelligence, December1992, Vol. 58, No. 1-3, p. 71-112.
Benhamou,F., D. McAllester, and P. Van Hentenryck, CLP(Intervals) Revisited, 1994,
11.
Brown University Technical Report CS-94-18.
12. Birmingham, W.P., A.P. Gupta, and D.P. Siewiorek, Automating the Design of
ComputerSystems, 1992, Jones and Bartlett Publishers.
13. Marcus, S., J. Stout, and J. McDermott,VT: AnExpert Elevator Designer That Uses
Knowledge-basedBacktracking, AIMagazine, 1988, Vol. 9, No. 1, p. 95-112.
14. Yokoo,M., et al., Distributed Constraint Satisfaction for Formalizing Distributed Problem
Solving, Twelfth International Conference on Distributed ComputingSystems, 1992, Yokohama,
Japan, IEEEComputerSociety, Los Alamitos, CA, p. 614-621.
15. Mittal, S. and B. Falkenhainer, DynamicConstraint Satisfaction Problems, Proceedings of
the Eighth National Conferenceon Artificial Intelligence (AAM-90),1990, p. 25-32.
16. Carlson, B., S. Haridi, and S. Janson, AKL(FD)- A concurrent language for
programming,Logic Programming:1.994 International Symposium,1994, The MITPress, p.
521-535.
17. Carlson, B., M. Carlsson, and D. Diaz, Entailment of Finite DomainConstraints,
Proceedingsof the Eleventh International Conference of Logic Programming,1994, MITPress.
92