Speeding up distributed pseudo-tree optimization procedures with cross edge consistency to solve DCOPs

The Distributed Pseudo-tree Optimization Procedure (DPOP) is a well-known message passing algorithm that provides optimal solutions to Distributed Constraint Optimization Problems (DCOPs) in cooperative multi-agent systems. However, the traditional DCOP formulation does not consider constraints that must be satisfied (hard constraints), rather it concentrates only on constraints that place no restriction on satisfaction (soft constraints). This is a serious shortcoming as many real-world applications involve both types of constraints. Traditional DPOP algorithms are not able to benefit from the existence of hard constraints, where an additional calculation is required to handle such constraints. This results in longer runtimes. Thus scalability remains an issue. Additionally, in the standard DPOP, the agents are arranged as a Depth First Search (DFS) pseudo-tree, but recent work has shown that the construction of pseudo-trees in this way often leads to chain-like communication structures that greatly impair the algorithm’s performance. To address these issues, we develop an algorithm that speeds up the DPOP algorithm by reducing the size of the messages exchanged and increases parallelism in the pseudo tree. For this purpose, initially, we improve the path for exchanging messages. Next, we introduce a new form of constraint propagation, which we call cross-edge consistency. Our theoretical evaluation shows that our proposed algorithm is complete and correct. In empirical evaluations, our algorithm achieves a significant reduction in the runtime, ranging from 4% to 96%, compared to the state-of-the-art.


Introduction
Distributed Constraint Optimization Problems (DCOPs) is a commonly used framework involving multiple agents that interact with one another to achieve a common goal [23]. A number of real-world problems, such as distributed event scheduling [13], scheduling smart home devices [6] and allocating tasks in mobile sensor networks [11], can be modeled with this framework. Specifically, a DCOP consists of several distributed cost functions that collectively form a global objective function (i.e. the common goal). Each of these cost functions represents a constraint relationship among a set of variables that are controlled by the agents contributing to that constraint. In search-based and inference-based algorithms. The former use a search technique to find the optimal solution from a set of possible assignments (e.g. SyncBB [8], ConcFB [15], ADOPT [14]). The latter, such as DPOP [17], Action-GDL [22], BrC-DPOP [5], are based on dynamic programming techniques. Among them, the Distributed Pseudo-tree Optimization Procedure (DPOP) has gained particular attention since it can often provide exact solutions for many reallife problems, often at the expense of low communication cost. This is achieved by following a synchronous message passing algorithm, where the agents exchange their utility and value assignments by following a synchronous message passing protocol.
To date, several DPOP variants have been proposed. O-DPOP [18] and MB-DPOP [19] have made improvements in terms of the memory requirements of the original algorithm and SS-DPOP [7] improves the participating agents' privacy. However, a notable issue with all of these variants is that they are not able to handle constraints that must be satisfied (i.e. hard constraints). Instead, they only deal with soft constraints. Unlike hard constraints, soft constraints poses a profit/loss for each possible value assignment to its corresponding variables. Nonetheless, hard constraints, along with soft constraints, are seen in many well-known DCOPs, such as distributed radio link frequency assignment [1] and distributed event scheduling [13]. To confront this shortcoming, two notable extensions of DPOP, H-DPOP [12] and BrC-DPOP [5], have been proposed.
In more detail, H-DPOP reduces the computation cost of DPOP by ruling out infeasible combinations of the variables, and thus generates smaller messages. Infeasibe combination of values for variables sharing a hard constraint, are those, that are restricted by that specific hard constraint. This is done by a Constraint Decision Diagram (CDD), which graphically represents a solution set for nary constraints [3]. To do so, H-DPOP performs join and projection operations on CDDs that are computationally expensive. At the same time, it is not possible to fully exploit hard constraints to prune the domain of a variable using this approach. Addressing these issues, BrC-DPOP introduced the notion of a Value Reachability Matrix (VRM). A VRM is a binary matrix representation of a constraint that requires a large number of matrix multiplications that largely affect the time complexity. Unfortunately, the issues of CDD, still exist for VRM to some extent. Therefore, it is worth noting that similar to the aforementioned DPOP extensions, BrC-DPOP uses a depth-first search pseudo tree to graphically represent a DCOP. Recently, it has been shown that this approach often results in a chain-like structure that impairs the performance of the algorithm due to the lack of parallelism [2]. Nevertheless, the algorithm proposed in the paper, the so-called BFS-DPOP, shows the significance of an alternative graphical representation − a breadthfirst search pseudo tree. To be exact, BFS-DPOP enhances parallelism, and thus reduces the runtime of the algorithm. However, BFS-DPOP cannot handle hard constraints, and thus it is not directly applicable to BrC-DPOP.
Against this background, we propose a new variant of the DPOP algorithm, that we call Cross-Edge Consistent DPOP (CeC-DPOP). The contributions of our algorithm are as follows. Firstly, it takes advantage of increased parallelism through the use of a BFS pseudo tree as the communication structure. Our algorithm can also make use of hard constraints to reduce the domain size of a variable. In this context, unlike BrC-DPOP that enforces branch consistency, we develop a new form of consistency, called Cross-edge Consistency. 1 This particular form of consistency helps to remove nonassignable values from a variable's domain. In addition to this, we have also used arc consistency, for further reduction in domain size. This enables us to produce smaller message sizes that improve DPOP's runtime. Finally, we introduce a data structure, called a Consistency Matrix, which is used to store constraint information. Unlike VRM, the Consistency Matrix requires a smaller number of computations to remove nonassignable values from the domain of a variable. The use of a BFS pseudotree along with the cross-edge consistency enforced by Consistency Matrices enables CeC-DPOP to outperform the previous state-of-the-art algorithms in terms of runtime. We theoretically prove that our algorithm CeC-DPOP is complete and correct. We then evaluate the complexity of the algorithm and observe that it has polynomial-time computational complexity. Furthermore, we empirically evaluate the performance of our approach, and observe a significant reduction of runtime, up to 18-96% compared to DPOP, 10-89% compared to BFS-DPOP, 5-67% compared to BrC-DPOP, 55-75% compared to H-DPOP.
The remainder of this paper is structured as follows. We describe the problem in the section that follows. Then, in Section 3, we discuss the complete process of CeC-DPOP with a worked example. Afterward, we discuss the complexity of the algorithm in Section 4. Section 5 presents the theoretical analysis. In Section 6, we present the empirical results of our method compared to the current state-of-the-art, and Section 7 concludes.

Background and Problem Formulation
A DCOP model can be formally expressed as a 5-tuple A, X, D, F, α where: ..., f m } is a set of constraint functions (also known as utility or cost functions). Constraints are used to represent the relationship among the variables and denotes the utility value for each possible assignment of those variables. In constrained optimization problems a value (penalty) is assigned for each possible valuecombination of variables sharing a constraint. In a maximization problem the sum of the penalty of every constraint is maximized and it is the opposite for minimization problem. In more detail, each function f i (x i ) depends on a subset of variables x i ⊆ X that can be considered as the scope of that function. To represent the relationship among the variables in x i , the function f i (x i ) denotes the utility value for each possible assignment of those variables. Each constraint f i ∈ F can be hard in which case the value combinations that must be avoided are denoted as 0, whereas the combinations that are allowed are represented by 1.
In our paper, we used 1 to indicate a legal value assignment since we are considering a maximization problem. Relational operators like; greater than, less than, equal to, etc, are a common example of hard constraint. The remaining type is the soft constraint indicating that each value combination results in a finite utility/cost value and there is no restriction in value assignment. The dependencies among the variables can be used to construct a constraint graph that has been used to represent DCOPs graphically. In this representation, each variable is associated with a node and connected to each other through an edge. α : X → A is an onto mapping function that assigns the variables X to the set of agents A.
Within this model, the main objective of a DCOP algorithm can be expressed as each agent assigning the values to its associated variable(s) from the corresponding domain(s) that can be expressed as X * , in the pursuit of the maximization or minimization of the sum of the utility functions (i.e. the global objective function). In this paper, we consider the maximization problem only (Equation 1). However, the algorithm can also be applied to a minimization problem. For example, in Fig. 1, a DCOP instance is graphically represented as a constraint graph.
Here, we consider the set of variables X = {x 1 , x 2 , ..., x 7 }, each having domain d i = {0, 1}. The cost matrix of the soft constraint involving variables x 5 and x 6 is shown in Fig. 2. The remaining constraints in the graph that are defined by relational operators are the hard constraints. As mentioned in Section 1, DPOP is a complete, synchronous message passing algorithm for solving DCOPs. Specifically, it uses a dynamic programming technique on a DFS pseudo-tree in a distributed manner. DPOP is executed through three phases. In the first phase, a distributed DFS traversal is started from the root (held by an agent) of the constraint graph using the distributed DFS algorithm [20]. As a result, a DFS pseudo-tree structure is built where each agent labels its neighbors as parents, pseudo-parents, children or pseudo-children and edges are identified as tree or back edges. For example, after this phase, the constraint graph of Fig. 1 results in the DFS pseudo-tree of Fig. 3. The resulting pseudo-tree serves as a communication structure for the subsequent phases of DPOP. The second phase is the Util propagation phase in which each agent, starting from the leaves of the constraint graph, sends a UTIL message to its parent. The UTIL message is generated by aggregating the constraint utilities between the current node and the variables in its separator. Here, a separator is defined as the ancestors of the current node that are connected directly to this node or its descendants. Again, the utilities in the UTIL message received from its children are also aggregated with the constraint utilities of the current node. Lastly, the current node projects itself out by optimization over the received utilities. Finally, the value propagation phase is initiated by the root agent. Each agent selects its optimal assignment using the cost function computed in the UTIL propagation phase and the VALUE message received from its parent. Afterward, each agent broadcasts its assignment to its children. When every agent has chosen its optimal assignment, the algorithm terminates. DPOP can be executed on different branches independently using a DFS pseudo-tree as its communication structure. 3 Although DPOP produces a linear number of messages, message size is exponential. This is because, a message consist of all possible value assignment to a variable pair, sharing a constraint. Another notable limitation of the DPOP algorithm is that it does not exploit hard constraints along with soft ones. These two limitations have been resolved by the BrC-DPOP algorithm [5].
In particular, to deal with hard constraints, BrC-DPOP enforces arc consistency and introduces a weaker form of the path consistency which can be applied along the path of a pseudo-tree to reduce message size. Specifically, the algorithm starts by generating a pseudo-tree structure followed by a path construction phase which is subsequently used to get the knowledge of the direct paths from each agent to its parent and pseudo-parents. In the next phase, arc consistency is enforced in a distributed manner. Then the most important phase is executed where branch consistency is exploited in a distributed way. This phase aims to ensure consistent pairs of assignable values between an agent and its pseudo-parents considering every pseudotree path between them. Finally, the UTIL and VALUE propagation phases are executed considering the updates of the pseudo-tree. BrC-DPOP reduces the message size due to branch-consistency enforcement, as well as faster runtime 3 A communication structure is a path along which DCOP message passing takes place. since it prunes the values of the variables. Though BrC-DPOP improves the DPOP algorithm to a greater scale, the communication structure is a DFS pseudo-tree, and as previously mentioned, this often becomes chain-like 4 in many experiments for example in Fig. 3. This condition greatly reduces the algorithm's performance. To deal with this drawback, [2] proposes the BFS-DPOP variant which uses the Breadth-First Search (BFS) pseudo-tree as the communication structure.
In more detail, BFS-DPOP operates on a Breadth-First Search (BFS) pseudo-tree that is used as the communication structure. This increases the parallelism because it produces more branches than that of its DFS counterpart. Here, Fig. 4 depicts the transformed BFS pseudo-tree of the corresponding constraint graph of Fig. 1. In BFS-DPOP, following the construction of BFS Pseudo-tree, an additional phase, namely, a cluster removal phase, is added. In this phase, for two end-points of a cross-edge, one of them is selected as the cross-edge belonger. The value of a cross-edge belonger is assigned by the agent itself. In contrast, the value of the non-belonger of a cross-edge is assigned by the root agent. Finally, the UTIL and VALUE propagation phase is executed on the BFS Pseudo-tree considering the changes that occurred in the previous phases. Even though BFS-DPOP experiences shorter communication paths, and hence less communication time, through the use of a BFS pseudotree, the algorithm produces messages with exponential size as the system grows. Moreover, this algorithm cannot deal with hard constraints.
To summarize, the primary issue of the current DPOP variants, based on this context, is the lack of an effective domain pruning process, in the presence of hard constraints. There is also a lack of an appropriate pseudo-tree structure, with more branches and reduced height. Our proposed approach, the Cross-Edge Consistent DPOP (CeC-DPOP), addresses both of these issues.

The Cross-Edge Consistent DPOP Algorithm (CeC-DPOP)
CeC-DPOP improves the DPOP algorithm by enforcing cross-edge consistency to reduce the domain size of the variables of a given DCOP. To be precise, cross-edge consistency is a new version of consistency, enforced by CeC-DPOP. Unlike branch-consistency, cross-edge consistency can be enforced in a shorter time. CeC-DPOP particularly achieves this through the use of a Consistency Matrix and a BFS pseudo-tree as the constraint representation data structure and the graphical representation of a DCOP, respectively. Cross-edge consistency is enforced along the path from two endpoints of a cross-edge to the lowest node, containing both these endpoints as descendants (i.e. lowest common ancestor). The use of cross-edge consistency eliminates the nonassignable values from a variable's domain. This decreases the time required to perform the join and projection operation on UTIL messages. This way, we obtain reduced message size and runtime compared to the current state-of-the-art. Moreover, by using a BFS pseudo-tree instead of a DFS pseudo-tree, CeC-DPOP can increase parallelism and shorten the tree depth. Based on the problem formulation in Section 2, we now formally define cross-edge consistency: Definition 1 Given a BFS pseudo-tree associated with a DCOP problem instance, we define a CE relationship (Cross-Edge relationship) on its variables: x i and x j if and only the Lowest common Ancestor, LCA(x i , x j ) = x LCA , where x LCA ∈ Ancestor i and x LCA ∈ Ancestor j . Definition 2 A pair of values (r, c) ∈ D i × D j of two variables x i , x j that share a constraint f ij is cross edge consistent (CeC) if and only for any sequence of variables

Definition 4 Given a DCOP, the Consistency Matrix
Given this definition of cross-edge consistency, in Section 3.1, we give detailed description of the algorithm. Next, in Section 3.2, we provide a worked example of the algorithm.

Algorithm Description
CeC-DPOP consists of four phases: BFS pseudo tree construction, consistency enforcement, UTIL propagation, and VALUE propagation phase. Initially, a BFS pseudo tree is constructed from the constraint graph. In order to generate the corresponding BFS pseudo tree, we use the same method as prescribed in the BFS-DPOP algorithm. For example, Fig. 4 illustrates a sample BFS pseudo tree of the constraint graph depicted in Fig. 1. Having a BFS pseudo tree G bf s constructed, CeC-DPOP enforces arc-consistency. This phase uses the distributed Arc-Consistency (AC) algorithm that is introduced in BrC-DPOP. This algorithm results in a reduced domain for all the variables having hard constraints.
After arc-consistency is achieved, CeC-DPOP enforces a new form of consistency (i.e. cross-edge consistency) on the BFS pseudo tree. To do so, we need the lowest common ancestor LCA(x i , x j ) for every pair of variables x i and x j in G bf s . To find the LCA of every pair of variables, we use [21], a distributed algorithm. To represent hard constraints we use Consistency Matrices (Definition 4), where a matrix M ij represents a hard constraint between variables, x i and x j . Now the algorithm enforces cross edge consistency on the pseudo tree G bf s . For this, we need to construct a path for each cross-edge in G bf s (Algorithm 1). In more detail, the BFS pseudo tree G bf s , parent set P and set of child C are the inputs of the algorithm. We construct a list, NEXT i , which contains the pair, (x l , x c ), throughout this algorithm phase. It informs the current agent x i about the next agent x c to enforce cross-edge consistency for that edge whose endpoints have a LCA at x l . The for loop in line 1 selects a cross edge having one end point x i from G bf s , and sends a message NEXT UP DAT E(x l , x i ) to its parent P i . This message contains information about the LCA x l of two variables x i and x j and the current variable x i . To do this, line 2 computes a LCA, x l of x i with another variable x j with whom it holds cross edge. Then in line 3, x i sends a NEXT UP DAT E(x l , x i ) to its parent P i . In line 4, CeC-DPOP checks whether x i is a member of a cross edge, and if this is not the case, it sends a NEXT UP DAT E(NULL, x i ) to parent P i . Here, NULL indicates that x i is not an end point of any cross edge.
Afterwards, the while loop in line 6 compares a counter variable, cnt next i , with the child count of current variable (i.e. |C i |) to check whether the current variable received a NEXT UP DAT E message from each child in C i . Within this loop, if a NEXT UP DAT E(x l , x c ) is received from a child then (x l , x c ) is appended to the list, NEXT i (line 7-8). Then line 9 checks for any complete(x c ) message received from a child. This message informs the current variable x i that the path construction for the sub tree rooted at x c is complete. For each received complete(x c ) message, line 10 increments cnt next i by 1. The while loop terminates when each child x c in C i sends a complete(x c ) message. Now, in line 11, the algorithm checks whether NEXT i is not empty. If this is true, the for loop in line 12 selects each (x l , x c ) pair from the NEXT i list and line 13 sends a NEXT UP DAT E(x l , x i ) message to P i . Next, the algorithm terminates after sending a complete(x i ) message to P i after line 14. The NEXT i list thus computed holds information about the next variable to enforce cross-edge consistency, from current variable x i .
Finally, we enforce cross-edge consistency on the path that is established on the pseudo tree (Algorithm 2). The BFS pseudo tree G bf s , set of Consistency Matrices M, set of child C and the NEXT list are the inputs of the algorithm. The algorithm works as follows. Line 1 checks whether the current variable x i is root. If it is, it initiates CeC message propagation by iterating every child using the for loop in line 2. Line 3 then sends a CeC(x i , M ii ) to every x c in C i , where x i is the variable which sent the message along with its Consistency Matrix M ii . Line 4 of the algorithm checks whether any CeC message has been received from its parent. If this is the case, line 5 iterates over each pair (x l , x c ) of the NEXT i list to propagate a CeC message. For this purpose, lines 6-7 checks whether the current variable equals the LCA x l of a cross edge in the subtree. If this is the case, it initializes M il with its unary constraint M ii which represents the domain of the current variable x i . Otherwise, lines 8-9 computes M il , which is a multiplication of M ip and M pl . Next, line 10 checks whether x c is not null. If this is true, line 11 sends a CeC(x i , M il ) message to x c . Now, lines 12-13 of the algorithm checks whether any child exists that did not receive any CeC message. If this is true, x i sends a CeC(x i , NU LL) to that child. Lines 14-16 finally compute the Consistency Matrices along each cross edge by iterating over every cross edge and multiplying the matrices obtained for each endpoint of the cross edge. After cross edge consistency is enforced, we obtain a set of variables with reduced domain size. Now, we execute the UTIL and VALUE propagation phase. These two steps correspond to the UTIL and VALUE propagation phases of the BFS-DPOP algorithm.

Worked Example
In this sub-section, we present a working example of the algorithm that we introduced in Section 3.1. Initially our algorithm constructs a BFS pseudo-tree (Fig. 5b) from the constraint graph (Fig. 5a). From the pseudo-tree, we observe a cross-edge x 5 − x 6 . Then, for convenience we show CeC enforcement in a section of the original pseudo-tree (Fig. 5c). For our example, we assume each variable x i has a domain D i ={0, 1, 2, 3, 4}. After pseudo-tree construction, the algorithm enforces arc-consistency. AC propagation reduces the domain size of a variable by removing values, which are not satisfied by the hard constraints related to that variable. The effect of AC propagation on Fig. 5c is shown in Fig. 6. Now the algorithm enforces cross-edge consistency following the steps described in the upcoming sections:

Path Construction
From the pseudo-tree the algorithm detects a crossedge connecting x 5 and x 6 and finds LCA(x 5 , x 6 ) = x 1 . Now, agent a 5 sends NEXT UP DAT E(x 1 , x 5 ) to its parent a 2 . Afterwards a 5 sends complete(x 5 ) to its parent a 2 . This message indicates that agent a 5 has no other NEXT UP DAT E message to send to a 2 . After receiving NEXT UP DAT E(x 1 , x 5 ), agent a 2 appends (x 1 , x 5 ) to NEXT 2 . Now, the NEXT 2 list contains {(x 1 , x 5 )}. After updating the NEXT list, agent a 2 sends NEXT UP DAT E(x 1 , x 2 ) to its parent a 1 . Agent a 2 completes its path construction by sending complete(x 2 ) message to a 1 .
In a similar process, agent a 6 sends NEXT UPDATE (x 1 , x 6 ) and later sends complete(x 6 ) to its parent a 3 . On receiving a NEXT UPDATE message, agent a 3 appends (x 1 , x 6 ) to NEXT 3 and sends NEXT UPDATE(x 1 , x 3 ) to its parent a 1 . Finally, a 3 sends complete(x 3 ) to a 1 . On receiving NEXT UPDATE(x 1 , x 2 ) and NEXT UPDATE(x 1 , x 3 ), agent a 1 , appends {(x 1 , x 2 ), (x 1 , x 3 )} to NEXT 1 . The NEXT 1 list contains information about two agents a 2 and a 3 . Likewise, the list, NEXT 2 and NEXT 3 contain information about agent a 5 and a 6 respectively. This way, we have two paths from agent a 1 to the endpoints of the cross-edge x 5 − x 6 . The course to cross-edge consistency enforcement is now set. The path construction phase can be visualized with the help of Fig. 7. In the next phase CeC messages are propagated along these paths.

CeC Propagation Phase
The CeC propagation begins from the root agent, a 1 . Agent a 1 sends CeC(x 1 , M 11 ) to its child, a 2 and a 3 (Fig. 9). The simulation for CeC propagation in our example is shown in Fig. 8. In the next section, we will discuss the complexity analysis (Section 4) of the algorithm. Following, the complexity analysis, we provide a theoretical analysis of the algorithm, to show that CeC-DPOP is complete and correct (Section 5).

Complexity Analysis
Initially, we discuss the complexity of the DPOP algorithm. Given a graph and an ordering of its nodes, when processing the nodes in that order, the width of the current node is the number of neighbours that precede it in the ordering. The induced width of an ordering of nodes is the largest width of any node in that ordering. For DPOP, the complexity lies in the maximal utility message size which is exponential in the induced width of the DFS pseudo-tree, O(d w * ). Here, d is the domain size of the variables.
Improving DPOP for making use of hard constraints, BrC-DPOP employs branch consistency to reduce the domain d to d brc , where d brc ≤ d. Hence, the complexity stands as O(d w * brc ). On the other hand, BFS-DPOP reduces the induced width to the order of the maximal size of cross-edge cluster. The cross-edge cluster of a node is the number of crossedges connecting the node. Thus, if the maximum size of a cross-edge cluster is |CEC|, the complexity of BFS-DPOP is O (|X|.d |CEC|+2 ). Here, |X| is the number of variables.
As stated above, CeC-DPOP enforces cross-edge consistency and use a breadth-first search pseudo-tree. To enforce cross-edge consistency, CeC-DPOP constructs a path and then enforces arc-consistency along the path. In the path construction phase, each node sends a message to its parent containing the path information starting from one end of the cross edge to itself. This continues until the information reaches the least common ancestor of the two cross edge endpoints. Therefore, the complexity of this phase is O(|CE| log(|X|)), where |CE| is the number of cross-edges and |X| is the number of variables. This particular phase requires the lowest common ancestor for each pair of nodes associated with that path, which is found in a preprocessing phase having a complexity of O(log(|X|)). The next phase is the arc-consistency enforcement phase. In this phase, each hard constraint is evaluated to check whether the domain of both variables connecting the endpoints is consistent with each other. Given the number of hard constraints is C H and the average domain of each variable is d, the complexity of this phase is O (C H d 3 ). Here, in order to check whether each value in the domain of an endpoint is consistent with every value of the other endpoint, it requires three nested loops, resulting in d 3 computations. The final phase then enforces cross-edge consistency. In this phase, each agent waits for its parent agent to send a CeC message which it uses to find the final cross-edge consistent matrix. This requires a complexity of O(d 3 ) indicating a multiplication of two matrices. The process continues for each variable, and as such, the total complexity of the cross-edge consistency enforcement phase is O (|X|(d 3 )).
The arc-consistency enforcement phase requires O(d|X|) messages, where the size of each message is O(d). In each step of arc-consistency enforcement, only the domain information of a variable needs to be propagated. Therefore, the cross-edge consistency enforcement phase requires O(C H ) messages and the size of each message is O(d 2 ). In this phase, we only propagate CeC messages each of which contains the Consistency Matrices and the size of a message depends on the size of these matrices. Therefore, the overall time complexity for enforcing cross-edge consistency is O(|CE| log(|X|) + C H d 3 + |X|(d 3 )) and the total number of messages exchanged is O(d|X| + C H ). The entire process of cross-edge consistency enforcement is insignificant to the complexity of UTIL and VALUE propagation and thus it does not affect the overall complexity. After, enforcing cross-edge consistency, the algorithm executes DPOP UTIL and VALUE propagation. For this the complexity is O(|X|.d |CEC|+2 cec ).

Theoretical Analysis
In this section, we prove CeC-DPOP is both complete and correct. Similar to BFS-DPOP, CeC-DPOP makes use of the DPOP's UTIL and VALUE propagation phase, which produces an exact solution of a given DCOP. Therefore, CeC-DPOP is complete and correct if we can prove that a DCOP is arc and cross-edge consistent (Definition 2) after the AC propagation and CeC propagation phases, respectively. As we utilize the same AC propagation phase as the BrC-DPOP paper, the former is true (see [5] for the proof). Theorem 1 proves the latter.

Theorem 1 The DCOP is cross edge consistent after the CeC propagation phase.
Proof Let, x i and x j be the end points of a cross-edge. According to our path construction phase, we have two paths x k 1 = x l , ...., x k n = x i and x k 1 = x l , ..., x k m = x j , where x l is the lowest common ancestor of x i and x j . All the arcs in the path (x l , x i ) and (x l , x j ) are arc consistent after the AC propagation phase. Now, CeC-DPOP enforces cross-edge consistency along these paths and we obtain Consistency Matrices, M li , M lj from the paths (x l , x i ) and (x l , x j ), respectively (Algorithm 2: line 9).
Finally, from lines 15-16 (Algorithm 2), we obtain the Consistency Matrix M ij using the following equation: Matrix M ij is cross edge consistent because M il defines that x i and x l are path consistent and M lj defines that x l and x j are path consistent by definition. So multiplying them will make x i and x j path consistent which in effect is cross edge consistent. Since this is true for a single cross-edge, it is also true for every other cross-edge. Therefore, the given DCOP is cross-edge consistent after cross-edge consistency enforcement.

Experimental Results
We now empirically evaluate how much performance improvement can be attained using CeC-DPOP in comparison to the original DPOP algorithm and three important variants of DPOP (BFS-DPOP, BrC-DPOP, and H-DPOP). Unlike CeC-DPOP, the original DPOP uses a DFS pseudotree as the communication structure and does not actively exploit hard constraints. Therefore, it is reasonable to observe the attributes of CeC-DPOP (i.e. inclusion of soft constraints along with hard constraints and the use of BFS pseudo-tree as the communication structure) with respect to the original DPOP. Additionally, we consider the BFS-DPOP algorithm as a benchmark because it also uses a BFS pseudo-tree as the communication structure. Finally, we compare CeC-DPOP with BrC-DPOP and H-DPOP as these algorithms can deal with DCOPs having both types of constraints. To benchmark the runtime of our algorithm CeC-DPOP, we run our experiments on two standard types of DCOP settings: random constraint graphs and the distributed RLFA problems. We are particularly influenced by the BrC-DPOP paper in choosing the above experimental settings.
In the case of random DCOPs, the runtime of the algorithms are reported varying four parameters: domain size, graph density, the density of hard constraints (i.e. the ratio of the number of hard constraints and n * (n − 1)/2 where n is the number of variables) and the number of variables. For the first parameter, we vary the domain size from 26 to 40 in Fig. 10. Here we set the number of variables X at 20 and edges are created by taking pairs of variables randomly and connecting them considering a fixed graph density, ρ = 0.5, and fixed hard constraint density 0.4. For the second parameter, we execute the algorithms by changing the graph density from 0.2 to 0.9 in Fig. 11. Here, we set the number of variables X at 20, domain size, D at 10 and hard constraint density at 0.4. Then for the third parameter, we increase the density of hard constraints from 0.2 to 0.9 in Fig. 12 setting the number of variables at 20, domain size at 10 and graph density at 0.4. Finally, we vary the number of variables, setting graph density ρ = 0.5, domain size, D at 10 and hard constraint density at 0.4. In our experiments, we generate 30 instances and calculate the average runtime of running each of the algorithms. We also recorded standard errors to ensure statistical significance. For the third experiment (Fig. 12), we only compared CeC-DPOP with BrC-DPOP and H-DPOP. Amongst DPOP, BFS-DPOP, BrC-DPOP, and H-DPOP, only BrC-DPOP and H-DPOP can make use of hard constraints to prune domain and thus, varying density of hard constraints (keeping the remaining parameters constant) would not affect the runtime of DPOP and BFS-DPOP. Therefore, for our third experiment, we used BrC-DPOP as the benchmark. All of the experiments were performed on a simulator implemented in an Intel i7 Octacore 3.4GH z machine with 16GB of RAM.
Our experimental results for solving random DCOPs are depicted in Figs. 10 -13. Specifically, we use hard constraints that are either "less than", "greater than" or "equal" alongside soft constraints for which we randomly generated utility values from the range [0, 100]. In Fig. 10, we observe the runtime of CeC-DPOP by varying the domain size. The reason behind this performance is that when the domain size increases, more values in each domain are pruned by CeC-DPOP through consistency enforcement which produces UTIL message of smaller dimensions. As a result, the required time to compute messages decreases at a significant rate. Though BrC-DPOP has a relatively smaller runtime than DPOP and BFS-DPOP for enforcing branch consistency, CeC-DPOP always outperforms through enforcing cross edge consistency. Here we observe that the runtime of CeC-DPOP is 70 − 73% smaller than DPOP, 22−43% than BFS-DPOP and 19−33% than BrC-DPOP. Figure 11 illustrates the results based on the next setting; that is, varying the graph density while setting the number of nodes, domain size and density of hard constraint as constants. Here we observe that the runtime of CeC-DPOP is 56 − 70% smaller than DPOP, 34 − 54% than BFS-DPOP and 21 − 40% than BrC-DPOP. This behavior is explained by the fact that CeC-DPOP uses a BFS pseudotree as the communication structure which is generated from dense constraint graphs which give more branches. As a result, more parallelism is experienced. Another reason is that the number of edges is relatively higher in the dense constraint graphs, creating the opportunity of crossedge consistency enforcement at a significant level. Thus, more domain values are pruned and shorter messages are produced resulting in smaller computation time. Overall, a significant reduction in runtime is observed.
In the third experimental setting, we vary the density of hard constraints and set the other three parameters as constants (Fig. 12). We observe a notable performance gain of CeC-DPOP in terms of runtime compared to the other algorithms. In particular, we detect a 16 − 20% reduction of runtime in comparison to BrC-DPOP and a 55 − 75% reduction in comparison to H-DPOP. With the increase in the density of hard constraints, CeC-DPOP is able to prune more values, compared to BrC-DPOP and H-DPOP. This results in shorter message sizes and an overall reduction in runtime. Finally, we vary the number of variables and set the other three parameters as a constant (Fig. 13). The results obtained are similar to the first three experiments on random DCOPs. More specifically, CeC-DPOP outperforms other algorithms contributing a 18 − 96%, 10 − 89% and 5 − 67% reduction in runtime relative to DPOP, BFS-DPOP, and BrC-DPOP. As already mentioned, the Distributed RLFA Problem is the second type of problem to evaluate CeC-DPOP against the benchmarking algorithms. The distributed RLFA problem [1] consists of a set of channels, each having a transmitter and receiver at both ends. The aim is to assign a frequency from a given set F by minimizing the total interference at the receivers below an acceptable level (hard constraints) and at the same time using as few and also as low frequencies as possible (soft constraints). For our experiment, we mapped a transmitter as a variable and for simplicity, we assigned a single agent to a variable. The domain of a variable consists of frequencies (chosen from available spectral resources) that can be assigned to a variable. The interference between transmitter is modeled as a constraint of the form x i − x j > s where x i , x j are variables and s is a random frequency separation. For this problem, we varied three parameters: domain size, graph density and the number of variables.
In Fig. 14 we varied the domain size, setting the number of variables at 20, s ∈ {3, 4} and graph density, ρ = 0.5. The  results are similar to those observed for random DCOPs.
Here we observe that the runtime of CeC-DPOP is 68−72% smaller than DPOP, 13−27% than BFS-DPOP and 9−20% than BrC-DPOP. Next, in Fig. 15, we varied the graph density, setting number of variables at 20, s ∈ {3, 4} and domain size, D = 10. Here we observe that the runtime of CeC-DPOP is 43 − 70% smaller than DPOP, 21 − 50% than BFS-DPOP and 10−22% than BrC-DPOP. Lastly, we varied the number of variables in Fig. 16, setting graph density, ρ = 0.5, s ∈ {3, 4} and domain size, D = 10. Here we observe that the runtime of CeC-DPOP is 27 − 95% smaller than DPOP, 18 − 82% than BFS-DPOP and 4 − 64% than BrC-DPOP. In order to compare CeC propagation to AC propagation, we conducted another experiment. Here, we varied the domain size of a random DCOP setting the number of variables at 20, hard constraint density, 0.4 and graph density, ρ = 0.5. We recorded the total number of assignable pairs after AC and CeC propagation. The results are shown in Table 1. This shows, even after AC propagation, we get an additional 30 − 40% reduction after CeC propagation (on average). This further reduction is observed since AC propagation is not entirely capable of removing all non-assignable value pairs. A summary of the experimental analysis is shown in Table 2. Here, we also

Conclusions
DCOPs have been used to solve different multi-agent coordination problems since the last one and a half decade. The existing algorithms that deal with DCOPs do not actively utilize hard constraints in solving such problems.
To address the shortcoming, We present a new algorithm, CeC-DPOP, that significantly reduces the runtime of the DPOP algorithm that can be used to solve DCOPs having both soft and hard constraints. This is possible due to the introduction of a new type of consistency, that we call cross edge consistency. Additionally, CeC-DPOP uses BFS pseudo-tree as the communication structure that further accelerate the message passing process through enhance parallelism. Finally, we empirically observe that our algorithm performs around 5-96% faster than the current state-of-the-art algorithms. Now, the contribution of our paper have thrown up few new questions that need further investigation. In the future, we intend to investigate how much speedup can be achieved applying our approach to other DPOP extensions (e.g. O-DPOP, MB-DPOP, SS-DPOP). Moreover, we intend to reduce the size of the consistency matrix while maintaining the quality of the solution. In so doing, we can make our approach more compatible with higher dimension constraints; and in effect, further reduce memory requirements of a given DPOP algorithm. As a result, CeC-DPOP would extend the use of DPOP in solving real-life problems including Distributed RLFA problems that include both hard and soft constraints. Furthermore, since the cross edge consistency has only been applied to exact inference based DCOP algorithm, we would like to further investigate whether it can be tailored to different non-exact DCOP algorithms.