Computing Mobile Agent Routes with Node-Wise

Computing Mobile Agent Routes with Node-Wise Constraints in Distributed Communication Systems Amir Elalouf1 , Eugene Levner1,2, and T.C. Edwin Cheng3 1

Bar Ilan University, Ramat Gan, Israel [email protected],il 2 Ashkelon Academic College, Ashkelon, Israel [email protected] 3 The Hong Kong Polytechnic University, Hong Kong [email protected]

Abstract. A basic problem in the quality-of-service (QoS) analysis of multiagent distributed systems is to find optimal routes for the mobile agents that incrementally fuse the data as they visit hosts in the distributed system. The system is modeled as a directed acyclic graph in which the nodes represent hosts and the edges represent links between them. Each edge is assigned a cost (or benefit) and weights that represent link delay, reliability, or other QoS parameters. The agent scheduling problem is viewed as a constrained routing problem in which a maximum-benefit (or minimum-cost) route connecting the source and the destination subject to QoS constraints is to be found. We study approximation algorithms called ‘fully polynomial time approximation schemes’ (FPTAS) for solving the problem. We suggest an accelerating technique that improves known FPTAS, e.g., Hassin’s (1992); Camponogara & Shima’s (2010); and Elalouf et al. (2011) algorithms, and present new FPTASs. Keywords: Multi-agent distributed systems, Mobile agent, Agent routing, Routing algorithm, FPTAS, Acceleration technique.

1

Introduction

The problems considered in this paper arise in distributed communication and manufacturing systems in which mobile agents incrementally fuse the data as they visit hosts in the system. Agent-based computing has been appraised as ‘a new revolution in software’ ([1]). More than that, according to Torsun [2], the entire area of distributed artificial intelligence can be viewed as ‘the cooperative problem solving using a federation of collaborating agents’. In the context of distributed communication and manufacturing systems, we define an agent as a software system that communicates and cooperates with other human or software systems to solve a complex problem that is beyond the capability of each individual system and such a system is capable of autonomous actions, without the direct intervention of human beings or other agents. A multi-agent system is defined as a loosely coupled network of agents that work together to solve problems that are beyond the individual capabilities or knowledge of I. Batyrshin and G. Sidorov (Eds.): MICAI 2011, Part I, LNAI 7094, pp. 76–87, 2011. © Springer-Verlag Berlin Heidelberg 2011

Computing Mobile Agent Routes with Node-Wise Constraints

77

each agent. This definition is compatible with similar definitions given by Jennings and Wooldridge [3] and Shen et al. [4]. An autonomous agent-based distributed manufacturing or communication network is a system that is able to function without the direct intervention of human beings or other agents in some environments, and that has control over its own actions and internal states. Establishing the notion of mobile agents in 1994, White [5] describes a computational environment known as “Telescript” in which running programs are able to transport themselves from host to host in a computer network. Tsichritzis [6] suggests the notion of mobile computation by describing a hypothetical computing environment in which all the objects could be mobile. Within the scope of this paper, we follow the concepts in [5-6] and define a mobile intelligent agent (or, briefly, migent) as a computer program that is able to autonomously migrate from one host to another in a computer network, at times and to places of their own choosing, and to collaborate with each other. These collaborating agents are intelligent in the sense that they are adaptive, autonomous, cooperative, and capable of behaving reasonably in different environments. Each migent behaves in accordance with its own goal and executes its tasks in cooperation with other agents in order to achieve the goal. Such agents can learn and adapt to changes in dynamic environments. In this context, mobile agents differ from ‘applets’, which are programs downloaded as the result of a user action, then executed from beginning to end on one host. Mobile agent-based technologies have been used in manufacturing and communication for more than two decades [8-11]. In particular, intelligent agents and multi-agent systems and a myriad of applications have been built in various domains ranging from comparatively small systems such as failure detectors in intranets to complex, mission critical systems such as the military operation control. For instance, in order to ensure the minimum power consumption and to decrease the communication bandwidth, the mobile agents are widely used in distributed sensor networks wherein they selectively visit the sensors and incrementally fuse the appropriate measurement data [10, 11]. Other typical examples of real-life mobile agents, which are most known today, are cell phones, manned/unmanned aerial/ground vehicles equipped with a sophisticated software, and web-crawlers (a goal-oriented web robots aiming at discovering/ collecting a requested information in the Internet). In a typical application, a mobile agent visits several hosts in a network in order to complete its mission. The hosts provide information and also activities, services, and inter-agent communications. All the services and information are available at different sites and in different forms, levels of accuracy, and degrees of reliability. A given benefit function determines how much benefit each site contributes to an agent’s mission. The benefit function can be defined and measured differently, depending on the application. For example, it can be the information value or cost in monetary units while in other cases it is the data volume retrieved from different hosts. Since different sites may yield information at many different degrees of benefit, the mobile agent should find a best possible itinerary to visit them under resource constraints. The problem of enhancing the efficiency of mobile agents then reduces to the problem of finding resource-constrained extremal paths in a graph. The mobile agent’s routing

78

A. Elalouf, E. Levner, and T.C.E. Cheng

problem consists in finding an information- or resource-constrained route for each agent in a multi-agent system that provides the best system performance. In this paper we investigate different versions of the mobile agent routing problems and develop a general three-stage technique for their efficient solution. Our technique follows and extends the earlier computational scheme suggested by Gens and Levner for the knapsack problem [12, 13]. This three-stage scheme, being originated in the early 1980s, gave excellent possibilities for constructing the FPTASs for solving the constrained routing problems (which has been done by Hassin [14], Goel et al. [15], Xue et al. [16], Lorenz and Raz [17], and Ergun et al. [18], among many others). Recently, using a similar technique, Elalouf et al. [7] improved the routing algorithms by Camponagaro and Shima [19] and Hassin [14] and, also, obtained new fast algorithms for several single-constrained routing problems. The contribution of this paper is two-fold. First, we introduce more general (and more practical) mobile agent routing problems containing multiple node-wise constraints and imposing QoS requirements upon all intermediate nodes in a route. Second, we further develop and improve the three-stage FPTAS technique suggested in [7]. In the next section we define the problems. In Section 3 we suggest new FPTAS algorithms. Section 4 concludes the paper.

2

Problem Formulation

Following Wu et al. [11] and Camponogara and Shima [19], we address the routing problem for mobile agents aimed to fuse data in distributed networks. Rather than collecting data at a single site, the mobile agent traverses the network and fuses data. Its goal is to perform the information-collection process as efficient as possible. There exist several basic formulations of such quality-of-service-oriented optimization problems each one being dependent, on the one hand, on the form of the objective function (either maximization or minimization) and on the sign of inequality in the constraints (either ≤ , or ≥), on the other hand. The first problem to be considered is the following: Problem P1. To maximize the total benefit generated from agent travel subject to the condition that the total transit time (also called a delay) does not exceed a given threshold. Such a problem having a single constraint limiting the delay at the destination node only has been studied by Camponogaro and Shima [19]. The problem framework is based on a network (acyclic graph) G = (V, E) consisting of a set V of nodes (representing the sites), a set E of edges (transmission links between the sites), a start node s, and a destination node t. Nodes in G are denoted by i (i = s, 2, …, t); edges in G are denoted by (i,j); |V| = n and |E| = m. Edge (i,j) is assigned integer parameters bij and rij, bij being the benefit of traversing the edge; specifically, it is the gathered information attributed to the edge; while rij being the transit time (delay) during agent’s move from node i to a next node j in a route, R is a given threshold (the total delay permitted at the destination). Benefit b(p) of a route p from the given node s to the given node t is defined as the

Computing Mobile Agent Routes with Node-Wise Constraints

79

sum of the benefits of the edges in the route; the delay r(pk) in a sub-route pk from s to any node k is defined as the sum of the delays at the edges of the sub-route. In the above notation, Problem P1 can be cast as follows: Problem P1. Maximize b(p) ≡ Σ(i,j) ∈ p bij, s.t. r(p) ≡ Σ(i,j) ∈ p rij ≤ R. We consider more general agent routing problems in which, instead of a single constraint related to the final node in a route, we introduce multiple constraints related to each node in the route. For instance, consider a route p = (s, v1, …, vh = t) from s to t; here h denotes the number of links (called "hops") in route p. A node-wise generalization of P1, denoted by PN1, is constructed as follows. Denote by pk a partial path from s to k ∈ V. For each node k, delay threshold Rk defines a time slot permitted to be spent by the agent in any partial path pk from s to vk. Exceeding this value may lead to excessive signal energy losses and other path losses (see [11, 19], for details). Delay thresholds R1, …, Rn being known in advance for each node in G(V, E), we require that in any partial path pk from s to k, k=1,…, h, delay should be at most Rk: Problem PN1. Maximize b(p) ≡ Σ(i,j) ∈ p bij, s.t. r(p, k) ≡ Σ(i,j) ∈ p(k) rij ≤ Rk, k = 1, …, h.

(1)

Here r(p, k) ≡ Σ(i,j) ∈ p rij, the left-hand side of constraint k, k=1, …, h, denotes the accumulated agent delay at node kin sub-route p(k) of p from s to k, and Rk are the maximum delays that are allowed to be accumulated in node k, k = 1, …, h. A FPTAS algorithm for PN1 is described in the next section. In the concluding part of the paper, we will discuss several modifications of PN1, in which the maximum is changed to minimum and ≤ in the constraint is substituted by ≥. We believe that the FPTASs for the modified problems can be developed, as well.

3

Algorithm Description

3.1

Dynamic Programming (DP) Algorithm

DP is a main building block of the FPTAS. We start with describing DP for PN1. Let us associate with each path p a pair (B, R), where B=b(p) is the path benefit and, respectively, R = R(p), the path delay. We deal with sets S(k) of pairs (B, R) arranged in increasing order of B-values so that every pair in S(k) corresponds to a path from a node s to a node k. In order to restore a path itself corresponding to a pair (B, R), we define a predecessor node to each node and use a standard backtracking. If there are two pairs in S(k), (B1,R1) and (B2, R2) such that B1 ≥ B2 and R1 ≤ R2, then the pair (B2, R2) is called dominated and may be discarded. Notice that graph G is acyclic (since we are solving the longest-path problem with respect to benefit with non-negative lengths, the problem with cycles does not have a finite solution). Then all the nodes can be topologically ordered (see [21,22] for the details). The exact polynomial time DP algorithm for PN1 is presented in Fig.1.

80

A. Elalouf, E. Levner, and T.C.E. Cheng

Algorithm 1.The exact pseudo-polynomial DP algorithm 1. Input. {(b(k, j), r(k, j) | (k,j) ∈ E}; R(k). 2. Output: A path with maximum benefit. 3. Step 1. [Initialization]. Set S(0,0) = {(0,0)}. 4. Step 2. [Generate S(1) to S(n)] 5. for all k ∈ V 6. S(k) ← ∅ ,T← ∅ $ Comment: T,G are temporary sets $ 7. for each arc e leading from node u to node k (denoted by u→k) 8. G←∅ 9. for each pair (B,R) ∈ S(u) corresponding to a path from s to u 10. do if R + r(u,k) ≤ R(k) then G ← G ∪ {(B+b(u,k), R+r(u,k))} 11. Endfor 12. T ←merge(T,G); during merging eliminate the dominated pairs 13. endfor 14. S(k)← T 15. end for 16. Step 3. Find a pair with max B in S(t). Use backtracking to find the optimal path. Fig. 1. The exact pseudo-polynomial DP algorithm

Lemma 1.The complexity of DP is O(mUB) where the upper bound UB is the total benefit of the max-benefit route from s to t. Proof: Since the benefits are integer and we discard dominated pairs, there is at most UB pairs in S(k) for any k. Further, constructing each G in Step 2 lines 8-11 requires O(UB) elementary operations. Indeed, in line 12, merging the sorted sets G and T, as well as discarding all the dominated pairs, are done in linear time (in the number of pairs, which is at most UB). In Step 2 we have a loop that goes over all the arcs, so in total we have O(m) iterations of lines 8-12. Thus, Algorithm 1 has the complexity of O(m UB) in total. □ 3.2

General Description of the FPTAS

Our general approach for constructing a FPTAS basically follows the so-called interval partitioning scheme first suggested by Sahni [20] for the min-cost knapsack problem and further developed by Gens and Levner [12, 13]. The main reason why we have used this approach is that the algorithmic scheme for partitioning routes is similar to that for the knapsack and it yields the desirable results. We suggest the improved scheme that consists of three main stages: We construct the FPTAS for the considered problem in three stages. Stage A: Find a lower bound LB and an upper bound UB such that UB/LB≤ n. Stage B: Improve the UB/LB ratio to UB/LB ≤ 2 using algorithms BOUNDS of complexity O(1) described below. Stage C: Having obtained an improved bound ratio, find an ε-approximate solution using the ε-approximation algorithm AA(LB,UB, ε).

Computing Mobile Agent Routes with Node-Wise Constraints

81

We implement this scheme by designing a FPTAS for PN1. Similar FPTAS algorithms for other routing problems can be derived along the same lines. 3.3

Stage A: Finding Preliminary Lower and Upper Bounds for PN1

A directed path p = (s, i1, …, ih= t) from node s to node t (denoted as the s-t path) is called feasible if all its sub-paths, from s to any k, satisfy (1), that is, r(p, k) ≡ Σ(i,j) ∈ p(k) rij ≤ Rk, k = 1, …, h. A forthcoming sub-procedure that we will use is the following reaching algorithm that propogates shortest distances from each (topologically ordered) node to higherindexed nodes. This algorithm works as follows. Set label d(s) = 0 and labels d(i) = ∞ for any other node i. Then examine the nodes in topological order. For each node w, scan all the arcs in the adjacency set A(i), which contains the arcs emanating out from node i. If for any arc (i, j) from A(i) we find that: (1) d(j) > d(i) + rij, and (2) d(i) + rij ≤ Rj, then set d(j) = d(i) + rij. Notice that condition (2) distinguishes our algorithm from standard reaching algorithms known in the literature (see, e.g., [21, 22]). When we have examined all the nodes once in this order, any finite label d(i) equals the minimum distance from s to i. If the final label d(i) = ∞ at a node i, this means that there is no feasible route to this node. In what follows, along with notation (i, j) we will use symbol e to denote a current arc of G. For a fixed arc eq (1≤ q ≤ m), define the constrained graph Gq as a graph that compulsotarily contains an arc of benefit ܾ௘೜ . This graph is needed in order to find a shortest (with respect to delays) path in G from s to t which is forced to pass through the eq = (i',j'). Let us denote this path by p*(i',j'). In order to find it, we can use the reaching algorithm that finds the minimum-delay sub-path from s to i' in G, adds arc (i', j) to the obtained sub-path and then finds for the shortest path from j' to t through the corresponding arcs of G. We will call the arc (i,j) right if the obtained path p*(i,j) is feasible. Now we can describe Stage A. It contains the following steps. Step A1. Find h, the number of hops in the longest (with respect to hops) s-t path in graph G. For this aim, we use the standard algorithm for finding the longest s-t path in the acyclic directed graph G (see, e.g. [21, 22]). Step A2. Order the arcs of G according to decreasing distinct benefit values be: b1 >b2 > … > bM, where M ≤ m.

(2)

Step A3. In the order defined by (2), define the constrained graphs Gq. Find a maximum index q* such that graph Gq* has no feasible path but Gq*+1 has. (Graph Gq must have a feasible path for at least one q otherwise the problem instance has no feasible solution). We have: LB = bq*+1 and UB = hbq*+1. The validity of the algorithm is verified by the following

82

A. Elalouf, E. Levner, and T.C.E. Cheng

Lemma 2. Let bq*+1 be the maximum benefit among all the right arcs of G, and eq*+1 the corresponding arc. Then bq*+1 ≤ b* ≤ hbq*+1. Proof: Since graph Gq*+1 has a feasible path passing through eq*+1 and its total benefit is not smaller than bq*+1, then the total maximal benefit b* must be larger or equal to this value: b* ≥ bq*+1. On the other hand, the optimal p* has at most h arcs, each having benefit at most bq*+1, thus the optimal path benefit is at most hbq*+1. So, bq*+1≤ b* ≤ nbq*+1. □ Lemma 3. The complexity of Stage A for PN1 is O(m2) time. Proof. Step A1 runs in O(m+n) time (see [21, 22]. Step A2 requires O(m log n) for sorting the arcs ; Step A3 requires O(m2) time in order to find shortest paths in at most m constrained graphs. In total, Stage A requires O(m2) time. □ 3.4

Stage B: Finding Improved Bounds for PN1

This stage has two building blocks: a test procedure and BOUNDS. 3.4.1 Test procedure Stage B contains two building blocks: Test(v, ε) and procedure BOUNDS. Test(v, ε) is a parametric dynamic-programming type algorithm has the following property: Given positive parameters v and ε, it either reports that the maximum possible benefit b* ≥ v, or, otherwise, reports that that b* ≤ v(1+ε). Actually, Test(v, ε) will be repeatedly applied as a sub-procedure in the algorithm BOUNDS below to narrow the gap between UB and LB until UB/LB ≤ 2. Test(v, ε) differs from many similar testing procedures known in the literature. Namely, to the best of our knowledge, all the earlier ε-tests for the constrained routing problems were based on the rounding and scaling operations (see, e.g., [14-18]) whereas our test is based on partitioning of the data. Associated with each path p is a pair (B, R), where R is the delay R(p) and, correspondingly, B = B(p), the path benefit. We deal with sets S(k) (k = 1,…, n) of pairs (B, R), defined above in the DP, arranged in increasing order of R values so that every pair in S(k) corresponds to a path from s to a node k. As in DP we delete all the dominated pair in all S(k) Given a δ , if there are two pairs in S(k), (B1, R1) and (B2, R2) , such that 0 ≤ B2 B1 ≤ δ , then the pairs are called δ -close. We use the operation called discarding δ –close from set S(k), which means the following: (a) Let v be a given parameter satisfying LB≤v≤UB. In each S(k), partition the interval [0, v] into ┌(n/ε)┐ equal subintervals of size no greater than δ= εv/n; one more interval is [v, UB] (b) if more than one pair from S(k) falls into any one of the above subintervals, then discard all such δ –close pairs, leaving only one representative pair in each subinterval, namely the pair with the smallest (in this subinterval) R-coordinate.

Computing Mobile Agent Routes with Node-Wise Constraints

83

Notice that in interval [v, UB] we leave only one representative pair, even if this interval is greater than δ . Algorithm Test(v,ε) is presented in Fig. 2. Lemma 4. The complexity of Test(v, ε) is O(mn/ε). Proof: Since in Test(v, ε) we partition interval [0,v] into ┌(n/ε)┐ subintervals, we have O(n/ε) representatives within each set S(k). Since we are going over all m arcs, the algorithm has to spend O(mn/ε) time in total. □ Algorithm 2.Test(v,ε) Input. {(b(k, j), r(k, j) | (k,j) ∈ E}; R(k),v,ε,δ= εv/n Step 1. [Initialization]. Set S(0,0) = {(0,0)}, Step 2. [Generate S(1) to S(n)] for all k ∈ V S(k) ← ∅ ,T← ∅ [Remark: T,G are temporary sets] for each arc e leading from node u to node k (denoted by u→k) G←∅ for each pair (B,R) ∈ S(u) corresponding to a path from s to u do if R + r(u,k) ≤ R(k) then G ← G ∪ {(B+b(u,k), R+r(u,k))} Endfor T ←merge(T,G); during merging eliminate the dominated and δ-close pairs endfor S(k)← T end for Step 3. Find a path in S(t), such that B ≥ v. If such a path is found in S(t), return b*≥v. If such a path cannot be found in S(t) return b*≤ v(1+ε). Fig. 2. The testing procedure Test(v, ε)

3.4.2 The Narrowing Procedure BOUNDS A narrowing procedure in this section originates from the procedure suggested by Ergun et al. [18] for solving the restricted shortest path problem with one constraint. In spite of the fact that we are solving a different problem, we use the key idea presented by Ergun et al.. Namely, when we run Test(v, ε) we choose ε to be a function of UB/LB changing from iteration to iteration. We use, for the reader’s convenience, the following notation. To distinguish the allowable error (ε) in the FPTAS and an iteratively changing error in the testing procedure, we denote the latter by θ; then, Algorithm 3 in Section 3.4.1 from now on will be named Test(v, θ). The idea is that when UB and LB are far from each other, we choose a large θ; when UB and LB get closer, we choose a smaller θ. More precisely, just as in Ergun et al. (2002), at each iteration of Test(v, θ), we set θ = UB LB − 1 whereas a new v value at each iteration takes v = LB ⋅ UB / (1 + θ ) .

84

A. Elalouf, E. Levner, and T.C.E. Cheng

Although BOUNDS for PN1 is similar to the corresponding narrowing algorithm of Ergun et al. []8] , we present it in Fig. 3 for the sake of completeness. Algorithm 3. BOUNDS

Input: LB and UB such that UB/LB ≤ n. Output: LB and UB such that UB/LB ≤ 2 If UB/LB ≤2 , Goto 7 Set θ = UB LB − 1 Set v ← LB ⋅UB / (1 + θ ) Run Test(v, θ ) If Test(v, θ ) returns b*≥v set LB← v else set UB ←v(1+ θ ) Go to 1 End Fig. 3. Algorithm BOUNDS

The complexity of BOUNDS is O(mn/ε). The proof is just the same as that of Theorem 6 in Ergun et al. [18] and is skipped here. 3.5

Stage C: The ε-Approximation Algorithm

Associated with each path p is a pair (B, R), where B is the path benefit b(p) and, correspondingly, R = R(p), the path resource consumption. We deal again with sets S(k) of pairs (B, R) as in the above algorithms DP and Test. As in DP and Test(v, ε) we delete all the dominated pairs in all S(k). In order to restore an ε-approximation path itself corresponding to a pair (B, R), we use a standard backtracking defining a predecessor node to each node in the path. We use the operation called discarding δ–close from set S(k), which means the following: (a) In each S(k), partition the interval [0, UB] into ┌(UB/LB)(n/ε)┐ equal subintervals of size no greater than δ= εLB/n; (b) If more than one pair from S(k) falls into any one of the above subintervals, then discard all such δ–close pairs, leaving only one representative pair in each subinterval, namely the pair with the smallest (in this subinterval) R-coordinate. The corresponding algorithm is presented in Fig. 4. Theorem 1.The complexity of AA(LB, UB, ε) is O(mn/ε). The complexity of the entire three-stage FPTAS for PN1 is O(mn/ε +m2).

Proof: Since the sub-interval length is δ= εLB/n, we have O(n(UB/LB)(1/ε)) subintervals in interval [0,UB]. Since there is at most one representative pair in each subinterval, we have in total O(n(UB/LB)(1/ε)) pairs in any of the sets G, T, and S(k), for any k. Further, constructing each G in lines 10-12 in Fig. 4 requires O(n(UB/LB)(1/ε))

Computing Mobile Agent Routes with Node-Wise Constraints

85

elementary operations. Merging the sorted sets G and T as well as discarding all the dominated and δ -close pairs in line 12 are done in linear (in the number of pairs) time. Since G and T contain at most n(UB/LB)(1/ε) pairs each, the operations in line 13 are done in O(n(UB/LB)(1/ε)). In lines 6-16 we go over all the arcs, and in total lines 9-12 are operated in O(m) time . Thus, we have O(mn(UB/LB)(1/ε)) elementary operations in total. Since the input UB and LB of AA(LB,UB,ε) satisfies UB/LB≤2, its complexity is O(mn/ε). Taking the complexity of finding bound ratio into account, the suggested FPTAS for PH1 runs in O(mn/ε +m2) time. □ It is worth noticing that the suggested three-stage FPTAS not only able to solve PN1 but can be also applied for solving the single-constrained problem P1 (see its formulation in Section 2), which is a special case of PN1. In this case, Step 1 can be implemented in O(mn) time rather than in O(m2), which improves the total complexity to O(mn/ε). Thus, the present algorithm improves the earlier known FPTASs for P1 developed by Hassin [14] by a factor of n2/h, Camponagaro & Shima's [19] by a factor of log log (b⎯/b)n/h and Elalouf et al.'s [7] by an additive term log log n. Algorithm 4.The ε -approximation algorithm AA (LB,UB,ε)

1. Input. {(b(k, j), r(k, j) | (k, j) ∈ E}; R(k), v, ε, δ= εv/n 2. Output: Path with benefit app such that app≥OPT(1-ε) 3. Step 1. [Initialization]. 4. Set S(0,0) = {(0,0)}, 5. Step 2. [Generate S(1) to S(n)] 6. for all k ∈ V 7. S(k) ← ∅ ,T← ∅ 'Remark: T,G are temporary sets 8. for each arc e leading from node u to node k (denoted by u→k) 9. G ←∅ 10. for each pair (B,R) ∈ S(u) corresponding to a path from s to u 11. do if R + r(u,k) ≤ R(k) then G ← G ∪ {(B+b(u,k), R+r(u,k))} 12. Endfor 13. T ←merge(T,G); during merging eliminate the dominated and δ-close pairs 14. endfor 15. S(k)← T 16. end for 17. Step 3. Find the pair with max B in S(t) 18. Use backtracking to find the corresponding path; its benefit is at least (1-ε) b*. Fig. 4. The ε-approximation algorithm AA (LB, UB, ε)

4

Discussion and Concluding Remarks

We show that the mobile-agent itinerary problem can be cast as the resourceconstrained longest path problem that is amenable to fast and practical algorithms. We derive a new FPTAS algorithm and present an acceleration technique that modifies

86

A. Elalouf, E. Levner, and T.C.E. Cheng

and improves on several FPTAS algorithms. The complexity of our algorithm only depends polynomially on the graph size (i.e., m and n) and 1/ε, and does not depend on the magnitudes of the input data. As mentioned, there are several obvious modifications of the considered constrained longest path problem PN1. Thus, another problem, denoted as PN2, from a mathematical point of view, is a "mirror" one to PN1, in which the maximum is changed to minimum and ≤ in the constraint is substituted by ≥ . Problem PN2. Given the costs cij and information volumes bij assigned to the links in the network, minimize the total cost of agent route under the constraint that the total volume of the gathered information in each subsequent node k in a route is not less than a given threshold, Bk. This problem can be cast as follows: Minimize c(p) ≡ Σ(i,j) ∈ p cij, s.t. b(p, k) ≡ Σ(i,j) ∈ p(k) bij ≥ Bk, k = 1, …, h. The third problem is formally "complementary" to PN1: Problem PN3. Given the data volume (e.g., the number of useful pages) bij and information value mij (e.g., the value in monetary form) assigned to each link in the network, maximize the total number of pages collected by the agent, subject to the condition that the total value of the gathered information in each node k is not less than a given threshold Mk. Maximize b(p) ≡ Σ(i,j) ∈ p bij, s.t. m(p, k) ≡ Σ(i,j) ∈ p(k) mij ≥ Mk, k = 1, …, h. The next problem, formally speaking, is a "mirror" problem to PN3: Problem PN4. Given costs cij and expected travel times tij assigned to each link in a network, minimize the total expected travel time for completing the task under the constraint that the total route cost in node k does not exceed a given budget Ck. Minimize t(p) ≡ Σ(i,j) ∈ p tij, s.t. c(p, k) ≡ Σ(i,j) ∈ p(k) cij ≤ Ck, k = 1, …, h. We believe that the general FPTAS technique described in this paper can be applied to solve the above and even more complicated multi-path, multi-constraint agent routing problems in distributed systems. We believe that the complexity of the algorithms presented in this work can be further improved. While in the present paper we look separately for a best route for each individual agent, a prospective direction for future research is to find a best schedule for several cooperating agents. Another research direction is to carry out extensive computational experiments to assess the performance of our algorithms in comparison with earlier known algorithms and to test the possibility of applying them in practice. Acknowledgments. The authors wish to thank Prof. Magnus M. Halldorsson for his helpful suggestions that helped improve the paper.

References 1. Guilfoyle, C., Warner, E.: Intelligent Agents: New Revolution in Software, p. 214. Ovum Ltd. Publisher, London (1994)

Computing Mobile Agent Routes with Node-Wise Constraints

87

2. Torsun, I.S.: Foundations of Intelligent Knowledge-Based Systems, p. 507. Academic Press, London (1995) 3. Jennings, N.R., Wooldridge, M.J.: Applications of Intelligent Agents. In: Jennings, N.R., Wooldridge, M.J. (eds.) Agent Technology: Foundations, Applications and Markets, pp. 3–28. Springer, Heidelberg (1998) 4. Shen, W., Norrie, D.H., Barthes, J.-P.: Multi-Agent Systems for Concurrent Intelligent Design and Manufacturing, p. 386. Taylor and Francis, London (2001) 5. White, J.E.: Telescript Technology: The Foundation for the Electronic Marketplace, White Paper. General Magic, Inc., USA (1994) 6. Tsichritzis, D.: Objectworld, Office Automation. Springer, Heidelberg (1985) 7. Elalouf, A., Levner, E., Cheng, T.C.E.: Efficient Routing of Mobile Agents for Agentbased Integrated Enterprise Management: A General Acceleration Technique. LNBIP, vol. 88, pp. 1–20. Springer, Berlin (2011) 8. Papaioannou, T.: Using Mobile Agents to Improve the Alignment between Manufacturing and its IT Support Systems. In: Robotics and Autonomous Systems. Elsevier (1999) 9. Peng, Y., Finin, T., Labrou, Y., Chu, B., Long, J., Tolone, X., Boughannam, A.: A MultiAgent System for Enterprise Integration. In: Proceedings of PAAM 1998, London, UK, pp. 155–169 (1998) 10. Qi, H., Iyengar, S.S., Chakrabarty, K.: Multi-Resolution Data Integration Using Mobile Agents in Distributed Sensor Networks. IEEE Trans. Systems, Man, and Cybernetics Part C: Applications and Rev. 31(3), 383–391 (2001) 11. Wu, Q., Rao, N.S.V., Barhen, J., Iyengar, S.S., Vaishnavi, V.K., Qi, H., Chakrabarty, K.: On Computing Mobile Agent Routes for Data Fusion in Distributed Sensor Networks. IEEE Transactions on Knowledge and Data Engineering 16(6), 740–753 (2004) 12. Gens, G.V., Levner, E.V.: Fast Approximation Algorithms for Job Sequencing with Deadlines. Discrete Applied Mathematics 3, 313–318 (1981) 13. Gens, G.V., Levner, E.V.: Fast Approximation Algorithms for Knapsack Type Problems. LNCIS, vol. 23. Springer, Berlin (1980) 14. Hassin, R.: Approximation Schemes for the Restricted Shortest Path Problem. Mathematics of Operations Research 17(1), 36–42 (1992) 15. Goel, A., Ramakrishnan, K.G., Kataria, D., Logothetis, D.: Efficient Computation of Delay-sensitive Routes from One Source to All Destinations. In: IEEE Infocom 2001, pp. 854–858. IEEE Press (2001) 16. Xue, G., Sen, A., Zhang, W., Tang, J., Thulasiraman, K.: Finding a Path Subject to Many Additive QoS Constraints. IEEE Transactions on Networking 15, 201–211 (2007) 17. Lorenz, D.H., Raz, D.: A Simple Efficient Approximation Scheme for the Restricted Shortest Path problem. Operations Research Letters 28(5), 213–219 (2001) 18. Ergun, F., Sinha, R., Zhang, L.: An Improved FPTAS for Restricted Shortest Path. Information Processing Letters 83(5), 287–291 (2002) 19. Camponogara, E., Shima, R.B.: Mobile Agent Routing with Time Constraints: A Resource Constrained Longest-Path Approach. Journal of Universal Computer Science 16(3), 372– 401 (2010) 20. Sahni, S.: Algorithms for Scheduling Independent Tasks. Journal of the ACM 23(1), 116– 127 (1976) 21. Cormen, T.H., Leiserson, C.E., Rivest, R.L., Stein, C.: Introduction to Algorithms, ch. 24.2. MIT Press (2001) 22. Ahuja, R.K., Magnanti, T.L., Orlin, J.B.: Network Flows. Prentice Hall, New Jersey (1993)