Parallel Algorithms for Equilevel Predicates

We define a new class of predicates called equilevel predicates on a distributive lattice which eases the analysis of parallel algorithms. Many combinatorial problems such as the vertex cover problem, the bipartite matching problem, and the minimum spanning tree problem can be modeled as detecting an equilevel predicate. The problem of detecting an equilevel problem is NP-complete, but equilevel predicates with the helpful property can be detected in polynomial time in an online manner. An equilevel predicate has the helpful property with a polynomial time algorithm if the algorithm can return a nonempty set of indices such that advancing on any of them can be used to detect the predicate. Furthermore, the refined independently helpful property allows online parallel detection of such predicates in NC. When the independently helpful property holds, advancing on all the specified indices in parallel can be used to detect the predicate in polylogarithmic time. We also define a special class of equilevel predicates called solitary predicates. Unless NP= RP, this class of predicate also does not admit efficient algorithms. Earlier work has shown that solitary predicates with the efficient advancement can be detected in polynomial time. We introduce two properties called the antimonotone advancement and the efficient rejection which yield the detection of solitary predicates in NC. Finally, we identify the minimum spanning tree, the shortest path, and the conjunctive predicate detection as problems satisfying such properties, giving alternative certifications of their NC memberships as a result.


INTRODUCTION
We introduce a new class of predicates called equilevel predicates to model and solve many problems in parallel and distributed computing.These predicates are defined on the elements of a distributive lattice [1].The distributive lattice is such that the height is small, but its size is large.More concretely, this lattice can be viewed as generated from a poset with at most chains and elements per chain.In this case, the height of the lattice is bounded by ( ) but the cardinality can be as many as elements.For efficiency, our methods operate on the underlying poset even though we are interested in finding an element in the lattice satisfying the given predicate.This approach allows us to obtain algorithms with complexities efficient in and .
A predicate defined on a lattice is equilevel if all the elements of the lattice that satisfy the predicate are on the same level of the lattice.It can be shown that detecting an equilevel predicate is, in general, a hard problem.For example, the minimum vertex cover problem for a graph can be modeled as detecting an equilevel predicate.Even so, we will see that there are many equilevel predicates which can be detected efficiently in parallel, and that this efficiency can be implied by a few simple properties.
As a special case, we also consider the class of equilevel predicates which hold on a single element in the underlying lattice.We call this class solitary.This class of predicates is related to the previously studied class of lattice-linear predicates [2], which are those predicates closed under the meet operation (or, the infimum operation) on the underlying lattice.Such predicates have special properties that aid in the design of efficient detection algorithms.Observe that for any lattice-linear predicate we can define a stronger predicate ′ that is satisfied only on the least element in the lattice satisfying .Then ′ is a solitary predicate.For example, consider the distributive lattice of assignments for the stable marriage problem [3,4].There may be multiple stable marriages; however, there is a unique man-optimal stable marriage.The predicate that an assignment corresponds to the man-optimal stable marriage is a solitary predicate.
In this paper, we investigate equilevel and solitary predicates, as well as the conditions giving efficient parallel algorithms for their detection.We first show that the problem of equilevel predicate is NP-complete in general.Moreover, the implications of this result are far-reaching in the landscape of lattice-linear predicate detection.For example, we show that slight generalizations of latticelinear predicate-based problems with efficient solutions, such as the conjunctive predicate detection, are NP-complete.We then define a property on equilevel predicates called the helpful property.An equilevel predicate has the helpful property with a polynomial time algorithm if the algorithm can return a nonempty set of indices such that advancing on any of them can be used to detect the predicate in polynomial time in an online manner.We apply the helpful property to modeling and efficient detection of various problems such as bipartite matching and computing bases which span sets of vectors as equilevel predicates.Furthermore, when this is refined to the stronger independently helpful property, there exists a simple NC algorithm for problems modeled as equilevel predicates.
Next, a special class of equilevel predicates, called solitary predicates, is identified.These are those predicates that can only be true on a single element in the lattice, and we show that even with this substantial restriction, detecting these predicates is still hard unless NP=RP.However, prior work implies that solitary predicates can be detected efficiently when they satisfy efficient advancement [2].We refine the efficient advancement property in a few ways to obtain NC algorithms.In particular, we show that whenever a problem satisfies the antimonotone advancement property, it can be solved in NC time when the poset generating the lattice has a small height.For example, it can be shown that the problem of the minimum spanning tree satisfies antimonotone advancement property, which gives an alternative certification of its membership in NC.Another special class of efficient advancement property giving NC algorithms is the efficient rejection property.We show that the shortest path problem [5], and the conjunctive predicate detection in distributed computations [6] satisfy this property.
In summary, this paper makes the following contributions: • The paper introduces the class of equilevel predicates.Detecting a general equilevel predicate is NP-complete.We show that a slight generalization of the conjunctive predicate detection where one asks for a global state with exactly events satisfying the conjunctive predicate is also NP-complete.• We show that any equilevel predicate with a helpful property (defined in this paper) can be detected in polynomial time.The problem of finding the size of a maximum matching in a bipartite graph falls in this class.• We show that any equilevel predicate with the independently helpful property can be detected in NC.The problem of computing a minimum spanning tree in a weighted undirected graph is shown to be in this class.• The paper introduces a subclass of equilevel predicates called solitary predicates.We show there is no randomized polynomial time detection algorithm for a solitary predicate unless NP=RP.However, any solitary predicate with the efficient advancement property can be detected in polynomial time.

• The paper introduces two subclasses of solitary predicates:
Those with the antimonotone advancement property and with the efficient rejection property.We use these properties to detect solitary predicates in NC.

RELATED WORK
Predicates on a distributive lattice whose detection models various combinatorial algorithms have been introduced in [2], [7], [8].These papers study the class of predicates called lattice-linear predicates which is equivalent to being closed under the meet operation of the lattice.It has been shown that the lattice-linear predicate (LLP) algorithm solves many combinatorial optimization problems such as the shortest path problem, the stable marriage problem, and the market clearing price problem [2].This method has been applied to other problems such as dynamic programming problems [9], the housing allocation problem [7], the minimum spanning tree problem [10], and generalizations of the stable matching problem [11].In [8], Gupta and Kulkarni extend LLP algorithms for deriving self-stabilizing algorithms.In [12], Gupta and Kulkarni also show that multiplication and modulo operations on natural numbers can be modeled as LLP algorithms.In [13], these authors continue by showing lattice-linearity simplifies the analysis of robot coordination algorithms in an asynchronous setting, and improves upon the algorithm's complexity guarantees.The above-mentioned work and the work in this paper are based on obtaining solutions to combinatorial optimization and constraint satisfaction problems through predicate detection algorithms.In the context of distributed monitoring, the technique of predicate detection was introduced by Cooper and Marzullo [14] and Garg and Waldecker [15].Regarding existing classes of predicates introduced for this setting, the detection of conjunctive predicates was examined in [6], lattice-linear predicates were introduced in [16], and regular predicates were introduced in [17].Moreover, other classes specific to distributed computing settings, such as observerindependent predicates [18], have also been investigated.
Note that equilevel predicates holding for multiple elements on one level cannot be closed under taking meets on a lattice.Thus, the LLP algorithm is inapplicable for these predicates.In contrast, when restricted to solitary predicates LLP algorithms can be applied.Thus, to advance this line of work we identify additional properties allowing parallel NC algorithms to detect solitary predicates.

EQUILEVEL PREDICATES
Throughout, we consider problems defined on a distributive lattice representing the domain.To ease the presentation of our definitions, we consider a specific representation.By Birkhoff's theorem [19], any finite distributive lattice L can be generated by a finite (a) A graph = ( { , , , }, { ( , ), ( , ), ( , ), ( , ) } ).poset .Let that poset consist of chains, i.e., can be decomposed into chains 1 , 2 , . . . of distinct elements.Thus, we can assume L is represented this way without loss of generality, and every element ∈ L can be viewed as an ideal (or, downset) of .Moreover, when examining parallel algorithms we imagine that there are processes where each process corresponds to exactly one of these chains.In this way, we treat each element ∈ L as a global state in the parallel computation, and the largest element of the chain present in as the local state of process .It follows then that a process advances a computation by augmenting the current global state with the next element in its respective chain.
Before continuing, let [ ] denote the number of elements in from , while | | denotes the cardinality counting all elements in the ideal representing .Finally, ⊥ and ⊤ correspond to the bottom and top elements of the lattice respectively.Then, a predicate on L is equilevel if all the satisfying elements are on the same level of the lattice.Definition 3.1 (Equilevel Predicate).A Boolean predicate is equilevel with respect to a lattice L iff Fig. 2 shows a search space (modeled using a distributive lattice) and a predicate and its set of satisfying solutions which are all on the same level of the lattice.We now define the notion of "detecting" a predicate.Definition 3.2 (Predicate Detection).Given a poset generating a lattice L, and a Boolean predicate , if is true on some element of lattice L, then decide "yes." Otherwise, decide "no." For example, consider the minimum vertex cover problem in an undirected graph ( , ).A subset of vertices ′ satisfies if ′ is the vertex cover of minimum size.Here, the lattice we consider is the Boolean lattice of the vertex set.It is clear that is an equilevel predicate since there may be multiple minimum vertex covers and they must all be of the same size.Then, we observe that detecting an equilevel predicate is NP-complete in general as the minimum vertex-cover decision problem is well-known to be NP-complete.
As another example of an equilevel predicate, suppose that we have a bipartite graph ( , , ) and we are interested in maximumsized subsets of that can be matched.The size of maximum-sized subsets of that can be matched to elements in is constant, even though there may be multiple matched sets in .For example, consider Equilevel predicates occur in numerous other contexts.Consider the problem of finding a minimum weight spanning tree of a connected undirected graph ( , ) with vertices.If the edge weights are not unique, then there may be multiple minimum-spanning trees with equal weight.Let the predicate be "the set of edges form a spanning tree with minimum weight." It is clear that all sets that satisfy the predicate have − 1 edges.Thus, in the inclusion lattice over the graph's edges, the sets satisfying the predicate are all at the same level.
Equilevel predicates are closed under conjunction.If predicates 1 and 2 are true for different levels, then the conjunction is false for all elements of the distributive lattice and the predicate 1 ∧ 2 is trivially equilevel.Otherwise, if they are true for the same level, then 1 ∧ 2 is also true only at that level (or possibly, always false).However, equilevel predicates are not closed under disjunction or complement because these operations may introduce elements satisfying the new predicate at many different levels of the lattice.
As we have observed, since NP-complete problems such as vertex cover can be modeled as detecting an equilevel predicate, the problem of detecting an arbitrary equilevel predicate is NP-hard.As another example, consider the problem of detecting a Hamiltonian path in an undirected graph.If we consider the Boolean lattice of all edges, then we only need to consider the subset of edges at level − 1 on a graph with vertices.Thus, the problem of Hamiltonian path can also be modeled as detecting an equilevel predicate.
We now show that some problems in distributed computation with efficient algorithms are equilevel predicates when slightly generalized.For example, consider conjunctive predicates which are given by the Boolean formula 1 ∧ 2 ∧ . . .where each is a function only of state local to the th process.For this class, there is an efficient algorithm for detecting this predicate in a distributed computation [6].However, if we generalize the problem by asking for the conjunctive predicate on a particular level of the lattice, then the problem can be modeled as an equilevel predicate.We now show that, in general, asking for a conjunctive predicate on a particular level is NP-complete.T 3.3.Given a distributed computation, deciding whether there exists a global state with events satisfying a given conjunctive predicate is NP-complete.

P
. We first show that the problem is in NP.The global state itself provides a succinct certificate.We can check that all local predicates are true in that global state and that the global state is at level .
For hardness, we use the subset sum problem.Given a subset problem on positive integers, 1 , 2 , . . ., with the requirement to choose a subset that adds up to , we create a computation on processes as follows.Each process has events.The local predicate on is true initially and also after it has executed events.Thus, the local predicate is true at each process exactly twice.The problem asks us if there is a global state with events in which all local predicates are true.Such a global state, if it exists, would choose for every process either the initial local state or the final local state.All the final states that are chosen correspond to the numbers that have been chosen.
To avoid the expansion of the numbers in binary to unary construction, we encode the representation of events on a process as follows: Since the conjunctive predicates can only be true when the local predicates are true, we keep only local states which satisfy their corresponding local predicate and store the number of local events executed so far with them.This leaves two local states at each process: The initial state with zero events executed until that point, and the final state of the process with the number of events equal to for the th process.Now, the construction of the computation from the subset sum problem is polynomial in the size of the input.
In what follows, we restrict our attention to a class of equilevel predicates to one which can be detected efficiently.

EQUILEVEL PREDICATES WITH THE HELPFUL PROPERTY
One class of equilevel predicates that we can efficiently detect is the set of predicates that satisfy the helpful property.An equilevel predicate satisfies the helpful property if, whenever it is false on a global state , we are guaranteed to be able to compute in polynomial time the indices of the local states which are helpful.Unless the global state is advanced on at least one helpful local state the predicate can never become true.Before, we define the helpful property, we introduce the notation (L) to mean that there exists ∈ L such that ( ).Now, we define the helpful property.where ℎ ( , , ) is defined as The definition states that whenever the predicate is not true in a global state , the polynomial time algorithm A can return a nonempty set of indices A ( ) such that advancing on any of the corresponding local states can be used to detect the predicate.The th local state is helpful in the global state if we can advance the global state on the index whenever ¬ ( ) holds without the risk of missing a satisfying global state .If there is no global state that satisfies , then ℎ ( , , ) holds vacuously.The helpful property allows us to efficiently detect an equilevel predicate satisfying the property.In all our examples, we also require the algorithm A to be online in the sense that the algorithm A has access to the poset only on states up to .Therefore, the computation of helpful indices is based only on the poset of states less than or equal to .

P
. Algorithm Equilevel starts with the least element in the lattice L. The while loop can execute at most times where is the number of chains and is the maximum height of any chain.The algorithm A to compute ℎ has polynomial complexity.Hence, Algorithm Equilevel also has polynomial complexity.The algorithm A has access to the lattice L only up to .
Since is an equilevel predicate, the algorithm is guaranteed to return a minimal state that satisfies .
By online detection of the predicate, we mean that the algorithm has access to the lattice only up to the current global state .For example, when we consider the stable marriage problem, the vector denotes the current assignment of men to women.The algorithm needs to make its decisions based only on the information on men preferences and women preferences up to that point.This interpretation is different from the online algorithm in the standard algorithm literature, where the information about the problem comes incrementally.
We show detection of equilevel predicates through the following examples: Example 1: Maximum Cardinality Bipartite Matching.Consider the problem of bipartite matching in a graph ( , , ).We are interested in finding a subset ⊆ of maximum size such that can be matched with vertices in .We use the Boolean lattice on the vertices .A vertex set ⊆ satisfies if | | is the maximum number of vertices that can be matched.It is clear that is an equilevel predicate.Suppose that we have a set of vertices ⊆ which is not of the maximum size.Then, we can find a set of helpful set of vertices such that any element of can be added to .It can be checked efficiently that does not satisfy (for example, by checking if there exists an alternating path from a vertex in − to an unmatched vertex in [20]).The algorithm to find helpful vertices is simple: any vertex in − that has an alternating path to an uncovered vertex in is a helpful vertex.For efficiency, the algorithm may maintain the set of matched vertices in .One can use Algorithm Equilevel to find the largest set in with matching in .The predicate ℎ ( , , ) holds whenever the vertex can be added to the current set of matched vertices .We note here that [21] discusses parallel algorithms for perfect matching in a bipartite graph.Our goal is to view the problem from the perspective of detecting a global condition.
Example 2: Minimum Spanning Tree in an Undirected Graph.Let be true on a set of edges of an undirected graph if the edge set forms a spanning tree of the graph.Given a connected undirected graph with vertices, it is well-known that any edge set that is acyclic and has − 1 edges satisfies .This predicate is equilevel because all the elements that satisfy the predicate are at the level −1 in the Boolean lattice of all edges.Given a set of edges, one can efficiently compute whether the set is acyclic.Hence, one can use Algorithm Equilevel to find a spanning tree as follows: The predicate ℎ ( , , ) holds whenever the edge does not form a cycle with edges in , so at each step Algorithm Equilevel adds any edge which does not make a cycle in the current solution.
Example 3: Basis Set of Vectors.Suppose that we are given a set of vectors of the same dimension.Our goal is to compute a basis, i.e. find a subset of the biggest size containing linearly independent vectors.The predicate is true on a set if all the vectors in are linearly independent, and there does not exist any vector in − that is linearly independent with vectors in .Here ℎ ( , , ) holds if the vector is independent of all the vectors in .
Lattice-linear predicates [2] are associated with the concept of forbidden local states.In particular, for any which does not satisfy a lattice-linear predicate , there exists at least one local state such that no global state that satisfies can have the same local state .This means that one can advance on all forbidden local states of a lattice-linear predicate unconditionally.In particular, if there are multiple local states that are forbidden then the global state can be advanced on all of them in parallel as forbidden local states remain forbidden until they are advanced.In contrast, when it comes to equilevel predicates, advancing on one helpful local state may make the local state on some other process "unhelpful." For example, in computing a spanning tree we may be able to add one of edge or edge to our current solution, but adding both of them could create a cycle.
An equilevel predicate may not have the helpful property as shown next.

T 4.3.
There exist equilevel predicates that do not have any helpful property unless P= NP.

P
. We have earlier shown that the problem of finding the vertex cover of the least size is an equilevel predicate.If there exists any helpful property for this problem, we would have a polynomial time algorithm to find the vertex cover.Similarly, detecting a conjunctive predicate at a particular level of the lattice of global states also cannot have the helpful property unless P= NP.

EQUILEVEL PREDICATES WITH THE INDEPENDENTLY HELPFUL PROPERTY
We now define a stronger version of equilevel predicates in which at every step, one evaluates which indices are independently helpful.Two helpful indices are independently helpful if it is okay to advance on both of them in parallel.This definition allows us to design parallel algorithms for equilevel predicates.where -( , , ) is defined as such that with a polylogarithmic number of parallel advancements, the predicate is detected.
Observe that the predicate -( , , ) implies the predicate ℎ ( , , ) for all ∈ .In this definition, we require that there exists that is bigger than in all of the components ∈ .The definition of ℎ ( , , ) required to be bigger than only in the component .Hence, the algorithm can advance in all of the components in in parallel.Secondly, we require that we either reach the top of the lattice or find a global state that satisfies the predicate in at most polylogarithmic number of parallel advancements.Note the requirements on the algorithm A: We require it to be of polylogarithmic depth complexity so that we can detect the predicate in NC.
Any equilevel predicate with independently helpful property can be detected in NC by using the Algorithm Equilevel-Independence. T 5.2.Let be any equilevel predicate that satisfies an independently helpful property with an NC algorithm A. Then, can be detected in NC.

P
. Algorithm Equilevel-Independence starts with the least element in the lattice L. In each step of the while loop, it makes one call of independently helpful and advances on all indices ∈ with -( , , ).If there can be at most polylogarithmic number of advancements, then the algorithm will detect in NC.
Example 1: For the problem of minimum-spanning tree, any set of edges that do not form a cycle with the currently chosen edges is independently helpful.Observe that there may be multiple sets of independently helpful states.We only require the algorithm to return any such set.How do we find an independently helpful set in parallel?At every stage in the algorithm, there is a set of connected components.Each connected component chooses a single outgoing edge such that the edges chosen do not form any cycle.This set of edges can be added in parallel to reach the next stage of the algorithm.The number of connected components decreases by at least a factor of two after every such step.Hence, we would need to make at most polylogarithmic advancements.This leads us to Borůvka's parallel algorithm for the minimum spanning tree [22].

SOLITARY PREDICATES
A solitary predicate is one which is either false on all the elements of the lattice, or is true on a single element in the lattice.Definition 6.1 (Solitary Predicate).A Boolean predicate is solitary with respect to a lattice L iff The above definition states that if the predicate is true for two elements and in the lattice, then must be equal to .This definition also includes the empty predicate that is not true in any element of the lattice.
Solitary predicates are closely related to the problem of Unique SAT.Unique SAT (USAT) [23] asks for the satisfiability of a Boolean expression given the promise that it has either a single satisfying assignment or none.Let 1 , 2 , . . ., be Boolean variables.Let be a Boolean expression on these variables.The USAT problem requires the algorithm to return 1, if the Boolean expression has a unique satisfying assignment, 0, if the Boolean expression is not satisfiable and either 0 or 1, if it has multiple satisfying assignments.Valiant and Vazirani [23] have shown the following result.T 6.2.(Valiant-Vazirani [23]) If there exists a randomized polynomial-time algorithm for solving instances of SAT with at most one satisfying assignment, then NP=RP.
As a direct application, we get the following result by using the construction in [24] as shown below.T 6.3.Given any finite distributive lattice L generated from a poset , and a solitary predicate , there does not exist a randomized polynomial time algorithm to detect unless NP=RP.

P
. Suppose, if possible, there exists a randomized polynomial time algorithm A to detect a solitary predicate.Given any instance of USAT on variables 1 , 2 , . . ., , we construct a poset with events on processes, 1 , 2 , . . ., with one event per process.Process hosts the variable which is initially set to false.When the event is executed, the variable is set to true.The distributive lattice generated from this poset has 2 elements -one for every truth assignment.If the given instance of USAT has zero satisfying assignments, then A is guaranteed to return .If the given instance of USAT has exactly one satisfying assignment, then A is guaranteed to return with a satisfying assignment.Otherwise, we do not care what A returns.Therefore, any randomized polynomial time algorithm to detect a solitary predicate can be used to solve USAT in polynomial time.

SOLITARY PREDICATES WITH EFFICIENT ADVANCEMENT PROPERTY
Although detecting a general solitary predicate is hard, we can detect the predicate , whenever it satisfies the efficient advancement property [2].The efficient advancement property requires an efficient algorithm A such that whenever the predicate is false on an element ∈ , the algorithm returns an index such that the predicate is false for all ≥ such that [ ] equals [ ].
Definition 7.1 (Efficient Advancement Property [2]).A Boolean predicate has the efficient advancement property with the polytime algorithm A with respect to a finite distributive lattice L generated from a poset if where ( , , ) is defined as The above definition states that whenever is false in , the algorithm A ( ) returns a set of indices such that any global state greater than that matches on any returned index also has false.We will restrict ourselves to online algorithms, i.e., the algorithm A will only have access to those global states preceding .Any problem that can be modeled using a solitary predicate with the efficient advancement property can be solved in polynomial time.We restate the result from [2] in terms of solitary predicates.

T 7.2. [2]
Let be a solitary predicate with the efficient advancement property on a distributive lattice L. Then can be detected in polynomial time.
It is easy to develop a parallel algorithm to detect a solitary predicate with the efficient advancement property.Now consider lattice-linear predicates that are true on multiple elements in the lattice.Let be any lattice-linear predicate.We know that is closed under the meet operation of the lattice [2].Suppose that becomes true in the lattice and the least element that satisfies is .We derive another predicate ′ from that holds only for the element whenever it exists.Thus, ′ holds for iff ( ) and for all elements , if ( ), then ≤ .Therefore, ′ ( ) is false for all other elements besides .
T 7.3.Let be any lattice-linear predicate.Let ′ ( ) be defined as follows: Then, ′ is a solitary predicate.

P
. First, consider the case when does not hold for any element in the lattice.This implies that ′ also does not hold for any element in the lattice and is, therefore, solitary.Now, suppose that is true in the lattice.Since is an LLP predicate, it is closed under meets.Therefore, there is the smallest element, , in the lattice such that ( ) holds.It is readily verified that ′ ( ) holds iff = .
Thus, all the instances of lattice-linear predicates provide us examples of solitary predicates when we focus on the least element.
Example 1: Man-Optimal Stable Marriage.In this problem, we are given as input men and women.We are also given a list of men preferences as where [ ] [ ] denotes ℎ top choice of man .The women preferences are more convenient to express as a array where [ ] [ ] is the rank of man by woman .A matching between man and woman is stable if there is no blocking pair, i.e., a pair of woman and man such that they are not matched and prefer each other to their spouses.The underlying lattice for this example is the set of all dimensional vectors of 1.. .We let [ ] be the choice number that man has proposed to.Initially, [ ] is 1 for all men.
If we now focus on the man-optimal stable marriage, then the predicate "the assignment is a man-optimal stable marriage" is a solitary predicate.The predicate for the stable marriage is given by, where ( , ) is defined as The predicate says that a marriage given by the vector is stable if none of its index is forbidden.The index is forbidden if the woman corresponding to man 's preference in [ ] is also equal to the preference of man in , or a global state before , and the woman prefers to .
We now define the predicate for the man-optimal stable marriage, ( ) as By definition, it is clear that is a solitary predicate.Given a lattice L, we can search for the element satisfying by searching for .We can use Algorithm Solitary for this purpose.
Example 2: Housing Allocation Problem.As another example of a solitary predicate, consider the housing allocation problem with agents and houses proposed by Shapley and Scarf [25].The housing market is a matching problem with one-sided preferences.Each agent initially owns a house ℎ for ∈ {1, } and has a completely ranked list of houses.The list of preferences of the agents is given by [ ] [ ] which specifies the ℎ preference of the agent .The goal is to come up with an optimal house allocation such that each agent has a house and no subset of agents can improve the satisfaction of agents in this subset by exchanging houses within the subset.
It is well-known that the housing market has a unique solution, called the core of the game.We model the housing market problem as that of predicate detection in a computation [7].Each agent proposes to houses in the decreasing order of preferences.These proposals are considered as events executed by processes representing the agents.Thus, we have events per process.The global state corresponds to the number of proposals made by each of the agents.Let [ ] be the number of proposals made by the agent .We assume that in the initial state, every agent has made his first proposal.Thus, the initial global state = [1, 1, .., 1].We extend the notation of indexing to subsets ⊆ [ ] such that [ ] corresponds to the subvector given by indices in .A global state satisfies ℎ if every agent proposes a different house.We generalize ℎ to refer to a subset of agents rather than the entire set.Let ⊆ [ ].Then, ℎ ( , ) iff the houses proposed by agents in is a permutation of indices in .Intuitively, if ℎ ( , ) holds, then all agents in can exchange houses within the subset .For all , there always exists a nonempty such that ℎ ( , ).Let ℎ ( ) be defined as is a matching and It is easy to show that ℎ ( ) is a solitary predicate with an efficient advancement property.Hence, the housing allocation problem also can be modeled and solved using the solitary predicates with the efficient advancement property.An agent is forbidden in the global state if the agent wishes a house that is part of the submatching in .
We briefly discuss detection of predicates when the search starts from the top of the lattice in addition to the bottom of the lattice.Many predicates, such as and conjunctive predicates, satisfy not only the efficient advancement property but also its dual.Equivalently, the set of elements satisfying these predicates are closed not only for the meet operation but also for the join operation.If we are okay with returning either of the elements as our final answer, then searching for any of the element in parallel can speed up the algorithm by a factor of the height of the lattice.
The dual of the efficient advancement property can formally be defined as [17] follows.

Definition 7.4 (dual of Efficient Advancement Property).
A Boolean predicate has the dual of efficient advancement property with the polytime algorithm A with respect to a finite distributive lattice L generated from a poset if where -( , , ) is defined as The above definition states that whenever is false in , the algorithm A ( ) returns an index such that any global state less than that matches on that index also has false.When the efficient advancement as well as its dual are true, one can search for the satisfying element starting from both the bottom and the top of the lattice as shown in Algorithm Solitary2.ALGORITHM Solitary2: A Parallel Algorithm for detecting Predicates with efficient advancement property and its dual.
var : element of L initially ⊥ (the bottom element of L); : element of L initially ⊤ (the top element of L); while ¬ ( ) and ¬ ( ) do forall : forbidden( , ) do in parallel if cannot be advanced on then return false; else advance on ; forall : dual-forbidden( , ) do in parallel if cannot be retreated on then return false; else retreat on ; endwhile; if ( ) then return else return ; // an optimal solution Applying the idea to the stable marriage problem, one can search for the stable marriage starting from the top choices for all men (the ⊥ element) of the lattice in parallel with the bottom choices for all men (the ⊤) element of the lattice.This algorithm will traverse the distance in a lattice given by the minimum of the distance of a stable marriage from the top or the bottom.Hence, depending upon the distance of man-optimal and man-pessimal stable marriage, it will return the stable marriage that is closer to the bottom or the top of the lattice.
Similarly, consider the problem of detecting conjunctive predicates which are also closed under the join operation of the lattice.By using the Algorithm Solitary2, we again get an algorithm to detect a conjunctive predicate that will traverse the lattice given by the minimum of the distance of a satisfying global state from the top or the bottom of the lattice.In the above analysis, we are ignoring the factor of 2 penalty that we incur because we run the algorithm both from the bottom and the top of the lattice.

SOLITARY PREDICATES WITH
NC ADVANCEMENT PROPERTIES Consider the problem of the minimum spanning tree in an undirected graph when all edges have unique weights.If the graph is connected, then there is a unique minimum spanning tree.To find this spanning tree, we consider the Boolean lattice formed from all edges.We assume that edges are given to us in the increasing order.We define the predicate on a subset of edges as true whenever forms the minimum spanning tree.We use the binary representation of : The variable [ ] equals 1 iff the ℎ edge is part of the unique minimum spanning tree.The predicate is solitary because either there is a unique minimum spanning tree or no spanning tree in such a weighted undirected graph.Furthermore, the predicate satisfies antimonotone advancement property.If ℎ edge is not part of the minimum spanning tree, then [ ] is not forbidden and and it will stay not forbidden even when other edges are included as part of .
We now show that any solitary predicate with Antimonotone advancement property on a poset with height polylogarithmic in can be detected in NC.
T 8.2.Let be any poset and be an antimonotone advancement predicate that can be checked in NC.If the height of the poset is (log ( )), for any constant , then the Algorithm Solitary is in NC.

P
. The forall statement in the algorithm Solitary can run at most (log ( )) time because if a process is forbidden then it must advance.All processes can advance at most (log ( )) times because the height of the poset is (log ( )).We are exploiting the fact that all processes which can advance do so in parallel.If a process is not forbidden, then it stays not forbidden due to the antimonotonicity property.Since checking for the property is in NC, the entire algorithm is in NC.
When we apply this algorithm to the minimum spanning tree problem, we get the NC algorithm Parallel-MST.The algorithm assumes that edges of the graph are presented in the sorted order similar to Kruskal's algorithm [26] In this example, the predicate on a set of edges is defined to be " forms the minimum spanning tree in the graph." Since all edge weights are unique, is a solitary predicate.In the Boolean lattice of all edges, an edge from to is forbidden if there is no path from to using edges with weight lower than the weight of the edge ( , ).Such an edge is always included as part of the minimum spanning tree.Furthermore, the predicate satisfies antimonotone advancement property.If an edge ( , ) is not forbidden, then it continues to stay not forbidden.Finally, the poset corresponding to a Boolean lattice has (1) height, and therefore by Theorem 8.2, we have an NC algorithm.Many NC algorithms are already known for the minimum spanning tree problem.Our goal was to show how the notion of solitary predicates in a lattice with (1) height and antimonotone advancement leads to an NC algorithm.
We now discuss another property of predicate that allows us to detect it in NC: efficient rejection.A solitary predicate that has the efficient rejection property can be detected in NC even when the height of the poset is not (log ( )).We show that the problem of finding the least global state that satisfies the conjunctive predicate and the problem of reachability in a directed graph satisfy the efficient rejection property.
As a concrete example, consider conjunctive predicates.We are searching for the least global state that satisfies Since we are only interested in the least global state, we can view it as a solitary predicate with appropriately refined as We start with the notion of a rejection relation.A state rejects a state if whenever all local states less than or equal to are forbidden, then all states less than or equal to are also forbidden.If we know the initial forbidden states and the rejection relation, we can compute the states on each process that are forbidden in the initial state or become forbidden when the processes are advanced on the forbidden states.This is done by computing the reflexive transitive closure of the rejection relation.Then, the first local state that is not rejected on every process gives us the least global state that satisfies the predicate.Formally, Definition 8.3 (Rejection Relation).Given any distributive lattice L derived from a poset with chains, 1 , . . ., and a predicate , for ∈ and ∈ we define, where is the reflexive order associated with the chain .
We say that a lattice-linear predicate satisfies efficient rejection if Definition 8.4 (Lattice-linear Predicate with Efficient Rejection).A lattice linear Boolean predicate satisfies efficient rejection with respect to a lattice L if there exists a rejection relation such that ( , ) can be computed in NC.
We observe here that computing the rejection relation requires as input the entire poset.Hence, the algorithm derived using efficient rejection is offline.For example, the algorithm for the conjunctive predicate derived using the rejection relation requires the entire poset and is offline.This algorithm is in contrast to the algorithm derived using efficient advancement property [6] which is online.
Algorithm LLPwithRejection detects a lattice-linear predicate with efficient rejection in NC.This algorithm is similar to the one proposed in [27] where the algorithm is proposed for conjunctive predicates and we refer the reader to [27] for details.We show that the algorithm is applicable to any lattice-linear predicate with efficient rejection.Thus, it is also applicable to finding the shortest path in a directed graph.We now show how lattice-linear predicates with efficient rejection can be applied to graph reachability.Suppose that we are given a fixed vertex 0 in a directed graph ( , ).Our goal is to find all the vertices that are reachable from 0 .We can use simple BFS to find all reachable vertices.Let [ ] be a binary variable such that [ ] is 1 if is reachable from 0 .Then, the following predicate is true on a binary vector that corresponds to the reachable vertices.

≡ ( [0] = 1) ∧ (∀( , ) ∈ : [ ] ≥ [ ])
The predicate is a lattice-linear predicate and can be employed to find all the reachable vertices.However, this procedure takes time proportional to the diameter of the graph.
By computing the reflexive transitive closure of the binary graph, we can find all reachable vertices in polylogarithmic time.Let be the graph in the matrix form.We compute , the reflexive transitive closure of the matrix , such that [ , ] equals 1 iff the vertex is reachable from the vertex .We define as For this problem, our poset has 2 processes and each process has just one event.The process ( , ) is forbidden if [ , ] equals 0 and [ , ] equals 1 or for some , [ , ] and [ , ] are both 1.

CONCLUSIONS AND OPEN PROBLEMS
We have defined a class of predicates called Equilevel predicates on finite distributive lattices.We have also identified subclasses of equilevel predicates that can be detected efficiently in parallel.There are many problems that are open in this area.Are there other subclasses of equilevel predicates or solitary predicates that admit efficient detection?What other problems can be modeled as equilevel predicate detection and do they introduce any specific algorithmic challenges?Are there techniques that can be used to find approximate solutions of the equilevel predicate detection problem?
On the other end of the spectrum, what properties preclude efficient parallel detection of equilevel predicates?In this work, we made general statements about the NP-hardness of detecting equilevel predicates.However, similar to how we identified properties enabling parallel detection of these predicates, it would be insightful to identify properties that certify P-hardness (see [28]) of the detection of corresponding subclasses of equilevel predicates which, in turn, would rule out the possibility of an efficient parallel solution unless NC=P.
Hasse diagram of the vertex powerset, ordered by inclusion.

Figure 2 :
Figure 2: Above is the example of an equilevel predicate in the context of the minimum vertex cover problem.Examine the given graph (top).The minimum vertex covers are of cardinality 2, given by { , } and { , }.This gives an equilevel predicate over the inclusion order (bottom) such that the satisfying elements (shaded) are all on level 2.
Various Classes of Predicates.Equilevel predicates are the ones that are true on elements of a lattice at a single level.Solitary predicates are the ones that are true on a single element in the lattice.
This allows us to use a sequential procedure, given in Algorithm Equilevel, to advance on helpful indices towards a satisfying global state if one exists.The Algorithm Equilevel works as follows.It starts with the global state initialized to the least global state corresponding to the bottom element of the lattice L. If the predicate is true at the initial global state, then we are done and we can return .If not, we first check whether corresponds to the top element of the lattice.If is the top element of the lattice, we can safely return that there is no element in L that satisfies .Otherwise, we advance on the index where ℎ ( , , ) holds.Let be any equilevel predicate that satisfies a helpful property with a polynomial time algorithm A. Then, can be detected online in polynomial time.
ALGORITHM Equilevel: A Sequential Algorithm to find a state satisfying function GetSatisfying( : predicate, L: Lattice) var : array[1 . . .] of int initially ∀ : [ ] = 0; while ¬ ( )do if ( is the top element of L) then return null; else [ ] := [ ] + 1 where ℎ ( , , ); (1)now define a special case of the efficient advancement property.A predicate has the NC advancement property, if(1)there exists an NC algorithm to detect whether an index is forbidden and (2) starting from the initial state and always advancing all the forbidden indices the algorithm either reaches a satisfying state or the top element of the lattice in the polylogarithmic number of steps in the size of the input.Clearly, any predicate that has the efficient NC advancement property can be detected in parallel in NC time with the Algorithm Solitary.We now give several examples guaranteeing the NC advancement property.We say that a predicate has an antimonotone advancement property if once an index is not forbidden in , it stays not forbidden for all ≥ such that [ ] equals [ ]. Formally,