Hierarchical Constraint Logic Programming for Multi-Agent Systems
Hiroshi Hosobe
1 a
and Ken Satoh
2
1
Faculty of Computer and Information Sciences, Hosei University, Tokyo, Japan
2
National Institute of Informatics, Tokyo, Japan
Keywords:
Multi-Agent System, Logic Programming, Constraint.
Abstract:
Logic programming is a powerful tool for modeling and processing multi-agent systems (MASs), where prob-
lems are collaboratively solved by multiple agents that exchange messages. Especially, (constraint) logic
programming with default rules is useful for speculative computation for MASs, where tentative solutions are
computed before answers arrive from other agents. However, the previous frameworks became complicated to
enable speculative computation for MASs. In this paper, we propose a framework using hierarchical constraint
logic programming (HCLP) for speculative computation for MASs. HCLP is an extension of constraint logic
programming that allows soft constraints with hierarchical preferences. We simplify our MAS framework by
utilizing HCLP and soft constraints to handle MASs with default rules. We show a prototype implementation
of our framework and a case study on its execution.
1 INTRODUCTION
Multi-agent systems (MASs) have long been being
studied in the field of artificial intelligence. A MAS
is defined as “a loosely coupled network of problem
solvers that interact to solve problems that are beyond
the individual capabilities or knowledge of each prob-
lem solver” (Sycara, 1998). Such cooperative prob-
lem solvers are called agents. Research on MASs typ-
ically is focused on how to construct agents for given
problems. Applications of MASs range over broad ar-
eas including computer networks, robotics, complex
system modeling, city and building management, and
smart grids (Dorri et al., 2018).
Logic programming (LP) (Lloyd, 1987), which
uses formal logic for programming, and constraint
logic programming (CLP) (Jaffar and Lassez, 1987;
Jaffar and Maher, 1994), which extends LP with
the notion of constraints, can be powerful bases for
modeling and processing MASs. An extension of
LP is suitable for the reactive component of a MAS
as well as for the rational component of a single
agent (Kowalski and Sadri, 1999). Also, an extension
of CLP allows building MASs with constraint-solving
capabilities (Vlahavas, 2002).
A MAS is usually designed to normally work in a
situation with no problem of communication among
agents. However, in actual situations, it is difficult
a
https://orcid.org/0000-0002-7975-052X
to always guarantee efficient and reliable communi-
cation among agents. For example, if a MAS is de-
ployed on a network like the internet that does not
guarantee reliable communication, or if a MAS in-
volves a human user as part of the MAS, it is possible
that communication might largely delay or even fail.
Speculative computation for MASs is an effec-
tive means for coping with such problems. It en-
ables MASs to compute tentative solutions in sit-
uations where communication among agents might
largely delay or fail. Especially, LP and CLP with de-
fault rules are useful for speculative computation for
MASs (Satoh et al., 2003; Satoh et al., 2000). In such
situations, MASs speculatively compute tentative so-
lutions, for which agents use default knowledge about
other agents, instead of waiting for their answers.
However, the previous MAS frameworks became
complicated to enable speculative computation. They
were achieved by performing speculative computa-
tion and default rule handling within the same mech-
anisms. In other words, they introduced specialized
mechanisms for operating such default rules and an-
swers, which required more complicated mechanisms
to enable more powerful MASs.
In this paper, we propose a framework for spec-
ulative computation for MASs by using an extension
of CLP. The CLP extension that we use is hierarchi-
cal CLP (HCLP) (Wilson and Borning, 1993), which
allows soft constraints with hierarchical preferences
Hosobe, H. and Satoh, K.
Hierarchical Constraint Logic Programming for Multi-Agent Systems.
DOI: 10.5220/0011698000003393
In Proceedings of the 15th International Conference on Agents and Artificial Intelligence (ICAART 2023) - Volume 1, pages 289-296
ISBN: 978-989-758-623-1; ISSN: 2184-433X
Copyright
c
 2023 by SCITEPRESS – Science and Technology Publications, Lda. Under CC license (CC BY-NC-ND 4.0)
289

(i.e., constraint hierarchies (Borning et al., 1992)).
Our main point is that we simplify our MAS frame-
work by utilizing HCLP and soft constraints to han-
dle MASs with default rules. Instead of introducing
a specialized mechanism for operating default rules
and answers in MASs, we express them by using the
hierarchical preferences of soft constraints in HCLP,
which enables us to treat default rules and answers
declaratively rather than operationally. We present
how to specify MASs in HCLP and how to perform
speculative computation for such MASs. Also, we
show a prototype implementation of our framework
and a case study on its execution.
2 RELATED WORK
Researchers proposed frameworks and methods us-
ing LP for speculative computation for MASs. A
logical framework based on abduction for specula-
tive computation for master-slave MASs was first pro-
posed (Satoh et al., 2000). Then this framework was
extended to tree-structured MASs to enable agents to
revise answers that they previously returned (Satoh
and Yamamoto, 2002). Also, a framework using
abduction was proposed (Satoh, 2005) and applied
to orientation systems (Ramos et al., 2015a; Ramos
et al., 2015b; Ramos et al., 2016; Ramos et al.,
2014) and a decision support system (Oliveira et al.,
2014). In addition, researchers proposed a framework
that translates programs by assigning time stamps to
predicates (Sakama et al., 2000), approaches using
consequence finding (Inoue et al., 2001; Inoue and
Iwanuma, 2004; Iwanuma and Inoue, 2002), a method
that combines action execution (Hayashi et al., 2002),
a method using defeasible logic (Lam et al., 2012),
and a method using Bayesian networks (Gomes et al.,
2016).
To treat more general problems than those LP-
based frameworks and methods, a framework us-
ing CLP for speculative computation for master-slave
MASs was proposed (Hosobe et al., 2007; Satoh et al.,
2003). This framework was applied to a reasoning
module for distributed clinical decision support sys-
tems (Oliveira et al., 2015). In addition, it was ex-
tended to enable agents to revise previous answers
and also to return disjunctive answers (Ceberio et al.,
2006). This extended framework was implemented in
a practical multi-threaded manner (Ma et al., 2010b).
Furthermore, it was extended to allow tree-structured
MASs (Hosobe et al., 2010). Also, there have been
more different CLP-based approaches to speculative
computation for MASs including one using abduc-
tive reasoning (Ma et al., 2010a) and another us-
ing Bayesian networks (Oliveira et al., 2017). How-
ever, those CLP-based frameworks became compli-
cated to treat default rules for speculative computation
for MASs.
3 PRELIMINARIES
This section describes constraint hierarchies and
HCLP as preliminaries of our framework.
3.1 Constraint Hierarchies
In constraint hierarchies (Borning et al., 1992), each
constraint is associated with a hierarchical preference
called a strength. A constraint hierarchy is divided
into a finite number of levels. Each level consists
of constraints with the equal strength correspond-
ing to the level. The top level contains required (or
hard) constraints that must always be satisfied, and
lower levels contain preferential (or soft) constraints
that should be relaxed if necessary. The strengths
of constraints are usually represented symbolically as
required, strong, medium, and weak. In this paper, we
omit the explicit specification of required, expressing
required constraints as ones without the specification
of strengths.
Solutions to constraint hierarchies are obtained by
the optimization concerning solution candidates. For
this purpose, a relation called comparator is used to
judge which of two solution candidates is better. So-
lution sets differ according to comparators, and there
have been various comparators proposed. In this pa-
per, we use the comparator called unsatisfied-count-
better (UCB) that evaluates solution candidates to in-
crease satisfied stronger constraints.
3.2 HCLP
HCLP (Wilson and Borning, 1993) is an extension
of CLP (Jaffar and Lassez, 1987; Jaffar and Maher,
1994) that incorporates constraint hierarchies. Rules
in HCLP hold constraints in the bodies of the Horn
clauses in the same way as CLP, and furthermore con-
straints can be associated with strengths. The deriva-
tion of a goal (that is a successful sequence of reduc-
tions) is performed in the same way as CLP, and the
solution is computed by solving the constraint hierar-
chy obtained when the goal becomes empty of atoms.
In general, derivations for different branches ob-
tain different constraint hierarchies that also have con-
straints with different strengths. Therefore, HCLP ob-
tains the best solutions by further performing inter-
ICAART 2023 - 15th International Conference on Agents and Artificial Intelligence
290

hierarchy comparison that judges which of two con-
straint hierarchies is better satisfied.
4 PROPOSED FRAMEWORK
In this section, we propose a framework that uses
HCLP for speculative computation for MASs. We
first propose how to specify MASs in HCLP and then
how to perform speculative computation for MASs.
4.1 Specification of MASs
Our framework uses HCLP as a basis for the specifi-
cation of MASs. A MAS forms a tree structure, and
the agent corresponding to the root node is called the
root agent. The root agent starts the execution of the
MAS, and returns a tentative solution whenever it is
obtained by speculative computation. The users who
give information to a MAS in execution are also re-
garded as agents, and correspond to the leaf nodes of
the tree. The agents representing the users are called
the external agents, and the other agents are called the
internal agents.
Formally, the structure of a MAS is specified with
an agent hierarchy in the same way as the previous
work on hierarchical agents.
Definition 1 (agent hierarchy (Hosobe et al., 2010)).
An agent hierarchy H is a tree consisting of a set of
nodes called agents. Let root(H) be the root node of
H, called the root agent. Let int(H) be the set of all
the non-leaf nodes of H, each called an internal agent.
Let ext(H) be the set of all the leaf nodes of H, each
called an external agent. Given an internal agent M,
let chi(M,H) be the set of all the child nodes of M,
each called a child agent of M. Given a non-root agent
S, let par(S,H) be the parent node of S, called the
parent agent of S.
Figure 1 depicts the agent hierarchy of a MAS
consisting of five agents r,a,b,a
0
, and b
0
. Here r is
the root agent, r,a, and b are the internal agents, and
a
0
and b
0
are the external agent. Also, a and b are the
child agents of r (and r is the parent agent of a and
b), a
0
is the child agent of a (and a is the parent of a
0
),
and b
0
is the child agent of b (and b is the parent of
b
0
).
Agents are assigned HCLP programs extended in
the following way.
• Each internal agent has a program consisting of
rules that describe how it is executed, and of rules
that describe the default knowledge of its child
agents.
!
" "#
$ $#
Figure 1: A MAS with a root agent r, non-root internal
agents a and b, and external agents a
0
and b
0
.
• Each external agent initially has no program. To
reply to a query from its parent agent, it is dynami-
cally assigned a rule that is generated by the corre-
sponding user according to the user’s own knowl-
edge. In addition, the program can be dynamically
revised when the user’s knowledge changes.
For each agent M, a rule in the program of M is a
Horn clause described with a head H, required and/or
preferential constraints C, and atoms B
1
,B
2
,...,B
n
in
the following form:
H ← C ||B
1
,B
2
,...,B
n
Each atom is expressed as either p(t
1
,t
2
,...,t
n
)@M
called a non-askable atom or p(X
1
,X
2
,...,X
n
)@S
called an askable atom, where S is a child agent of
M, p is a predicate symbol, t
1
,t
2
,...,t
n
are terms, and
X
1
,X
2
,...,X
n
are variables. Each constraint is either
required or preferential.
The problem that should be solved concerning a
MAS is called a goal, which is expressed as an ask-
able atom p(X
1
,X
2
,..., X
n
)@r for the root agent r. A
solution to the problem is expressed as a valuation of
variables X
1
,X
2
,..., X
n
. In general, there exist multi-
ple solutions to a problem, and the set of all the solu-
tions is called the solution set.
We use preferential constraints to express default
knowledge. Typically, we use weaker constraints for
agents closer to the root, using the strongest con-
straints for the external agents.
Formally, a MAS is defined with an agent hier-
archy and a set of the programs associated with the
agents in the hierarchy.
Definition 2 (MAS). A MAS is a pair hH,P i, where
H is an agent hierarchy, and P is a set of programs P
M
of M ∈ int(H) ∪ ext(H).
Now we show an example of describing a MAS
by using our framework. It reserves a twin or sin-
gle room by checking the availabilities of two users,
which we construct by rewriting the example given in
the previous work (Hosobe et al., 2010).
Example 1. Consider a MAS hH,P i, where H is the
agent hierarchy depicted in Figure 1, and P is the set
of the following programs P
r
,P
a
,P
b
,P
a
0
, and P
b
0
.
• The programs P
r
,P
a
, and P
b
of the internal agents
r,a, and b respectively are defined as follows.
Hierarchical Constraint Logic Programming for Multi-Agent Systems
291

– Program P
r
of r:
reserve(R,L,D)@r ←
R = twin room,L = [a,b]||
available(D)@a,available(D)@b
reserve(R,L,D)@r ←
R = single room,L = [a]||
available(D)@a,unavailable(D)@b
reserve(R,L,D)@r ←
R = single room,L = [b]||
unavailable(D)@a,available(D)@b
available(D)@a ← weak D ∈ {1,2,3}||
available(D)@b ← weak D ∈ {1,2,3}||
– Program P
a
of a:
available(D)@a ← ||free(D)@a
0
unavailable(D)@a ← ||busy(D)@a
0
free(D)@a
0
← medium D ∈ {1, 2} ||
busy(D)@a
0
← medium D ∈ {3} ||
– Program P
b
of b:
available(D)@b ← ||free(D)@b
0
unavailable(D)@b ← ||busy(D)@b
0
free(D)@b
0
← medium D ∈ {2} ||
• The programs P
a
0
and P
b
0
of the external agents a
0
and b
0
respectively indicate their answers, and are
defined with the rules with strong constraints. For
example, P
a
0
is defined as
/
0 (i.e., no answers), and
P
b
0
is defined as follows.
– Answer P
b
0
of b
0
:
free(D)@b
0
← strong D ∈ {2,3}||
The intuitive meaning of this example is as fol-
lows. Agents a
0
and b
0
are the external ones corre-
sponding to the two users. Agents a and b are the in-
ternal ones that automatically answer to a posed query
by using their default knowledge as well as by asking
a
0
and b
0
about their actual availabilities respectively.
Agent r is the root that processes the entire coordina-
tion by asking a and b about their availabilities. The
programs of r,a, and b and the answer of b
0
can be
understood as follows.
• Program P
r
of r reserves a twin room for the day
when both a and b are available, and reserves a
single room for the day when only one of them
is available. In addition, it has default knowledge
that a and b are available on days 1, 2, and 3.
• Program P
a
of a answers the availability of a
0
to
the query of r. In addition, it has default knowl-
edge that a
0
is free on days 1 and 2 and is busy on
day 3.
• Program P
b
of b answers the availability of b
0
to
the query of r. In addition, it has default knowl-
edge that b
0
is free on day 2.
• Answer P
b
0
of b
0
replies to the query of b that this
user is free on days 2 and 3.
1: P ← P
r
2: hΘ,Φi ← solve(Q@r,P,
/
0)
3: Output Θ as the initial answer
4: loop
5: Await an answer P
0
from a child
6: P ← P ∪ P
0
7: hΘ,Φi ← solve(Q@r,P,Φ)
8: Output Θ as a revised answer
9: end loop
Figure 2: Algorithm of root agent r with program P
r
for
processing goal Q@r.
This example uses strong, medium, and weak as
the strengths of the preferential constraints in the de-
fault knowledge, more specifically using strong for a
0
and b
0
, medium for a and b, and weak for r. It makes
the MAS treat the knowledge of the actual users a
0
and b
0
by the highest priority, the default knowledge
of a and b working for the individual users by the next
highest priority, and the default knowledge of r work-
ing for the entire coordination by the lowest priority.
4.2 Speculative Computation for MASs
We present how to perform speculative computation
for MASs in our framework. The execution is started
by submitting a goal to the root agent of a MAS. Dur-
ing the execution, internal agents send askable atoms
to their child agents when necessary, and the chil-
dren answer to their parents by returning the neces-
sary rules for the derivation of the askable atoms.
Given a MAS hH,P i, the root agent r = root(H) is
executed basically in the same way as ordinary HCLP.
The main difference is that it revises its program P
with the progress of the execution of the MAS. The
execution of the MAS is started by submitting a goal
Q@r to r. Initially, P is the same as the program P
r
of r. After computing the solution set of P for Q@r, r
outputs it as the initial answer, and moves to the wait-
ing state. When r receives an answer from a child
agent of it, it updates P by adding the answer, recom-
putes the solution set of P for Q@r, outputs it as a
revised answer, and moves to the waiting state again.
Figure 2 shows this algorithm.
When root agent r computes a solution set, it pro-
cesses each atom as follows.
• If the atom is a non-askable one for r, it is pro-
cessed in the same way as ordinary HCLP.
• If the atom is an askable one, p(X
1
,X
2
,...,
X
n
)@a, for a child agent S of r, it is processed
as follows.
1. If r has not yet processed this askable atom, r
ICAART 2023 - 15th International Conference on Agents and Artificial Intelligence
292

1: Φ
0
← Φ
2: Ψ ←
/
0
3: for each “Q@r ← C ||B
1
,...,B
n
” in P do
4: C
0
← C
5: for i ← 1 to n do
6: if B
i
is an askable atom Q@S for a child S of
r and Q@S /∈ Φ
0
then
7: Send Q@S to S
8: Φ
0
← Φ
0
∪ {Q@S}
9: end if
10: Update C
0
by processing B
i
in the same way
as ordinary HCLP
11: end for
12: Ψ ← Ψ ∪ {C
0
}
13: end for
14: Compute the best solutions Θ to Ψ by performing
the inter-hierarchy comparison
15: return hΘ,Φ
0
i
Figure 3: Algorithm solve(Q@r, P,Φ) of root agent r for
computing the solution set of program P for goal Q@r and
processed askable atoms Φ.
sends it to S.
2. The atom is processed in the same way as ordi-
nary HCLP.
After completing the derivations for all the branches,
r computes the best solutions by performing the inter-
hierarchy comparison. Figure 3 shows this algorithm,
where Φ indicates the set of the processed askable
atoms.
A non-root internal agent M ∈ int(H) \ {root(H)}
is normally in the waiting state. When it receives an
askable atom from its parent agent par(M), it collects
all the necessary rules for the derivation and sends
them as an answer to the parent. In addition, if the col-
lected rules include an askable atom for a child agent
of S ∈ chi(M), it sends the askable atom to the child.
When it receives an answer from the child, it further
returns the answer to the parent. Figure 4 shows this
algorithm.
When external agent S ∈ ext(H) receives an ask-
able atom from its parent agent par(S), it dynamically
generates a rule based on its own knowledge, and re-
turns the rule as an answer to the parent. It is not nec-
essary to immediately return the answer. Also, if it
wants to revise the answer that it previously returned,
it generates a new rule by using a stronger preferential
constraint, and returns to the parent.
1: Φ ←
/
0
2: loop
3: Await an askable atom Q@M from par(M) or
an answer P
0
from S ∈ chi(M)
4: if Q@M was received from par(M) then
5: Collect all the necessary rules P ⊆ P
M
for the
derivation of Q@M
6: for each “Q@M ← C || B
1
,...,B
n
” in P do
7: for i ← 1 to n do
8: if query B
i
is an askable atom Q@S for
S ∈ chi(M) and Q@S /∈ Φ then
9: Send Q@S to S
10: Φ ← Φ ∪ {Q@S}
11: end if
12: end for
13: end for
14: Send P to par(M)
15: else // P
0
was received from S
16: Send P
0
to par(M)
17: end if
18: end loop
Figure 4: Algorithm of a non-root internal agent M with
program P
M
for processing askable atom Q@M.
5 IMPLEMENTATION
We implemented a prototype MAS processor based
on our framework in the Scala language. In addition,
we constructed an algorithm for solving constraint hi-
erarchies that is necessary for processing HCLP pro-
grams, and implemented the solver by using the satis-
fiability modulo theories (SMT) solver Z3 (de Moura
and Bjørner, 2008). The MAS processor and the con-
straint hierarchy solver consist of approximately 700
lines of code in total.
6 CASE STUDY
In this section, we illustrate the execution of the MAS
in Example 1 as a case study on how our framework
works. It is started with a goal reserve(R,L, D)@r for
root agent r (Figure 5(a)).
Initially, agent r holds only P
r
as the internal pro-
gram P. It obtains the following initial tentative so-
lution set by processing this P, which is an effect of
speculative computation (Figure 5(b)).
R=twin_room, L=[a,b], D=1
R=twin_room, L=[a,b], D=2
R=twin_room, L=[a,b], D=3
These were obtained from the default knowledge
Hierarchical Constraint Logic Programming for Multi-Agent Systems
293

(a)
!
" "#
$ $#
!"#"!$" !" #" $ %&
(b)
!
" "#
$ $#
! " !"#$%&''(#
$ " %# & # ' " (
! " !"#$%&''(#
$ " %# & # ' " )
! " !"#$%&''(#
$ " %# & # ' " *
)*)#+),+- ' +%
.$)*)#+),+- ' +%
)*)#+),+-
' +&
.$)*)#+),+-
' +&
(c)
!
" "#
$ $#
! " !"#$%&''(#
$ " %# & # ' " (
! " !"#$%&''(#
$ " %# & # ' " )
)*)#+),+- ' *%
+ ,, .&-- ' *%-
.&--
' *%-
+ (-/#0( ' . (# ) ,,
.&--
' *%-
(d)
!
" "#
$ $#
! " !"#$%&''(#
$ " %# & # ' " (
! " !"#$%&''(#
$ " %# & # ' " )
)$*+*#,*-,. ' *%
+ ,, -)/0 ' *%-
-)/0
' *%-
+ (.1#)( ' . / ,,
-)/0
' *%-
! " /#$2,.%&''(#
$ " & # ' " /
(e)
!
" "#
$ $#
! " !"#$%&''(#
$ " %# & # ' " (
)&**
' )&*
+,+#-+.-*
' )&
+ ,, )&** ' )&*
)&** ' )&*
+ (*/#0( ' -
( ,,
(f)
!
" "#
$ $#
! " !"#$%&''(#
$ " %# & # ' " (
)*+,
' )&**$-.-#/-)/0 ' )&
+ ,, )*+,
' )&*
(g)
!
" "#
$ $#
! " !"#$%&''(#
$ " %# & # ' " (
! " )#$*+,%&''(#
$ " & # ' " )
-&,,
' *&+
, (,.#/( ' -
( ..
-&,,
' *&+
, (,.#/( ' -
( ..
Figure 5: Execution of the MAS in Example 1.
of r meaning that both a and b are available
on days 1, 2, and 3. Also, note that, during
this process, r sent askable atoms available(D)@a
and unavailable(D)@a to its child agent a, and
available(D)@b and unavailable(D)@b to its child
agent b.
Next, suppose that agent a returns
rules available(D)@a ← ||free(D)@a
0
and
free(D)@a
0
← medium D ∈ {1, 2} || by answer-
ing to the query available(D)@a of r. Then r updates
P by merging these rules, and obtains the following
revised tentative solution set by processing the
updated P (Figure 5(c)).
R=twin_room, L=[a,b], D=1
R=twin_room, L=[a,b], D=2
These reflect part of the default knowledge of a
meaning that a
0
is free on days 1 and 2. Note
that this revised answer dropped the reserve of a
room for day 3 because free(D)@a
0
← medium D ∈
{1,2}|| (originally in P
a
) has a stronger constraint
than available(D)@a ← weak D ∈ {1, 2, 3} || (orig-
inally in P
r
). Also, note that a sent askable atom
free(D)@a
0
to its child agent a
0
.
Next, suppose that agent a returns rules
unavailable(D)@a ← ||busy(D)@a
0
and
busy(D)@a
0
← medium D ∈ {3} || by answer-
ing to the query unavailable(D)@a of r. Then r
updates P and obtains the following revised solution
set (Figure 5(d)).
R=twin_room, L=[a,b], D=1
R=twin_room, L=[a,b], D=2
R=single_room, L=[b], D=3
These reflect other part of the default knowledge of
a meaning that a
0
is busy on day 3, introducing the
reserve of a single room for day 3. Also, note that a
sent askable atom busy(D)@a
0
to a
0
.
Next, suppose that agent b returns
rules available(D)@b ← ||free(D)@b
0
and
free(D)@b
0
← medium D ∈ {2}|| by answering
to the query available(D)@b of r. Then r up-
dates P and obtains the following revised solution
(Figure 5(e)).
R=twin_room, L=[a,b], D=2
This reflects the default knowledge of b meaning
that b
0
is free on day 2. Note that this answer
dropped the reserve of rooms for days 1 and 3 be-
cause free(D)@b
0
← medium D ∈ {2}|| (originally in
P
b
) has a stronger constraint than available(D)@b ←
weak D ∈ {1,2,3}|| (originally in P
r
). Also, note that
b sent askable atom free(D)@b
0
to its child agent b
0
.
Next, suppose that agent b returns rule
unavailable(D)@b ← ||busy(D)@b
0
by answer-
ing to the query unavailable(D)@b of r. Then
r updates P and obtains the following solution
(Figure 5(f)).
ICAART 2023 - 15th International Conference on Agents and Artificial Intelligence
294

R=twin_room, L=[a,b], D=2
This is the same as the previous one because b does
not have default knowledge about busy(D)@b
0
. Note
that b sent askable atom busy(D)@b
0
to b
0
.
Finally, suppose that agent b
0
returns
free(D)@b
0
← strong D ∈ {2,3}|| by answer-
ing the query free(D)@b
0
of b, which follows that b
further sends it to r. Then r updates P and obtains the
following solution (Figure 5(g)).
R=twin_room, L=[a,b], D=2
R=single_room, L=[b], D=3
These reflect the own knowledge of b
0
meaning that
this user is free on days 2 and 3.
7 DISCUSSION
Our main point in this work was to devise a simplified
framework for speculative computation for MASs. As
described in Section 1, the previous frameworks be-
came complicated. It should be noted that this com-
plication caused other problems. One obvious prob-
lem is that the resulting frameworks were difficult
to implement. Another problem is that it was diffi-
cult to theoretically investigate properties of the re-
sulting frameworks; in fact, the proof of the correct-
ness of the algorithm associated with such a frame-
work was a huge task (see, e.g., the appendix of
(Hosobe et al., 2010), which provides the proofs of
the soundness and the completeness of the given al-
gorithm). Another problem is that it is to difficult to
devise a more powerful framework by extending such
a complicated framework. The complication occurred
because the previous frameworks were achieved by
performing speculative computation and default rule
handling within the same mechanisms.
To solve the complication problem, we adopted a
different approach. We separated speculative compu-
tation and default rule handling to devise our frame-
work. For default rule handling, we based our frame-
work on HCLP instead of CLP, which was used
in several studies on speculative computation for
MASs (Ceberio et al., 2006; Hosobe et al., 2007;
Hosobe et al., 2010; Ma et al., 2010b; Satoh et al.,
2003). By this, we realized default rule handling
declaratively rather than operationally, which is a pri-
mary cause of the simplification. To enable specula-
tive computation for MASs, we constructed a com-
putational mechanism where agents in a hierarchical
MAS progressively exchange necessary information
to speculatively compute tentative answers. The re-
sulting computational mechanism also is sufficiently
simple, and it is easy to understand what operations
the agents perform in the course of speculative com-
putation. Also, it should be noted that our frame-
work treats hierarchical MASs and default constraints
in a similar way to the work (Hosobe et al., 2010),
which was one of the most advanced (and compli-
cated) frameworks for speculative computation for
MASs.
We consider that the expressive power of our
framework is higher than those of the previous CLP-
based MAS frameworks. This is because our frame-
work is based on HCLP, which allows us to more
freely associate preferences with default constraints,
unlike the previous CLP-based frameworks that em-
bedded default constraint handling in their special-
ized computational mechanisms. However, we have
not yet clarified how our framework is more power-
ful than the previous ones. To explore the expres-
sive power of our framework, it is necessary to ex-
perimentally explore how preferences of constraints
can be utilized to model and process various MASs.
Also, it is necessary to theoretically clarify relations
of our framework with the previous CLP-based one
for speculative computation for MASs, which needs
to formally present and prove theorems about the re-
lations. In addition, it is necessary to investigate how
our framework is related with other previous frame-
works than the CLP-based ones.
8 CONCLUSIONS AND FUTURE
WORK
We proposed an HCLP-based framework for specu-
lative computation for MASs. While the previous
frameworks were based on CLP and were compli-
cated, we used HCLP with constraint hierarchies to
express the default knowledge of agents and to real-
ize speculative computation for MASs, which simpli-
fied our framework. We also presented the prototype
implementation of our framework and illustrated the
execution of an example based on our framework.
Our future work is to explore the expressive power
of our framework. More specifically, we will ex-
perimentally investigate the modeling and processing
of various and more complex MASs in our frame-
work. Also, we will clarify relations of our frame-
work with previous CLP-based frameworks for spec-
ulative computation for MASs, for which we will for-
mally present and prove theorems about the relations.
In addition, we will improve the speculative computa-
tion of our framework. For this purpose, by incorpo-
rating incremental computation as in previous related
work, we will improve the efficiency of recomputing
solutions after obtaining tentative ones.
Hierarchical Constraint Logic Programming for Multi-Agent Systems
295

ACKNOWLEDGMENT
This work was supported by JST AIP Trilateral AI
Research Grant Number JPMJCR20G4.
REFERENCES
Borning, A., Freeman-Benson, B., and Wilson, M. (1992).
Constraint hierarchies. Lisp Symbolic Comput.,
5(3):223–270.
Ceberio, M., Hosobe, H., and Satoh, K. (2006). Speculative
constraint processing with iterative revision for dis-
junctive answers. In Post-proc. CLIMA, volume 3900
of LNAI, pages 340–357.
de Moura, L. and Bjørner, N. (2008). Z3: An efficient SMT
solver. In Proc. TACAS, volume 4963 of LNCS, pages
337–340.
Dorri, A., Kanhere, S. S., and Jurdak, R. (2018). Multi-
agent systems: A survey. IEEE Access, 6:28573–
28593.
Gomes, M., Oliveira, T., and Novais, P. (2016). A specu-
lative computation approach for conflict styles assess-
ment with incomplete information. In Proc. IDC, vol-
ume 678 of SCI, pages 163–172.
Hayashi, H., Cho, K., and Ohsuga, A. (2002). Speculative
computation and action execution in multi-agent sys-
tems. In Proc. CLIMA, volume 70-5 of ENTCS, pages
153–166.
Hosobe, H., Satoh, K., and Codognet, P. (2007). Agent-
based speculative constraint processing. IEICE Trans.
Inf. & Syst., E90-D(9):1354–1362.
Hosobe, H., Satoh, K., Ma, J., Russo, A., and Broda, K.
(2010). Speculative constraint processing for hierar-
chical agents. AI Comm., 23(4):373–388.
Inoue, K. and Iwanuma, K. (2004). Speculative computa-
tion through consequence-finding in multi-agent envi-
ronments. Ann. Math. Artif. Intell., 42(1–3):255–291.
Inoue, K., Kawaguchi, S., and Haneda, H. (2001). Control-
ling speculative computation in multi-agent environ-
ments. In Proc. CLIMA, pages 9–18.
Iwanuma, K. and Inoue, K. (2002). Conditional answer
computation in SOL as speculative computation in
multi-agent environments. In Proc. CLIMA, volume
70-5 of ENTCS, pages 167–182.
Jaffar, J. and Lassez, J.-L. (1987). Constraint logic pro-
gramming. In Proc. ACM POPL, pages 111–119.
Jaffar, J. and Maher, M. (1994). Constraint logic pro-
gramming: A survey. J. Log. Program., 19–
20(Supp. 1):503–581.
Kowalski, R. and Sadri, F. (1999). From logic programming
towards multi-agent systems. Ann. Math. Artif. Intell.,
25:391–419.
Lam, H.-P., Governatori, G., Satoh, K., and Hosobe, H.
(2012). Distributed defeasible speculative reasoning
in ambient environment. In Proc. CLIMA, volume
7486 of LNAI, pages 43–60.
Lloyd, J. W. (1987). Foundations of Logic Programming.
Springer, 2nd edition.
Ma, J., Broda, K., Goebel, R., Hosobe, H., Russo, A., and
Satoh, K. (2010a). Speculative abductive reasoning
for hierarchical agent systems. In Proc. CLIMA, vol-
ume 6245 of LNAI, pages 49–64.
Ma, J., Russo, A., Broda, K., Hosobe, H., and Satoh, K.
(2010b). On the implementation of speculative con-
straint processing. In Post-proc. CLIMA, volume 6214
of LNAI, pages 178–195.
Oliveira, T., Neves, J., Novais, P., and Satoh, K. (2014).
Applying speculative computation to guideline-based
decision support systems. In Proc. IEEE CBMS, pages
42–47.
Oliveira, T., Satoh, K., Novais, P., Neves, J., and Hosobe,
H. (2017). A dynamic default revision mechanism for
speculative computation. Auton. Agent Multi-Agent
Syst., 31(3):656–695.
Oliveira, T., Satoh, K., Novais, P., Neves, J., Le
˜
ao, P.,
and Hosobe, H. (2015). A reasoning module for dis-
tributed clinical decision support systems. In Proc.
IDC, volume 616 of SCI, pages 387–397.
Ramos, J., Novais, P., Satoh, K., Oliveira, T., and Neves, J.
(2015a). Speculative orientation and tracking system.
Int. J. Artif. Intell., 13(1):94–119.
Ramos, J., Oliveira, T., Novais, P., Neves, J., and Satoh, K.
(2015b). An alert mechanism for orientation systems
based on speculative computation. In Proc. INISTA,
pages 1–8. IEEE.
Ramos, J., Oliveira, T., Satoh, K., Neves, J., and Novais,
P. (2016). Orientation system based on speculative
computation and trajectory mining. In Proc. PPAMS
Workshops, volume 616 of CCIS, pages 250–261.
Ramos, J., Satoh, K., Novais, P., and Neves, J. (2014). Mod-
elling an orientation system based on speculative com-
putation. In Proc. DCAI, volume 290 of AISC, pages
319–326.
Sakama, C., Inoue, K., Iwanuma, K., and Satoh, K. (2000).
A defeasible reasoning system in multi-agent environ-
ments. In Proc. CLIMA, pages 1–6.
Satoh, K. (2005). Speculative computation and abduction
for an autonomous agent. IEICE Trans. Inf. & Syst.,
E88-D(9):2031–2038.
Satoh, K., Codognet, P., and Hosobe, H. (2003). Specula-
tive constraint processing in multi-agent systems. In
Proc. PRIMA, volume 2891 of LNAI, pages 133–144.
Satoh, K., Inoue, K., Iwanuma, K., and Sakama, C. (2000).
Speculative computation by abduction under incom-
plete communication environments. In Proc. ICMAS,
pages 263–270.
Satoh, K. and Yamamoto, K. (2002). Speculative computa-
tion with multi-agent belief revision. In Proc. AAMAS,
pages 897–904.
Sycara, K. P. (1998). Multiagent systems. AI Mag.,
19(2):79–92.
Vlahavas, I. (2002). MACLP: Multi agent constraint logic
programming. Information Science, 144:127–142.
Wilson, M. and Borning, A. (1993). Hierarchical constraint
logic programming. J. Log. Program., 16(3–4):227–
318.
ICAART 2023 - 15th International Conference on Agents and Artificial Intelligence
296