Parallel and Distributed Algorithms for the housing allocation Problem

TL;DR

This paper develops parallel and distributed algorithms for the housing allocation problem, optimizing for Pareto optimality and the core, with complexity results and new algorithms for cycle detection in distributed settings.

Contribution

It introduces complexity classifications and efficient algorithms for computing Pareto optimal matchings and the core in distributed models, including a distributed top trading cycle algorithm.

Findings

Computing Pareto optimal matchings is in CC.

Computing the core is CC-hard, but verifying it is NC.

Distributed algorithms for cycle detection run in logarithmic rounds.

Abstract

We give parallel and distributed algorithms for the housing allocation problem. In this problem, there is a set of agents and a set of houses. Each agent has a strict preference list for a subset of houses. We need to find a matching such that some criterion is optimized. One such criterion is Pareto Optimality. A matching is Pareto optimal if no coalition of agents can be strictly better off by exchanging houses among themselves. We also study the housing market problem, a variant of the housing allocation problem, where each agent initially owns a house. In addition to Pareto optimality, we are also interested in finding the core of a housing market. A matching is in the core if there is no coalition of agents that can be better off by breaking away from other agents and switching houses only among themselves. In the first part of this work, we show that computing a Pareto optimal matching of a house allocation is in {\bf CC} and computing the core of a housing market is {\bf CC}-hard. Given a matching, we also show that verifying whether it is in the core can be done in {\bf NC}. We then give an algorithm to show that computing a maximum Pareto optimal matching for the housing allocation problem is in {\bf RNC}^2 and quasi-{\bf NC}^2. In the second part of this work, we present a distributed version of the top trading cycle algorithm for finding the core of a housing market. To that end, we first present two algorithms for finding all the disjoint cycles in a functional graph: a Las Vegas algorithm which terminates in $O(\log l)$ rounds with high probability, where $l$ is the length of the longest cycle, and a deterministic algorithm which terminates in $O(\log^* n \log l)$ rounds, where $n$ is the number of nodes in the graph. Both algorithms work in the synchronous distributed model and use messages of size $O(\log n)$.

Figures

Full text

In the first part of this work, we show that computing a Pareto optimal matching of a house allocation is in CC and computing the core of a housing market is CC-hard, where CC is the class of problems logspace reducible to the comparator circuit value problem. Given a matching of agents to houses, we show that verifying whether it is Pareto optimal is in NC. We also show that verifying whether it is in the core can be done in NC. We then give an algorithm to show that computing a maximum cardinality Pareto optimal matching for the housing allocation problem is in RNC2 and quasi-NC2.

In the second part of this work, we present a distributed version of the top trading cycle algorithm for finding the core of a housing market. To that end, we first present two algorithms for finding all the disjoint cycles in a functional graph. The first algorithm is a Las Vegas algorithm which terminates in $O(\log l)$ rounds with high probability, where $l$ is the length of the longest cycle. The second algorithm is a deterministic algorithm which terminates in $O(\log^{*}n\log l)$ rounds, where $n$ is the number of nodes in the graph. Both algorithms work in the synchronous distributed model and use messages of size $O(\log n)$. By applying these two algorithms for finding cycles in a functional graph, we give the distributed top trading cycle algorithm which terminates in $O(n)$ rounds and requires $O(n^{2})$ messages.

1 Introduction

Matching is a fundamental problem in computer science with numerous applications. The housing allocation problem [10, 22, 1] is an instance of matching problem with one-sided preferences. In this problem, we need to allocate a set $H$ of houses among a set $A$ of agents and monetary compensations are not allowed. Each agent $a_{i}\in A$ ranks in order of preference a subset of $H$ (the acceptable houses for $a_{i}$). The variant in which there is an initial endowment of houses to agents is known as the housing market problem [19, 18, 17]. For both the housing market and the housing allocation problem, we need to construct a matching of agents to houses such that it is optimal with respect to some criterion. One criterion usually considered is Pareto Optimality [1, 3, 19]. A matching $M$ is Pareto optimal if there is no other matching $M^{\prime}$ such that no agent strictly prefer $M$ to $M^{\prime}$, and at least one agent strictly prefer $M^{\prime}$ to $M$. For example, a matching $M$ is not Pareto optimal if a group of agents could improve by exchanging the houses that they are assigned to in $M$.

Possible applications of the housing allocation problem and the housing market problem include: assigning virtual machines to servers in cloud computers, allocating graduates to trainee positions, professors to offices, and students to roommates. Yuan [21] also describes a large-scale application of housing allocation in the allocation of families to government-subsidized housing in China. Also, the paper [13] describes applications of algorithms for the stable marriage problem for mapping clients to server clusters in a content delivery network in Akamai. When only one side preference is considered, housing allocation algorithms can be applied.

For the housing allocation problem, there is a simple greedy algorithm, known as the serial dictatorship mechanism [1] to compute a Pareto optimal matching. The serial dictatorship mechanism works as follows. Arbitrate a total ordering on all the agents. Let all agents pick their top choice of the remaining houses one by one following the total order. This algorithm is sequential and takes $O(n^{2})$ computation steps. Also, it does not necessarily give a maximum cardinality Pareto optimal matching. The paper [3] studies the problem of finding a maximum cardinality Pareto optimal matching for the housing allocation problem in the sequential setting. Their algorithm first computes a maximum cardinality matching of the bipartite graph formed by agents and houses and then improves the matching to be Pareto optimal. Their algorithm runs in $O(\sqrt{n}m)$ sequential time, where $n$ is the number of agents plus the number of houses, and $m$ is the number of edges of the agent-house bipartite graph. They also show that any improvement to the complexity of their algorithm would imply an improved algorithm for finding a maximum matching in a bipartite graph.

For the housing market problem, Shapley and Scarf [19] prove that there exists at least one matching in the core of any housing market and present the well-known top trading cycle (TTC) mechanism, which they attribute to David Gale. This mechanism works by repeatedly finding the top preference cycles and exchanging houses along those cycles. It takes $O(n^{2})$ sequential steps. Ma [12] shows that the TTC mechanism is the only individually rational, Pareto-efficient, and strategy-proof mechanism. Roth and Postlewaite [18] show that there is exactly one core for each housing market instance. Note that the matching obtained by the TTC mechanism is not only a Pareto optimal maching, but also the unique core.

The parallel complexity of both these problems has not been studied in the literature. The housing allocation problem is a variant of the stable marriage problem with only one sided preferences. The decision version of the stable marriage problem, i.e, given a pair of man and woman, to decide whether they are matched in the man-optimal stable matching, is CC-complete [14]. The CC class [14] is the set of problems logspace reducible to the comparator circuit value problem. Currently, there are no efficient parallel algorithms for this class of problems. It is conjectured that CC is incomparable with NC [6, 14], the class of problems computable in polylog parallel time. In this work, we show that finding the core of a housing market is CC-hard, which can be taken as evidence that this problem is not parallelizable. Although finding the core is hard, we show that given a matching, it can be verified in NC whether it is the core. On the other hand, finding a Pareto optimal matching is easier than finding the core. We show that finding a maximum cardinality Pareto optimal matching can be done in RNC2 and quasi-NC2, where RNC2 represents the problems which have uniform circuits of polynomial size and $O(\log^{2}n)$ depth and quasi-NC2 represents the problems which have uniform circuits of quasi-polynomial size $n^{O(\log n)}$ , and $O(\log^{2}n)$ depth.

In this paper, we also study the housing market problem in the distributed setting. Specifically, we give a symmetric distributed algorithm for the TTC mechanism. By symmetric, we mean that each agent performs the same role.

In summary, this paper makes the following contributions:

• •

We prove that computing the core of a housing market is CC-hard, by giving a logspace reduction from the lexicographically first maximal matching problem, which is a CC-complete problem, to the housing market problem.

• •

We show that computing a maximum cadinality Pareto optimal matching for the housing allocation problem is in RNC2 and quasi-NC2.

• •

We give a symmetric distributed TTC algorithm for computing the core of a housing market, which runs in $O(n)$ rounds and require $O(n^{2})$ messages.

The paper is organized as follows. Section 2 gives preliminaries for the housing allocation and the housing market problem. Section 3 studies the parallel complexity of the housing market problem. Section 4 presents a parallel algorithm for computing a maximum cardinality Pareto optimal matching for the housing allocation. Section 5 presents a distributed algorithm for computing the core of a housing market. Finally, section 6 present the conclusions and future work.

2 Preliminaries

The housing allocation problem deals with assigning indivisible houses to agents who have preferences over these houses. In general, a housing allocation instance $(A,H,P)$ consists of

     (1) a set of agents $A=\{a_{1},a_{2},...,a_{n}\}$,

     (2) a set of indivisible houses $H=\{h_{1},h_{2},...,h_{m}$},

     (3) a preference profile $P=\{\prec_{a_{1}},\prec_{a_{2}},...,\prec_{a_{n}}\}$, where $\prec_{a_{i}}$ defines a strict preference of

          agent $a_{i}$ on a subset of houses.

We restrict our attention to strict preference profiles where each agent defines a strict total order over a subset of houses. Let $N(i)$ denote the subset of acceptable houses for agent $i$. The goal of the housing allocation problem is to find a Pareto optimal matching of agents to houses. For a matching $\mu$ and an agent $i$, let $\mu(i)$ denotes the house matched to agent $i$. We use $h\prec_{i}h^{\prime}$ to denote that agent $i$ prefers house $h$ to house $h^{\prime}$. For two matchings $\mu$ and $\nu$, $\mu\prec_{i}\nu$ denotes that agent $i$ prefer $\mu(i)$ to $\nu(i)$. The definitions of Pareto Domination and Pareto Optimality [19] are given as below.

Definition 2.1**.**

(Pareto Domination). Suppose $\mu,\nu$ are matchings. Then $\mu$ Pareto dominates $\nu$ if and only if

(1) $\mu\preceq_{i}\nu$ for all $i\in A$,

(2) $\mu\prec_{j}\nu$ for some $j\in A$.

We use $\mu\prec\nu$ to denote that matching $\mu$ Pareto dominates matching $\nu$.

Definition 2.2**.**

(Pareto Optimality). Suppose $\mu$ is a matching. Then $\mu$ is Pareto optimal if and only if it is not Pareto dominated by any other matching $\nu$.

The housing market problem is a variant of the housing allocation problem, where there is an initial endowment of houses to agents and we have the same number of agents and houses. Let $\mu_{0}$ be a matching denoting the initial endowment of houses to agents. Let $(A,H,P,\mu_{0})$ denote an instance of a housing market. In the housing market problem, in addition to Pareto optimality, we also want a matching to be individually rational [2] defined as follows.

Definition 2.3**.**

(Individually Rational). Suppose $\mu$ is a matching of agents to houses in a housing market. Then $\mu$ is individually rational if $\mu(a)\preceq_{a}\mu_{0}(a)$ for all $a\in A$.

Individual rationality means an agent is willing to give up its initially assigned house only when it can get a better house. To define the core of a housing market, let us first define the concept of coalition. Informally, given a matching $\mu$, a coalition w.r.t $\mu$ is a set of agents $A^{\prime}\in A$ such that, by only switching houses within themselves, each agent in $A^{\prime}$ can get a house at least as good as its house in $\mu$ and at least one agent gets a strictly better house.

Definition 2.4**.**

(Coalition). Given a housing market $(A,H,P,\mu_{0})$ and a matching $\mu$, a set of agents $A^{\prime}\subseteq A$ form a coalition w.r.t $\mu$ if there exists a matching $\nu$ such that

(1) $\nu(a)\in\{\mu_{0}(b)\leavevmode\nobreak\ |\leavevmode\nobreak\ b\in A^{\prime}\},\leavevmode\nobreak\ \forall a\in A^{\prime}$

(2) $\nu(a)\preceq_{a}\mu(a)\leavevmode\nobreak\ \forall a\in A^{\prime}$

(3) $\exists\leavevmode\nobreak\ a\in A^{\prime}\leavevmode\nobreak\ \text{such that}\leavevmode\nobreak\ \nu(a)\prec_{a}\mu(a)$

Condition (1) says that to get matching $\nu$ from $\mu_{0}$, the agents in $A^{\prime}$ only switch houses within themselves. Condition (2) means that in matching $\nu$ each agent in $A^{\prime}$ is matched to a house at least as good as the house it gets matched to in $\mu$. Condition (3) means that at least one agent is matched to a better house in matching $\nu$. The core [19] of a housing market is defined as follows.

Definition 2.5**.**

(Housing Market Core). The core of a housing market problem is a set of matchings $M$ such that matching $\mu\in M$ if and only if there does not exist any coalition $A^{\prime}$ w.r.t $\mu$.

Essentially, a matching is in the core of a housing market if there does not exist a set of agents such that they can match to better houses by breaking away from other agents and exchanging houses within themselves. An individually rational and Pareto optimal matching is not necessarily a core matching, whereas a core matching must be individually rational and Pareto optimal. An example to illustrate the difference between a core matching and an individually rational Pareto optimal matching is given in Fig. 1.

It is easy to see that both $M_{1}$ and $M_{2}$ are individually rational and Pareto optimal matchings. $M_{2}$ is the core matching but $M_{1}$ is not. In $M_{1}$, agents $a_{1}$ and $a_{2}$ can form a coalition within themselves and swap houses. Suppose $a_{1}$ and $a_{2}$ break away from other agents and switch houses with each other. Then, $a_{1}$ gets house $h_{2}$, which is the same as the house it gets in $M_{1}$, and $a_{2}$ gets house $h_{1}$, which is strictly better than the house it gets in $M_{1}$. Thus, $M_{1}$ is not the core. On the other hand, in $M_{2}$, there does not exist two agents such that at least one will be strictly better off by forming a coalition and swapping houses among themselves.

The following result is well-known.

Lemma 2.6** ([18]).**

There is exactly one unique matching in the core of a housing market instance.

Since the core of a housing market has one unique matching, we use the core to mean this unique matching henceforth. The TTC algorithm given by Shapley and Scarf [19] computes the unique core of a housing market. This algorithm works in stages. At each stage, it has the following steps:

     Step 1. Construct the top choice directed graph $G_{t}=(A,E)$ on the set of agents as follows. Add an arc from agent $i\in A$ to agent $j\in A$ if $j$ holds the current top house of $i$.

     Step 2. Since each node has exactly one outgoing edge in $G_{t}$, there must be at least one cycle, which could be a self-loop. All cycles are node disjoint. Find all the cycles in the top trading graph and implement the trade indicated by the cycles, i.e, each agent which is in any cycle gets its current top house.

     Step 3. Remove all agents which get their current top houses and remove all houses which are assigned to some agent from the preference list of remaining agents.

The above steps are repeated until each agent is assigned a house. At each stage, at least one agent is assigned a final house. Thus, this algorithm takes $O(n)$ stages in the worse case and needs $O(n^{2})$ computational steps.

3 Parallel Algorithms for Housing allocation and Housing Market

In this section, we study the parallel complexity of the housing allocation and housing market problem. The parallel computation model we use here is the CREW PRAM model [11]. First, we show that computing a Pareto optimal matching in a housing allocation is CC by reducing this problem to the lexicographically first maximal matching problem (LFMM), which is a CC-complete problem [14]. In the LFMM problem, we are given a graph $G(V,E,\prec)$ where $\prec$ denotes a total ordering on the edges. If $e_{1}\prec e_{2}$, we say that $e_{1}$ precedes $e_{2}$. The total order $\prec$ allows us to regard a matching $M$ as a sequence $S_{M}=(e_{1},e_{2},...)$ of edges in ascending order, i.e, $j<k\implies e_{j}\prec e_{k}$. Given two matchings $M$ and $N$, we say $M\prec N$ if $S_{M}$ lexicographically precedes $S_{N}$. The relation $\prec$ defines a total order over all maximal matchings. The minimum element, $M_{lex}$, of this order is call the lex-first maximal matching of $G(V,E,\prec)$. We need to decide whether a given edge $e$ is in the lex-first maximal matching of the graph. Then, we show that computing the unique core of a housing market is CC-hard, by giving a logspace reduction from the LFMM problem to the housing market problem. We say a problem is CC-hard if every problem in CC reduces to it.

Theorem 3.1**.**

Computing a Pareto optimal matching for a housing allocation is in CC.

Proof 3.2**.**

We reduce the problem of computing a Pareto optimal matching to the LFMM problem. Given a housing allocation instance $(A,H,P)$, we construct an agent-house bipartite graph $G=(A\cup H,E,\prec)$ where $\prec$ denotes a total ordering of edges. There is an edge from an agent $u\in A$ to a house $v\in H$ if $v$ is acceptable to $u$. For each agent $u$, let $r_{u}:H\rightarrow[|N(u)|]$ denote its rank function, i.e, $r_{u}(v)$ denote the rank of house $v$ at agent $u$’s preference list. We assign an arbitrary unique ordering to all the agents, i.e, a one-to-one function $f:A\rightarrow[n]$, where $n=|A|$. For each edge $(u,v)$, we associate the tuple $<f(u),r_{u}(v)>$ with it. We define the total order $\prec$ on edges as the lexicographical ordering of the tuples associated with them. Clearly, $\prec$ defines a total ordering on all edges. We claim that the lex-first maximal matching $M_{lex}$ of this graph corresponds to a Pareto optimal matching. Suppose not, then there exists another maximal matching $M^{\prime}$ which dominates $M$. There must exist an agent $u\in A$ such that $u$ prefers $M^{\prime}(u)$ to $M(u)$. We have that $r_{u}(M^{\prime}(u))<r_{u}(M(u))$, which means that $(u,M^{\prime}(u))\prec(u,M(u))$, contradicting the fact that $M$ is the lex-first maximal matching.

Corollary 3.3**.**

There is a $\tilde{O}(\sqrt{|E|})$ time parallel algorithm which uses $O(|E|)$ processors to compute a Pareto optimal matching, where is $|E|$ is the number of acceptable agent-house pairs.

Proof 3.4**.**

Follows from the fact that there is a $\tilde{O}(\sqrt{|E|})$ time parallel algorithm for the LFMM problem [14].

Corollary 3.5**.**

There is a $O(\sqrt{n})$ round distributed algorithm in the congest clique model for computing a Pareto optimal matching, where is $n$ is the number of agents and houses.

Proof 3.6**.**

The paper [4] gives a $O(\sqrt{n})$ distributed algorithm for the weighted stable marriage problem. The LFMM problem is simply a subcase of the weighted stable marriage problem. Thus, the same algorithm can be applied here.

Remark 3.7**.**

In the housing market problem, an individual rational and Pareto optimal matching must be a perfect matching of houses to agents. Thus, the reduction given in Theorem 3.1 cannot be applied. Instead, the problem of computing a individual rational and Pareto optimal matching can be reduced to the problem of lex-first perfect matching. Unfortunately, the complexity of this problem is unknown.

In a housing market $(A,H,P,\mu_{0})$, the weighted agent-house bipartite graph $G=(A\cup H,E,w)$ is defined as follows. There is an edge between agent $a_{i}\in A$ and house $h_{j}\in H$ if either $h_{j}=\mu_{0}(a_{i})$ or $a_{i}$ prefers $h_{j}$ to $I(a_{i})$. The weight of the edge is defined as the the rank of $h_{j}$ in $a_{i}$’s preference list. To compute an individual rational and Pareto optimal matching for a housing market, we first observe the following lemma from [7].

Lemma 3.8** ([7]).**

A minimum weight perfect matching of the weighted agent-house bipartite graph is an individual rational and Pareto optimal matching.

Proof 3.9**.**

Let $u$ be a minimum perfecting matching of the agent-house bipartite graph. Suppose $u$ is not Pareto optimal. Then there must be another perfect matching $v$ such that $v$ Pareto dominates $u$. By the definition of Pareto domination, we can easily argue that $v$ has smaller weight than $u$, contradiction.

Combining with the results from [9] and [16], we have the following result.

Theorem 3.10** ([7, 9, 16]).**

There is a RNC2* algorithm and a quasi-NC2** algorithm for computing a individually rational and Pareto optimal matching of a housing market, which require $O(n^{3}\cdot m)$ and $n^{O(\log n)}$ parallel processors, respectively.*

Proof 3.11**.**

By Lemma 3.8, to compute an individually rational and Pareto optimal matching, we can find a minimum weight perfect matching of the agent-house bipartite graph. By the results of [16] and [9], computing the minimum weight perfect matching of a bipartite graph is in RNC2* and quasi-NC2**.*

Now we show that computing the core of a housing market is CC-hard.

Theorem 3.12**.**

Computing the core of a housing market is CC-hard.

Proof 3.13**.**

We reduce the LFMM problem to the housing market problem. Let $G=(V,E,\prec)$ be an instance of a LFMM problem, where $\prec$ represents the total ordering on the edges. Let $M_{lex}$ denote the lex-first maximal matching of $G$. We construct an instance for the housing market problem as follows. For each node $v\in V$, we create an agent $a_{v}$ and a house $h_{v}$. So, we have $|A|=|H|=|V|$. Each agent $a_{v}$ is initially assigned house $h_{v}$. The preference list for each agent is constructed based on the total ordering of edges in $E$. Note that to compute the core of a housing market, the preference list of an agent below its initial assigned house is irrelevant, since the core must be individually rational. So for each agent, we only need to specify the part of the preference list above its initial assigned house. For each pair of agents $a_{u}$ and $a_{v}$, if edge $(u,v)$ exists in graph $G$, then agent $a_{u}$ prefers the house $h_{v}$ of agent $a_{v}$ to its own house $h_{u}$ . Otherwise, agent $a_{u}$ prefers its own house $h_{u}$ to $h_{v}$. In other words, for each edge $(u,v)\in E$, agent $a_{u}$ prefers house $h_{v}$ of agent $a_{v}$ to its own house $h_{u}$. The preference list of an agent $a_{u}$ is defined based on the order of edges incident to vertex $u$, i.e, agent $a_{u}$ prefers the house $h_{v}$ of agent $a_{v}$ to the house $h_{w}$ of agent $a_{w}$ if $(u,v)\prec(u,w)$. Since all edges are totally ordered, the preference list for each agent is strict. Fig. 2 shows an example of reduction above. Clearly, the above reduction can be done in logarithmic space.

We claim that an edge $e=(u,v)\in E$ is in $M_{lex}$ if and only if agent $a_{u}$ and $a_{v}$ switch houses with each other in the core of the housing market instance. We say that an edge is minimum in its neighborhood if it is smaller than all its neighboring edges. Recall that the greedy algorithm for LFMM works as follows. Add each edge which is minimum in its neighborhood in the current graph into $M_{lex}$ and remove all incident edges of the two endpoints of each such edge. Repeat the above procedure until the graph is empty. Since the greedy algorithm computes the unique lex-first maximal matching of a LFMM instance and the TTC algorithm computes the unique core of a housing market, it suffices to show that the TTC algorithm on the housing market instance simulates the greedy algorithm on $G$.

Let $G^{i}=(V^{i},E^{i})$ denote the reduced graph at the beginning of stage $i$ of the greedy algorithm. $G^{0}=G$. Let $R^{i}$ denote the set of edges in $E^{i}$ added into $M_{lex}$ by the greedy algorithm at stage $i$, i.e, the set of edges which are minimum in their neighborhoods in $G^{i}$. Let $M_{lex}^{i}$ denote the set of edges in $M_{lex}$ at the end of stage $i$. Let $G_{t}^{i}$ denote the top choice graph formed by remaining agents at stage $i$ of the TTC algorithm. We now show by induction on stages that an edge $(u,v)$ is added into $M_{lex}$ at stage $i$ of the greedy algorithm iff the corresponding agents $a_{u}$ and $a_{v}$ switches houses at stage $i$ of the TTC algorithm.

Base case: stage 0. Consider an edge $e=(u,v)\in R^{0}$. In the housing market, two agents $a_{u}$ and $a_{v}$ correspond to this edge. Since $e$ is the minimum in its neighborhood, agent $a_{u}$ and agent $a_{v}$ are the top choice of each other. Thus, they form a top trading cycle of length 2 in $G_{t}^{0}$ and switch houses with each other in the TTC algorithm. Therefore, all edges in $R^{0}$ correspond to the top trading cycles in $G_{t}^{0}$.

*Induction case: assume the claim holds for stage $i$. Consider stage $i+1$ of both algorithms. At the end of stage $i$, in the greedy algorithm, all edges incident to edges in $R^{i}$ are removed from the graph. In the TTC algorithm, all houses involved in the top trading cycles are removed from the preference list of remaining agents. We claim for each edge $e=(u,v)\in R^{i+1}$, the two corresponding agents $a_{u}$ and $a_{v}$ in the housing market form a top trading cycle of length 2 in $G_{t}^{i+1}$. Suppose not. Let $e^{\prime}=(u^{\prime},v^{\prime})\in R^{i+1}$ be an edge such that agent $a_{u^{\prime}}$ and agent $a_{v^{\prime}}$ do not form a top trading cycle in $G_{t}^{i+1}$. We must have that either house $h_{v^{\prime}}$ is not the top choice of agent $a_{u}$ or house $h_{u^{\prime}}$ is not the top choice of agent $a_{v^{\prime}}$ or both. Without loss of generality, assume house $h_{v^{\prime}}$ is not the top choice of agent $a_{u^{\prime}}$. We have two cases.

Case 1: house $h_{v^{\prime}}$ is not available for agent $a_{u^{\prime}}$. Then, agent $a_{v^{\prime}}$ participates in a certain top trading cycle before stage $i+1$. By induction assumption, this means that there exists one edge $e_{v^{\prime}}$ incident to vertex $v^{\prime}$ which is added into $M_{lex}$ at a stage before $i+1$, contradicting the fact that edge $(u^{\prime},v^{\prime})$ exists in $E^{i+1}$.

Case 2: house $h_{v^{\prime}}$ is available for agent $a_{u^{\prime}}$ but is not the current top choice for $a_{u^{\prime}}$. Then, there exists another agent $a_{w^{\prime}}$ such that agent $a_{u^{\prime}}$ prefers the house $h_{w^{\prime}}$ of $a_{w^{\prime}}$ to the house of agent $a_{v^{\prime}}$. The existence of agent $a_{w^{\prime}}$ indicates that it is not involved in any top trading cycle before stage $i+1$. By induction assumption, there does not exist any edge $e_{w^{\prime}}$ in $M_{lex}^{i}$ which is incident to vertex $w^{\prime}$. Thus, we have $(u^{\prime},w^{\prime})\in E^{i+1}$. The fact that agent $a_{u^{\prime}}$ prefers the house of agent $a_{w^{\prime}}$ to the house of $a_{v^{\prime}}$ indicates that $(u^{\prime},w^{\prime})\prec(u^{\prime},v^{\prime})$ which contradicts the fact that $(u^{\prime},v^{\prime})$ is minimum in its neighborhood.*

Even though we do not know any NC algorithm for either computing an individual rational and Pareto optimal matching or computing the core of a housing market, given a matching, we can verify whether it is an individual rational and Pareto optimal matching and whether it is the core in NC.

Theorem 3.14**.**

Given a matching $\mu$ of houses to agents in a housing market $(A,H,P,\mu_{0})$, the following two tasks can be performed in NC.

1) Verifying whether $\mu$ is individual rational and Pareto optimal. 2) Verifying whether $\mu$ is the unique core.

Proof 3.15**.**

1). Given a matching $\mu$, to check whether it is individual rational, we just need to check whether we have $\mu\prec_{a}\mu_{0}$ for each agent $a\in A$. Observe that if $\mu$ is individually rational, it must be a perfect matching. Then, to verify whether it is Pareto optimal, we construct a directed graph $G=(A,E)$ as follows. There is an arc $<u,v>$ from agent $u$ to $v$ if agent $u$ prefers $\mu(v)$ to $\mu(u)$. We claim that $\mu$ is Pareto optimal iff $G$ is cycle-free.

($\Rightarrow$). Suppose $G$ is not cycle-free. Then there exists a directed cycle in $G$. Since each arc $<u,v>$ in $G$ represents the fact that agent $u$ prefers the house of agent $v$ in matching $\mu$. Switching houses following the cycle gives better houses for all agents in the cycle, which gives a new matching $\nu$ and $\nu\prec\mu$, contradiction to the fact that $\mu$ is Pareto optimal.

($\Leftarrow$). Suppose that $\mu$ is not Pareto optimal. Then there exists another matching $\nu$ such that $\nu\prec\mu$. The difference between $\nu$ and $\mu$ is a set of disjoint cycles. Since each agent in $\nu$ is matched to a house at least as good in $\mu$, each such cycle must be a directed cycle in $G$.

Checking whether $G$ is cycle-free can be done in NC by first computing the transitive closure $TC$ of $G$ and for each vertex $u$, checking whether there exists a vertex $v$ such that $TC(u,v)=1$ and $TC(v,u)=1$. Thus, verifying whether a given matching is individual rational and Pareto optimal can be done in NC.

2). Given a matching $\mu$, to verify whether it is the core, we construct a different directed graph $G^{\prime}(V^{\prime},E^{\prime})$ as follows. $V^{\prime}$ represents the set of agents. There are two types of arcs: solid arcs and dashed arcs. There is a solid arc from agent $u$ to agent $v$ if $\mu(u)=\mu_{0}(v)$, i.e, agent $u$ is assigned the house owned by agent $v$. Hence, the solid arcs represent how agents switch houses to get matching $\mu$ from the initial matching $\mu_{0}$. Thus, all solid arcs form a set of disjoint directed cycles. There is a dashed arc from agent $u$ to agent $v$ if $\mu_{0}(v)\prec_{u}\mu(u)$.

We claim that $\mu$ is the core iff there is no directed cycle which contains dashed arcs in $G$. We show that any directed cycle with at least one dashed arc represents a coalition, w.r.t $\mu$. Let $C$ be such a cycle in $G$. If we switch houses following the cycle $C$, i.e, for each arc $<u,v>$ in $C$, agent $u$ matches to house $\mu_{0}(v)$. For each solid arc $<u,v>\in C$, we have $\mu(u)=\mu_{0}(v)$ by the definition of solid arc. Thus, each agent with a solid outgoing arc matches to the same house as in $\mu$. For each dashed arc $<u,v>\in C$, we have $\mu_{0}(v)\prec_{u}\mu(u)$, thus each agent with a dashed outgoing arc matches to a house strictly better than its house in $\mu$. Thus, each directed cycle with at least one dashed edge represents a coalition of agents, w.r.t $\mu$. Since a matching $\mu$ is in the core iff there is no coalition with respect to $\mu$ and each directed cycle with dashed arcs represent a coalition, we get our desired claim.

To check whether there exists a directed cycle with at least one dashed arc in $G^{\prime}$, we first compute the transitive closure $TC^{\prime}$ of $G^{\prime}$. For each dashed arc $<u,v>$, check in parallel whether $TC^{\prime}(v,u)=1$. Thus verifying whether a matching is the core can be done in NC.

3.1 A Parallel Algorithm for Maximum Pareto Optimal Matching

In the housing allocation problem, a Pareto optimal matching does not necessarily have maximum cardinality, i.e, with maximum number of agents matched to a house. To find a maximum cardinality Pareto optimal matching, we adapt the sequential algorithm in [3] to be a parallel algorithm. The sequential algorithm in [3] has three steps. To ensure that the final matching has maximum cardinality, step 1 computes a maximum cardinality matching. After step 1, all unmatched agents are removed from consideration. At step 2, the algorithm improves the matching obtained from step 1 to be trade-in-free. A matching $M$ is trade-in-free if there is no (agent,house) pair $(a_{i},h_{j})$ such that $a_{i}$ is matched in $M$, $h_{j}$ is unmatched in $M$, and $a_{i}$ prefers $h_{j}$ to $M(a_{i})$. That is, step 2 ensures that no matched agents prefers an unmatched house to its current matched house. After step 2, all unmatched houses are removed from consideration, since no matched agents prefer any of those houses to their matched houses. The final step is to improve the matching obtained from step 2 to be Pareto optimal, which is achieved by directly applying the TTC mechanism on all matched agents.

Our parallel algorithm, shown in Fig. 4 has only two steps. At step 1, we compute the maximum cardinality matching, which can be reduced to compute a minimum weight perfect matching of a new graph. Let $M^{\prime}$ be the maximum cardinality matching obtained at step 1. Let $A^{\prime}$ be the set of matched agents. After step 1, all the unmatched agents are removed from consideration. At step 2, we improve the matching obtained from step 1 to be Pareto optimal. In contrast to [3], we do not first make our matching trade-in-free and then Coalition-free. Instead, we directly compute a Pareto optimal matching by computing a minimum weight perfect matching of a graph $G^{\prime}$ constructed as follows. We create a set of virtual agents $B^{\prime}$ to ensure the number of agents is equal to the number of houses. Add an edge with weight 0 between each virtual agent and each house. For each real agent $a_{i}\in A^{\prime}$ and each house $h_{j}\in H$, add an edge between $a_{i}$ and $h_{j}$ if $h_{j}$ is $a_{i}$’s partner at the end of step 1 or $a_{i}$ prefers $h_{j}$ to its partner. The weight of edge $(a_{i},h_{j})$ is equal to the rank of $h_{j}$ in $a_{i}$’s preference list.

Let $G^{\prime}(A^{\prime}\cup B^{\prime}\cup H,E^{\prime},w^{\prime})$ be the graph constructed at Step 2. The following lemma shows the correctness of algorithm 5.

Lemma 3.16**.**

The matching output by algorithm 5 is a maximum cardinality Pareto optimal matching for a housing allocation.

Proof 3.17**.**

Let $M^{\prime}$ be the minimum weight perfect matching of $G^{\prime}$. Let $M^{*}$ be the matching output by algorithm 5, which is the induced submatching of $M^{\prime}$ on the set of matched agents $A^{\prime}$ after step 1. Step 1 ensures that $M^{*}$ is a maximum cardinality matching. It remains to show that $M^{*}$ is Pareto optimal. Suppose for contradiction that $M^{*}$ is not Pareto optimal. Then there exists some other matching $M^{\prime\prime}\not=M^{*}$ on real agents such that $M^{\prime\prime}\prec M^{*}$. By definition of Pareto optimality, each agent in $M^{\prime\prime}$ should be matched to a house at least as good as the house in $M^{*}$ and at least one agent is matched to a strictly better house in $M^{\prime\prime}$. Since $M^{*}$ is a maximum cardinality matching, $M^{\prime\prime}$ must also be a maximum cardinality matching which matches the same set of agents as $M^{*}$. Since the weight of an edge $(a_{i},h_{j})$ is defined as the rank of $h_{j}$ at $a_{i}$’s preference list, we have $w^{\prime}(M^{\prime\prime})<w^{\prime}(M^{*})$. Since each virtual agent has incident edges of weight 0 in $G^{\prime}$, there exists another perfect matching formed by edges in $M^{\prime\prime}$ and some edges incident to virtual agents such that the total weight is smaller than $M^{{}^{\prime}}$, contradicting the fact that $M^{\prime}$ is the minimum perfect matching of $G^{\prime}$.

Now, we can state our main result for the housing allocation problem.

Theorem 3.18**.**

There is a RNC2* and quasi-NC2** algorithm for finding a maximum cardinality Pareto optimal matching for the housing allocation problem.*

Proof 3.19**.**

By Lemma 3.16, the matching obtained by algorithm 5 is a maximum cardinality Pareto optimal matching. The time complexity of algorithm 5 is dominated by the complexity of a minimum weight perfect matching of a graph. By [16] and [9], this step can be done in RNC2* and quasi-NC2**.*

4 Distributed Algorithms for Housing markets

In this section, we present a symmetric distributed algorithm to implement the TTC mechanism in a distributed setting. We assume a distributed message passing model with $n$ processes, $p_{1},\dots,p_{n}$, which form a completely connected topology. The system is synchronous, which means that there is an upper bound on the time for a message to reach its destination. We require that at each round, a node can only send a same message of $O(\log n)$ size to any other node in the network. Since the graph is fully connected, this model is also known as the congest clique model in the literature. Actually, our proposed distributed algorithm fits in a more restricted model called the broadcast congest clique model [8], since at round each node only sends the same message to all other nodes in the network. This model is in contrast to the unicast congest clique model [8] which allows each node to send different messages to different nodes in each round.

To implement the top trading cycle algorithm in a fully distributed way, we need efficient distributed algorithms for finding the top trading cycle. Observe that the graph formed by the top choice of each agent is a functional graph since each node has only one outgoing edge. Hence there is only one unique cycle in each connected component of this graph. We present two distributed algorithms for finding all the top trading cycles in a functional graph.

4.1 A Las Vegas Algorithm for Finding Cycles in Functional Graphs

In this section, we give a Las Vegas algorithm, shown in Fig. 5, for finding all the disjoint cycles in a functional graph. The primary gradient of the algorithm is a pointer jumping technique. A similar technique is used in [15, 20] to solve the list ranking problem.

In this algorithm, each node has a variable active, which is initially true. A node terminates the code when active becomes false. Each node uses the variable $succ$ to record its current successor node, which initially is its outgoing neighbor. Our algorithm will build a tree. The $children$ variable denotes the current children of a node, which is essentially all the nodes that have been its successor. The $inCycle$ variable denotes whether a node is in the cycle or not. The algorithm is composed of iterations and each node keeps executing an iteration until active becomes false. Each iteration includes two steps: a Coin-flip step and a Explore step. In the Coin-flip step, each active node flips a coin. If a node flips head and its successor node flips tail, it becomes inactive. This step is used to reduce the active nodes by a constant fraction. In the Explore step, each active node traverses along the path formed by the successor pointer of all nodes and tries to update its successor pointer to be next active node in the path. It also adds all inactive node encountered into its children set. When such a active node is found, it checks whether such a node is actually itself, if that is the case, a cycle is detected. After a node determines that it is in the cycle (we will show that there is a unique such node), it broadcasts a cycle message along the tree formed by the child relationship (Notify step). We will prove that the set of nodes in the tree rooted at such a node and formed by the child relation is exactly the set of cycle nodes. For the purpose of analysis, we assume the functional graph we consider only has one component, which also means it only has one cycle. Our algorithm works for functional graph with multiple components, since the executions on different components are independent.

We now show that at the end of algorithm 1 each node correctly knows whether it is in the cycle or not. Let $succ[i]$ denote the value of $succ$ for $P_{i}$. First, we can easily get the following lemma from the code.

Lemma 4.1**.**

At the end of algorithm 1, there is exactly one node $i$ which has $succ[i]=i$ for each disjoint cycle in the functional graph.

Proof 4.2**.**

For node $i$, if $succ[i]=j$ at some point, then there exists a directed path from node $i$ to node $j$. Let us consider a single connected component of the functional graph. For any non-cycle node, its $succ$ cannot be itself since it does have a directed path to itself. Hence, it is sufficient to consider only cycle nodes. We first show there is at least one node $i$ with $succ[i]=i$. We claim that there is at least one active cycle node remaining after the Coin-flip step of each iteration. To become inactive, a node has to flip head and its successor has to flip tail. This implies that two consecutive active nodes cannot become inactive simultaneously. Hence, at the end of the algorithm at least one cycle node $i$ with $succ[i]=i$. Also, it is obvious that at most one cycle node $i$ can have $succ[i]=i$ at the end of the algorithm. Therefore, there is exactly one node $i$ which has $succ[i]=i$ for each disjoint cycle in the functional graph.

Let $i$ be the node with $succ[i]=i$ at the end of the algorithm. Let $T$ be the tree rooted at node $i$ and constructed from the child relation at the end of the algorithm. Let $V_{T}$ denote the set of nodes in tree $T$. Let $C$ denote the set of nodes in the cycle.

Lemma 4.3**.**

$C=V_{T}$**

Proof 4.4**.**

We prove $C\subseteq V_{T}$ and $V_{T}\subseteq C$. Suppose node $i$ runs for $L$ iterations. Let $A_{r}$ denote the set of active cycle nodes at round $r$, $1\leq r\leq L$. To prove $C\subseteq V_{T}$, we show by induction that each node in $A_{r}$ is in tree $T$ for all $r$.

Base case, $r=L$. $A_{L}=\{i\}$. Node $i$ is the root of $T$.

Induction case: Suppose each node in $A_{k}$ is in $T$. We need to show that each node in $A_{k-1}$ is in $T$. It is sufficient to show that the nodes in $A_{k-1}$ which become inactive at round $k$ are in $T$. Since all active cycle nodes at each round still form a cycle, $A_{k}$ divides $A_{k-1}$ into multiple directed paths. For any path $P$ of form $v_{i},v_{i+1},...,v_{j}$, only the two end nodes $v_{i}$ and $v_{j}$ are in $A_{k}$. From the code we know that node $v_{i}$ continues to find active nodes along $P$ at round $k$, and it stops until it reaches node $v_{j}$. Thus, all nodes in path $P$ between $v_{i}$ and $v_{j}$ become the children of node $v_{i}$. So, all nodes in path $P$ are in $T$. Hence, all nodes in $A_{k-1}$ are in $T$. Therefore, we have $A_{r}$ is in $T$ for any $1\leq r\leq L$. Since $A_{1}$ is exactly the set of cycles nodes, we have all cycles nodes are in $T$. Thus, $C\subseteq V_{T}$.

To prove $V_{T}\subseteq C$, we show that the any non cycle node is not in tree $T$. For any non cycle node $j$, suppose $j\in V_{T}$. Then $j$ must be a descendant of root node $i$. From the algorithm we know that the children relation is formed by next relation in the original graph. Thus, there must be a directed path from node $i$ to node $j$ in the original graph. This means $j$ must be in the unique cycle, a contradiction.

Theorem 4.5**.**

Algorithm 1 computes all the cycles of a functional graph $G$. It has round complexity of $O(\log l)$ and message complexity of $O(n\log l)$, w.h.p, where $l$ is the length of the longest cycle in $G$.

Proof 4.6**.**

Since the $cycle$ message only traverses through tree $T$, from Lemma 4.3, we know that each cycle node receives the $cycle$ message and each non cycle node does not receive the $cycle$ message.

Since the number of active nodes in any cycle reduces by a constant fraction in expectation at each iteration and each iteration takes constant number of rounds, by Chernoff bound, algorithm 1 takes $O(\log l)$ rounds w.h.p. Each round of the algorithm takes at most $O(n)$ messages, which results in $O(n\log l)$ messages in total.

4.2 A Deterministic Algorithm for Finding Cycles in Functional Graphs

In this section, we present a deterministic algorithm for finding all the disjoint cycles in a functional graph, shown in Fig. 6. This algorithm is similar to the las vegas algorithm in the previous section, with only one key difference. We replace the Coin-flip step in algorithm 1 to the Coloring step. Observe that in algorithm 1 the primary purpose of the Coin-flip step is to reduce the number of active nodes by a constant factor while ensuring that any two consecutive active cycle nodes cannot become inactive at the same time. Graph coloring techniques can also serve this purpose. Hence, we simply replace the coin-flip step in algorithm 1 to be a Coloring step, which is an invocation of the 6-coloring algorithm due to [5]. After the Coloring step, each node compares its color with the color of its successor. If a node has a smaller color than its successor, it becomes inactive. Then all remaining active nodes perform the Explore step as in algorithm 1.

We can observe that after the coloring step at each iteration, the node with the largest color remains active in each disjoint cycle. By similar argument, we can show that Lemma 4.1 and Lemma 4.3 still hold.

Theorem 4.7**.**

Algorithm 2 computes all the disjoint cycles in a functional graph and takes $O(\log^{*}n\log l)$ rounds and $O(n\log^{*}n\log l)$ messages.

Proof 4.8**.**

Since no more than 5 consecutive active nodes become inactive at each iteration by the property of 6-coloring, the Explore Step still takes constant rounds. The coloring step introduces an additional $O(\log^{*}n)$ factor. Thus, algorithm 2 terminates in $O(\log^{*}n\log l)$ rounds and takes $O(n\log^{*}n\log l)$ messages.

4.3 Distributed Top Trading Cycle Algorithm

We now present a distributed version of the top trading cycle algorithm. As in the sequential setting, we assume that each node knows which nodes are holding the houses in its preference list. Indeed, every node can broadcast its house to all. This only requires one round and $O(n^{2})$ messages.

The distributed algorithm is shown in Fig. 7. The basic idea is using the cycle finding algorithms presented above to simulate each stage of the top trading cycle algorithm. During a stage, all nodes first build the top choice functional graph, i.e, update their $succ$ variable to be the node which holds their current top choice. Then, all nodes execute algorithm 1 or 2 to find out whether they are in a cycle or not. After that, a cycle node gets assigned its current top choice and broadcasts a $remove$ message which contains the assigned house to all nodes. When node $P_{i}$ receives $remove$ messages from other nodes, it deletes the houses contained in the messages from the preference list, i.e, from $pref_{i}$. When executing algorithm 1 or 2, nodes might terminate at different rounds. Thus, we need to coordinate the execution of each stage. In order to achieve this, we use a convergecast step using the tree built in the execution of algorithm 1 or 2. When a node completes broadcasting its $remove$ message to all, it sends a $ok$ message to its parent in the tree if it is a leaf node in the tree. For non-leaf nodes, they send an $ok$ message to their parents only when they receive $ok$ messages from all children. For the root node, when it receives $ok$ from all its children, which means all nodes have updated their preference list, it broadcasts a $nextStage$ message to all to notify all nodes to start the next stage of the algorithm.

Since each stage of algorithm 3 simulates each iteration of the TTC mechanism. The correctness of algorithm 3 follows from the correctness of TTC. We now look at the round and message complexity.

Theorem 4.9**.**

Algorithm 3 computes the core of a housing market in $O(n)$ rounds and takes $O(n^{2})$ messages.

Proof 4.10**.**

We just analyze the complexity of adopting the Las Vagas algorithm as a subroutine. The complexity of the deterministic algorithm just has an additional $\log^{*}n$ factor. Let $l_{i}$ denote the length of the cycle at stage $i$ of algorithm 3. At stage $i$, both finding the cycle and convergecast along the tree need $O(\log l_{i})$ rounds, w.h.p. Finding the cycle takes $O(n\log l_{i})$ messages and convergecast takes $O(l_{i})$ messages. Thus, each stage takes $O(\log l_{i})$ randomized rounds and $O(n\log l_{i})$ messages. Therefore, since $\sum{l_{i}}=n$, algorithm 3 takes $O(n)$ rounds and $O(n^{2})$ messages in the worst case.

5 Conclusion

We conclude with two open problems. We have shown that computing a Pareto optimal matching for a housing allocation is in CC, which yields a linear time and linear work parallel algorithm. Computing an individual Pareto optimal matching for a housing market seems harder. It is interesting to know the relationship between this problem and the CC class. It is unlikely to be CC-complete, since this would imply a RNC2 and a quasi-NC2 algorithm for the CC class. We also show that computing the core of a housing market is CC-hard by giving a logspace reduction from the LFMM problem. It is interesting to know whether this problem is CC-complete. Or can we show that it is P-complete?