A new distributed algorithm for efficient generalized arc-consistency propagation

Abstract

Generalized arc-consistency propagation is predominantly used in constraint solvers to efficiently prune the search space when solving constraint satisfaction problems. Although many practical applications can be modelled as distributed constraint satisfaction problems, no distributed arc-consistency algorithms so far have considered the privacy of individual agents. In this paper, we propose a new distributed arc-consistency algorithm, called $\mathsf {DisAC3.1}$, which leaks less private information of agents than existing distributed arc-consistency algorithms. In particular, $\mathsf {DisAC3.1}$ uses a novel termination determination mechanism, which allows the agents to share domains, constraints and communication addresses only with relevant agents. We further extend $\mathsf {DisAC3.1}$ to $\mathsf {DisGAC3.1}$, which is the first distributed algorithm that enforces generalized arc-consistency on k-ary ($k\ge 2$) constraint satisfaction problems. Theoretical analyses show that our algorithms are efficient in both time and space. Experiments also demonstrate that $\mathsf {DisAC3.1}$ outperforms the state-of-the-art distributed arc-consistency algorithm and that $\mathsf {DisGAC3.1}$ ’s performance scales linearly in the number of agents.

Appendix

Proof of Lemma 1

Proof

$(1) \Rightarrow (2)$: Given an agent i, the property $\textit{isIdle}[i]$ is set to $\texttt {true}$ only in line 41 and line 44. If $\textit{isIdle}[i]$ was set to $\texttt {true}$ in line 41, then $s_{ji} = r_{ij}$ for all $j = 1, \ldots , p$ and there is an agent k who sent a “domain update” message $m_{ki}$ with timestamp $s_{ki}$ to agent i, and the corresponding “message sent” message $m_{ki}^{\text {sent}}$ from agent k to the root agent has been received. Since $s_{ki}=r_{ik}$, the root agent has also received the message $m_{ki}^{\text {utd}}$, and thus, the root agent has received agent i’s first “up to date” message.

The other case, i.e., $\textit{isIdle}[i]$ was set to $\texttt {true}$ in line 44, immediately implies that the root agent have received an “up to date” message from agent i and $s_{ji} = r_{ij}$ for all $j = 1, \ldots , p$.

$(2) \Rightarrow (3)$: We prove this by contradiction.

First, suppose there is at least one “domain update” message that has not been confirmed by the root agent and let $m_{ij}$ be such a message (sent from agent i to agent j) which bears the earliest timestamp s and let $m_{ij}^{\text {sent}}$ and $m_{ij}^{\text {utd}}$ be the corresponding “message sent” message and “up to date” message, respectively (cf. Sect. 3.2).

We first note that according to our assumption (2) the root agent already received agent i’s first “up to date” message $m^0$ and $s_{ik} = r_{ki}$ for all $k = 1, \ldots , p$. Furthermore, because $m_{ij}$ is the earliest message that has not been confirmed yet and the root agent receives messages in FIFO manner, no other messages from agent i to j sent later than $m_{ij}$ have been confirmed by the root agent. Then it follows that both $m_{ij}^{\text {sent}}$ and $m_{ij}^{\text {utd}}$ have not been received by the root agent; otherwise, we would have either $s_{ij} > r_{ji}$ or $s_{ij} < r_{ji}$, contradicting our assumption.

Furthermore, agent i must have sent $m_{ij}$ after sending $m^0$ to the root agent; otherwise, as the root agent receives messages from agent i in a FIFO manner, it would have received $m_{ij}^{\text {sent}}$ before receiving $m^0$. Now that agent i sent $m_{ij}$ after sending $m^0$, it must have sent $m_{ij}$ when it re-entered the first inner while-loop, i.e., it received a “domain update” message $m_{ki}$ from an agent k after sending $m^0$. Note that this message $m_{ki}$ is not confirmed either, because the corresponding “up to date” message $m_{ki}^{\text {utd}}$ from agent i to the root agent must be sent after $m_{ij}^{\text {sent}}$, but $m_{ij}^{\text {sent}}$ has not been received by the root agent. As $m_{ki}$ bears an earlier timestamp than $m_{ij}$, we have the contradiction that $m_{ij}$ is an unconfirmed “domain update” message with the earliest timestamp. Thus, we can assume that all “domain update” messages have been confirmed.

Now suppose there is at least one agent running the first inner while-loop and let i be such an agent. Then, since agent i sent already its first “up to date” message to the root agent, agent i must have received a new message of type “domain update” so that it could re-enter the first inner while-loop. Let this “domain update” message $m_{ki}$ be from an agent k. Then agent i has not yet sent the corresponding “up to date” message $m_{ki}^{\text {utd}}$ to the root agent, as it has not finished the first inner while-loop. Thus $m_{ki}$ has not been confirmed. This is a contradiction to our assumption that all “domain update” messages have been confirmed.

$(3) \Rightarrow (1)$: We prove this by contradiction.

We note first that the state of $\textit{isIdle}[i]$ $(i = 1, \ldots , p)$ will remain fixed in the future, because all “domain update” messages have been confirmed and no agent is running the first inner while-loop, and thus, no new message of type “message sent” or “up to date” will be received by the root agent in the future. Suppose there is an agent i such that $\textit{isIdle}[i] = \texttt {false}$. Then the agent must have received at least one “domain update” message from an agent k, otherwise $s_{ji} = r_{ij} = -\infty$ for all $j = 1, \ldots , p$ and as a consequence $\textit{isIdle}[i]$ had to be set to $\texttt {true}$ in line 44 after the root agent received the last “up to date” message of agent i.

Now suppose that $m_{ki}$ is the last message that agent i received, which was sent from agent k, and let $m_{ki}^{\text {sent}}$ and $m_{ki}^{\text {utd}}$ be the corresponding “message sent” message and “up to date” message, respectively. Then, because $m_{ki}$ has been confirmed, both $m_{ki}^{\text {sent}}$ and $m_{ki}^{\text {utd}}$ must have been received by the root agent. If $m_{ki}^{\text {sent}}$ was received later, then the root agent must set $\textit{isIdle}[i]$ to $\texttt {true}$ in line 41, and if $m_{ki}^{\text {utd}}$ was received later, the root agent must set $\textit{isIdle}[i]$ to $\texttt {true}$ in line 44. Both cases contradict our assumption that $\textit{isIdle}[i] = \texttt {false}$. Hence, $\textit{isIdle}[i] = \texttt {true}$ for all $i = 1, \ldots , p$. $\square$

Proof of Lemma 2

Proof

We note first that at the beginning of the algorithm we have vacuously $D_u^{i} \supseteq D_u$, as $D_u^{i}$ is a copy of $D_u$.

Now suppose $D_u^{i} \supseteq D_u$ during the process of the algorithm. Then we note that $D_u^{i} \not \supseteq D_u$ can only happen in line 18 of the algorithm, where there exists a variable $v \in V_i$ with $R_{uv} \in C_{ji}$ such that $\textsc {Revise}(u, v)$ is true, i.e., there exists $b \in D_u^{i}$ for which no $a \in D_v$ exists with $(b, a) \in R_{uv}$ in which case we remove b from $D_u^{i}$. Agent i then prompts agent j to replace $D_v^{j}$ with the content of $D_v$ (line 20). Agent j—we now switch the perspective and look at the algorithm from agent j’s point of view—then replaces $D_v^{j}$ with the content of $D_v$ (line 35) and adds among other arcs (u, v) to its queue (line 36), and applies function $\textsc {Revise}$ to (u, v) (line 11). This deletes b from $D_u$, as there is no $a \in D_v^{j}$ with $(b,a) \in R_{uv}$. Thus, we have $D_u^{i} \supseteq D_u$. $\square$