I Introduction
The growth of user engagement and functionality in crowdsourcing platforms has made computationally challenging tasks unprecedentedly convenient. The subject of our study is one such task—crowdsourcing Paretooptimal object finding. Consider a set of objects and a set of criteria for comparing the objects. An object x is Paretooptimal if and only if x is not dominated by any other object, i.e., y such that yx. An object y dominates x (denoted yx) if and only if x is not better than y by any criterion and y is better than x by at least one criterion, i.e., y and . If x and y do not dominate each other (i.e., xy and yx), we denote it by xy. The preference (betterthan) relation (also denoted ) for each is a binary relation subsumed by , in which a tuple (also denoted xy) is interpreted as “x is better than (preferred over) y with regard to criterion ”. Hence, if (also denoted xy), x is not better than y by criterion . We say x and y are indifferent regarding (denoted xy), if , i.e., “x and y are equally good or incomparable with regard to .” We consider the setting where each is a strict partial order as opposed to a bucket order [1] or a total order, i.e., is irreflexive () and transitive (), which together imply asymmetry ().

Paretooptimal object finding lends itself to applications in several areas, including public opinion collection, group decision making, and information exploration, exemplified by the following motivating examples.
Example 1 (Collecting Public Opinion and Group Decision Making).
Consider a set of movies and a set of criteria story, music, acting (denoted by , , in the ensuing discussion). Fig.0(a) shows the individual preference relations (i.e., strict partial orders), one per criterion. Each strict partial order is graphically represented as a directed acyclic graph (DAG), more specifically a Hasse diagram. The existence of a simple path from x to y in the DAG means x is better than (preferred to) y by the corresponding criterion. For example, (ae), i.e., a is better than e by music. and ; hence bd. The partial orders define the dominance relation between objects. For instance, movie c dominates d (cd), because c is preferred than d on story and music and they are indifferent on acting, i.e., cd, cd, and cd; a and b do not dominate each other (ab), since ba, ab and ba. Based on the three partial orders, movie b is the only Paretooptimal object, since no other objects dominate it and every other object is dominated by some object.
Note that tasks such as the above one may be used in both understanding the public’s preference (i.e., the preference relations are collected from a large, anonymous crowd) and making decisions for a target group (i.e., the preference relations are from a small group of people). ∎
Example 2 (Information Exploration).
Consider a photography enthusiast, Amy, who is drown in a large number of photos she has taken and wants to select a subset of the better ones. She resorts to crowdsourcing for the task, as it has been exploited by many for similar tasks such as photo tagging, location/face identification, sorting photos by (guessed) date, and so on. Particularly, she would like to choose Paretooptimal photos with regard to color, sharpness and landscape. ∎
By definition, the crux of finding Paretooptimal objects lies in obtaining the preference relations, i.e., the strict partial orders on individual criteria. Through crowdsourcing, the preference relations are derived by aggregating the crowd’s responses to pairwise comparison tasks. Each such comparison between objects x and y by criterion is a question, denoted xy, which has three possible outcomes—xy, yx, and xy, based on the crowd’s answers. An example is as follows.
Example 3 (Deriving Preference Relations from Pairwise Comparisons by the Crowd).
Fig.0(b) shows the hypothetical results of all pairwise comparisons between the movies in Example 1, by criterion story. The outcomes of all comparisons form the crowd’s preference relation on story (the leftmost DAG in Fig.0(a)). Fig.2 is the screenshot of a question form designed for one such comparison. A crowdsourcer, when facing this question, would make a choice among the three possible answers or skip a question if they do not have enough confidence or knowledge to answer it. Fig.0(b) shows how many crowdsourcers have selected each answer. For instance, for question af, three people preferred movie a, one person preferred , and one person is indifferent. By aggregating these answers, it is derived that a is better than f with regard to story, since of the crowdsourcers who responded to the question chose this answer. For question bc, the result is bc, since neither bc nor bc received enough votes. (Assuming a threshold , i.e., either bc or bc should have at least of votes, in order to not declare bc.) ∎
To the best of our knowledge, this paper is the first work on crowdsourcing Paretooptimal object finding. The definition of Paretooptimal objects follows the concept of Pareto composition of preference relations in [2]. It also resembles the definition of skyline objects on totallyordered attribute domains (pioneered by [3]) and partiallyordered domains [4, 5, 6, 7]. However, except for [8], previous studies on preference and skyline queries do not use the crowd; they focus on query processing on existing data. On the contrary, we examine how to ask the crowd as few questions as possible in obtaining sufficient data for determining Paretooptimal objects. Furthermore, our work differs from preference and skyline queries (including [8]) in several radical ways:

The preference relation for a criterion is not governed by explicit scores or values on object attributes (e.g., sizes of houses, prices of hotels), while preference and skyline queries on both totally and partiallyordered domains assumed explicit attribute representation. For many comparison criteria, it is difficult to model objects by explicit attributes, not to mention asking people to provide such values or scores; people’s preferences are rather based on complex, subtle personal perceptions, as demonstrated in Examples 1 and 2.

Due to the above reason, we request crowdsourcers to perform pairwise comparisons instead of directly providing attribute values or scores. On the contrary, [8] uses the crowd to obtain missing attribute values. Pairwise comparison is extensively studied in social choice and welfare, preferences, and voting. It is known that people are more comfortable and confident with comparing objects than directly scoring them, since it is easier, faster, and less errorprone [9].

The crowd’s preference relations are modeled as strict partial orders, as opposed to bucket orders or full orders. This is not only a direct effect of using pairwise comparisons instead of numeric scores or explicit attribute values, but also a reflection of the psychological nature of human’s preferences [10, 2], since it is not always natural to enforce a total or bucket order. Most studies on skyline queries assume total/bucket orders, except for [4, 5, 6, 7] which consider partial orders.
Our objective is to find all Paretooptimal objects with as few questions as possible. A bruteforce approach will obtain the complete preference relations via pairwise comparisons on all object pairs by every criterion. However, without such exhaustive comparisons, the incomplete knowledge collected from a small set of questions may suffice in discerning all Paretooptimal objects. Toward this end, it may appear that we can take advantage of the transitivity of object dominance—a costsaving property often exploited in skyline query algorithms (e.g., [3]) to exclude dominated objects from participating in any future comparison once they are detected. But, we shall prove that object dominance in our case is not transitive (Property 1), due to the lack of explicit attribute representation. Hence, the aforementioned costsaving technique is inapplicable.
Aiming at Paretooptimal object finding by a short sequence of questions, we introduce a general, iterative algorithm framework (Sec.III). Each iteration goes through four steps—question selection, outcome derivation, contradiction resolution, and termination test. In the th iteration, a question is selected and its outcome is determined based on crowdsourcers’ answers. On unusual occasions, if the outcome presents a contradiction to the obtained outcomes of other questions, it is changed to the closest outcome such that the contradiction is resolved. Based on the transitive closure of the outcomes to the questions so far, the objects are partitioned into three sets— (objects that must be Paretooptimal), (objects that must be nonPareto optimal), and (objects whose Paretooptimality cannot be fully discerned by the incomplete knowledge so far). When becomes empty, contains all Paretooptimal objects and the algorithm terminates. The question sequence so far is thus a terminal sequence.
Task  Question type  Multiple attributes  Order among objects (on each attribute)  Explicit attribute representation  
[11]  full ranking  pairwise comparison  no  bucket/total order  no 
[12]  topk ranking  rank subsets of objects  no  bucket/total order  no 
[13]  topk ranking and grouping  pairwise comparison  no  bucket/total order  no 
[8]  skyline queries  missing value inquiry  yes  bucket/total order  yes 
This work  Paretooptimal object finding  pairwise comparison  yes  strict partial order  no 
There are a vast number of terminal sequences. Our goal is to find one that is as short as possible. We observe that, for a nonPareto optimal object, knowing that it is dominated by at least one object is sufficient, and we do not need to find all its dominating objects. It follows that we do not really care about the dominance relation between nonPareto optimal objects and we can skip their comparisons. Hence, the overriding principle of our question selection strategy is to identify nonPareto optimal objects as early as possible. Guided by this principle, the framework only chooses from candidate questions which must satisfy three conditions (Sec.IIIA). This design is sufficient, as we prove that an empty candidate question set implies a terminal sequence, and vice versa (Proporty 2). The design is also efficient, as we further prove that, if a question sequence contains noncandidate questions, there exists a shorter or equally long sequence with only candidate questions that produces the same , matching the principle of eagerly finding nonPareto optimal objects (Theorem 1). Moreover, by the aforementioned principle, the framework selects in every iteration such a candidate question xy that x is more likely to be dominated by y. The selection is steered by two ideas—macroordering and microordering. By using different microordering heuristics, the framework is instantiated into several algorithms with varying power in pruning questions (Sec.IV). We also derive a lower bound on the number of questions required for finding all Paretooptimal objects (Theorem 2).
In summary, this paper makes the following contributions:

This is the first work on crowdsourcing Paretooptimal object finding. Prior studies on crowdsourcing skyline queries [8] assumes explicit attribute representation and uses crowd to obtain missing attribute values. We define preference relations purely based on pairwise comparisons and we aim to find all Paretooptimal objects by as few comparisons as possible.

We design macroordering and microordering heuristics for finding a short terminal question sequence. Based on the heuristics, the generic framework is instantiated into several algorithms (RandomQ, RandomP, FRQ) with varying efficiency. We also derive a nontrivial lower bound on the number of required pairwise comparison questions. (Sec.IV)

We carried out experiments by simulations to compare the amount of comparisons required by different instantiations of the framework under varying problem sizes. We also investigated two case studies by using human judges and real crowdsourcing marketplace. The results demonstrate the effectiveness of selecting only candidate questions, macroordering, and microordering. When these ideas are stacked together, they use orders of magnitude less comparisons than a bruteforce approach. The results also reveal that FRQ is nearly optimal and the lower bound is practically tight, since FRQ gets very close to the lower bound. (Sec.V)
Ii Related Work
This is the first work on crowdsourcing Paretooptimal object finding. There are several recent studies on using crowdsourcing to rank objects and answer groupby, topk and skyline queries. CrowdBT [11] ranks objects by crowdsourcing pairwise object comparisons. Polychronopoulos et al. [12] find topk items in an itemset by asking human workers to rank small subsets of items. Davidson et al. [13] evaluate topk and groupby queries by asking the crowd to answer type questions (whether two objects belong to the same group) and value questions (ordering two objects). Lofi et al. [8] answer skyline queries over incomplete data by asking the crowd to provide missing attribute values. Table I summarizes the similarities and differences between these studies and our work. The studies on full and topk ranking [11, 12, 13] do not consider multiple attributes in modeling objects. On the contrary, the concepts of skyline [8] and Paretooptimal objects (this paper) are defined in a space of multiple attributes. [8] assumes explicit attribute representation. Therefore, they resort to the crowd for completing missing values, while other studies including our work request the crowd to compare objects. Our work considers strict partial orders among objects on individual attributes. Differently, other studies assume a bucket/total order [11, 12, 13] or multiple bucket/total orders on individual attributes [8].
Besides [11], there were multiple studies on ranking objects by pairwise comparisons, which date back to decades ago as aggregating the preferences of multiple agents has always been a fundamental problem in social choice and welfare [14]. The more recent studies can be categorized into three types: 1) Approaches such as [15, 16, 17] predict users’ object ranking by completing a userobject scoring matrix. Their predications take into account users’ similarities in pairwise comparisons, resembling collaborative filtering [18]. They thus do not consider explicit attribute representation for objects. 2) Approaches such as [19, 20, 21] infer queryspecific (instead of userspecific) ranked results to web search queries. Following the paradigm of learningtorank [22], they rank a query’s result documents according to pairwise result comparisons of other queries. The documents are modeled by explicit ranking features. 3) Approaches such as [23, 24, 25, 26, 27] are similar to [11] as they use pairwise comparisons to infer a single ranked list that is neither userspecific nor queryspecific. Among them, [24] is special in that it also applies learningtorank and requires explicit feature representation. Different from our work, none of these studies is about Paretooptimal objects, since they all assume a bucket/total order among objects; those using learningtorank require explicit feature representation, while the rest do not consider multiple attributes. Moreover, except [24, 25, 26], they all assume comparison results are already obtained before their algorithms kick in. In contrast, we aim at minimizing the pairwise comparison questions to ask in finding Paretooptimal objects.
Iii General Framework
By the definition of Paretooptimal objects, the key to finding such objects is to obtain the preference relations, i.e., the strict partial orders on individual criteria. Toward this end, the most basic operation is to perform pairwise comparison—given a pair of objects x and y and a criterion , determine whether one is better than the other (i.e., or ) or they are indifferent (i.e., ).
The problem of crowdsourcing Paretooptimal object finding is thus essentially crowdsourcing pairwise comparisons. Each comparison task between x and y by criterion is presented to the crowd as a question (denoted xy). The outcome to the question (denoted ) is aggregated from the crowd’s answers. Given a set of questions, the outcomes thus contain an (incomplete) knowledge of the crowd’s preference relations for various criteria. Fig.2 illustrates the screenshot of one such question (comparing two movies by story) used in our empirical evaluation. We note that there are other viable designs of question, e.g., only allowing the first two choices (xy and yx). Our work is agnostic to the specific question design.
Given objects and criteria, a bruteforce approach will perform pairwise comparisons on all object pairs by every criterion, which leads to comparisons. The corresponding question outcomes amount to the complete underlying preference relations. The quadratic nature of the bruteforce approach renders it wasteful. The bad news is that, in the worst case, we cannot do better than it. To understand this, consider the scenario where all objects are indifferent by every criterion. If any comparison xy is skipped, we cannot determine if x and y are indifferent or if one dominates another.
In practice, though, the outlook is much brighter. Since we look for only Paretooptimal objects, it is an overkill to obtain the complete preference relations. Specifically, for a Paretooptimal object, knowing that it is not dominated by any object is sufficient, and we do not need to find all the objects dominated by it; for a nonPareto optimal object, knowing that it is dominated by at least one object is sufficient, and we do not need to find all its dominating objects. Hence, without exhausting all possible comparisons, the incomplete knowledge on preference relations collected from a set of questions may suffice in fully discerning all Paretooptimal objects.
Our objective is to find all Paretooptimal objects with as few questions as possible. By pursuing this goal, we are applying a very simple cost model—the cost of a solution only depends on its number of questions. Although the cost of a task in a crowdsourcing environment may depend on monetary cost, latency and other factors, the number of questions is a generic, platformindependent cost measure and arguably proportionally correlates with the real cost. Therefore, we assume a sequential execution model which asks the crowd an ordered sequence of questions —it only asks after is obtained. Thereby, we do not consider asking multiple questions concurrently. Furthermore, in discussion of our approach, the focus shall be on how to find a short question sequence instead of the algorithms’ complexity.
To find a short sequence, we design a general algorithm framework, as displayed in Fig.3. Alg.1 shows the framework’s pseudocode. Its execution is iterative. Each iteration goes through four steps—question selection, outcome derivation, contradiction resolution, and termination test. In the th iteration, a question is selected and presented to the crowd. The question outcome is derived from the crowd’s aggregated answers. On unusual occasions, if the outcome presents a contradiction to the obtained outcomes of other questions so far, it is changed to the closest outcome to resolve contradiction. By computing , the transitive closure of —the obtained outcomes to questions so far , the outcomes to certain questions are derived and such questions will never be asked. Based on , if every object is determined to be either Paretooptimal or nonPareto optimal without uncertainty, the algorithm terminates.
Below, we discuss outcome derivation and termination test. Sec.IIIA examines the framework’s key step—question selection, and Sec.IIIB discusses contradiction resolution.
Outcome derivation
Given a question xy, its outcome (xy) must be aggregated from multiple crowdsourcers, in order to reach a reliable result with confidence. Particularly, one of three mutuallyexclusive outcomes is determined based on crowdsourcers’ answers to the question:
(1) 
where is such a predefined threshold that , is the number of crowdsourcers (out of ) preferring x over y on criterion , and is the number of crowdsourcers preferring y over x on . Fig.0(b) shows the outcomes of all questions according to Equation (1) for comparing movies by story using and . Other conceivable definitions may be used in determining the outcome of xy. For example, the outcome may be defined as the choice (out of the three possible choices) that receives the most votes from the crowd. The ensuing discussion is agnostic to the specific definition.
The current framework does not consider different levels of confidence on question outcomes. The confidence on the outcome of a question may be represented as a probability value based on the distribution of crowdsourcers’ responses. An interesting direction for future work is to find Paretooptimal objects in probabilistic sense. The confidence may also reflect the crowdsourcers’ quality and credibility
[28].Termination test
In each iteration, Alg.1 partitions the objects into three sets by their Paretooptimality based on the transitive closure of question outcomes so far. If every object’s Paretooptimality has been determined without uncertainty, the algorithm terminates. Details are as follows.
Definition 1 (Transitive Closure of Outcomes).
Given a set of questions , the transitive closure of their outcomes is {xy xy } {xy xy w,w,…,w : wx, wy : w w }. ∎
In essence, the transitive closure dictates xz without asking the question xz, if the existing outcomes (and recursively the transitive closure ) contains both xy and yz. Based on , the objects can be partitioned into three sets:
xy xy ;
yx xy yx ;
.
contains
objects that must be Paretooptimal, contains objects that cannot possibly be Paretooptimal, and contains objects for which the incomplete knowledge is insufficient for discerning their Paretooptimality. The objects in may turn out to be Paretooptimal after more comparison questions. If the set for a question sequence is empty, contains all Paretooptimal objects and the algorithm terminates. We call such a a terminal sequence, defined below.
Definition 2 (Terminal Sequence).
A question sequence is a terminal sequence if and only if, based on , .
Iiia Question Selection
Given objects and criteria , there can be a huge number of terminal sequences. Our goal is to find a sequence as short as possible. As Fig.3 and Alg.1 show, the framework is an iterative procedure of object partitioning based on question outcomes. It can also be viewed as the process of moving objects from to and . Once an object is moved to or , it cannot be moved again. With regard to this process, we make two important observations, as follows.

In order to declare an object x not Paretooptimal, it is sufficient to just know x is dominated by another object. It immediately follows that we do not really care about the dominance relationship between objects in and thus can skip the comparisons between such objects. Once we know x is dominated by another object, it cannot be Paretooptimal and is immediately moved to . Quickly moving objects into can allow us skipping many comparisons between objects in .

In order to declare an object x Paretooptimal, it is necessary to know that no object can dominate x. This means we may need to compare x with all other objects including non Paretooptimal objects. As an extreme example, it is possible for x to be dominated by only a nonPareto optimal object y but not by any other object (not even the objects dominating y). This is because object dominance based on preference relations is intransitive, which is formally stated in Property 1.
Property 1 (Intransitivity of Object Dominance).
Object dominance based on the preference relations over a set of criteria is not transitive. Specifically, if xy and yz, it is not necessarily true that xz. In other words, it is possible that xz or even zx. ∎
We show the intransitivity of object dominance by an example. Consider objects , criteria , and the preference relations in Fig.4. Three dominance relationships violate transitivity: (i) xy (based on xy, xy, xy), (ii) yz (based on yz, yz, yz), and (iii) zx (based on zx, zx, zx). As another example, in Fig.0(a), bc (since bc, bc, bc, where story, music, acting) and ca (since ca, ca, ca), but ab (since ba, ab, ba) where transitivity does not hold.
Differently, transitivity of object dominance holds in skyline analysis [3]. The contradiction is due to the lack of explicit attribute representation—in our case two objects are considered equally good on a criterion if they are indifferent, while in skyline analysis they are equally good regarding an attribute if they bear identical values. Skyline query algorithms exploit the transitivity of object dominance to reduce execution cost, because an object can be immediately excluded from further comparison once it is found dominated by any other object. However, due to Property 1, we cannot leverage such pruning anymore.
Based on these observations, the overriding principle of our question selection strategy (shown in Alg.2) is to identify nonPareto optimal objects as early as possible. At every iteration of the framework (Alg.1), we choose to compare x and y by criterion (i.e., ask question xy) where xy belongs to candidate questions. Such candidate questions must satisfy three conditions (Definition 3). There can be many candidate questions. In choosing the next question, by the aforementioned principle, we select such xy that x is more likely to be dominated by y. More specifically, we design two ordering heuristics—macroordering and microordering. Given the three object partitions , and , the macroordering idea is simply that we choose x from (required by one of the conditions on candidate questions) and y from (if possible) or (otherwise). The reason is that it is less likely for an object in to dominate x. Microordering further orders all candidate questions satisfying the macroordering heuristic. In Sec.IV, we instantiate the framework into a variety of solutions with varying power in pruning questions, by using different microordering heuristics.
Definition 3 (Candidate Question).
Given , the set of asked questions so far, xy is a candidate question if and only if it satisfies the following conditions:

The outcome of xy is unknown yet, i.e., ;

x must belong to ;

Based on , the possibility of yx must not be ruled out yet, i.e., .
We denote the set of candidate questions by . Thus, . ∎
If no candidate question exists, the question sequence is a terminal sequence. The reverse statement is also true, i.e., upon a terminal sequence, there is no candidate question left. This is formalized in the following property.
Property 2.
if and only if .
Proof.
It is straightforward that , since an empty means no question can satisfy condition (ii). We prove by proving its equivalent contrapositive . Assume , i.e., contains at least one object x (condition (ii) satisfied). Since x does not belong to , there exists at least an object y that may turn out to dominate x (condition (iii) satisfied). Since x is not in , we cannot conclude yet that y dominates x. Hence, there must exist a criterion for which we do not know the outcome of xy yet, i.e., (condition (i) satisfied). The question would be a candidate question because it satisfies all three conditions. Hence . ∎
Questions violating the three conditions may also lead to terminal sequences. However, choosing only candidate questions matches our objective of quickly identifying nonPareto optimal objects. Below we justify the conditions.
Condition (i): This is straightforward. If or its transitive closure already contains the outcome of xy, we do not ask the same question again.
Condition (ii): This condition essentially dictates that at least one of the two objects in comparison is from . (If only one of them belongs to , we make it x.) Given a pair x and y, if neither is from , there are three scenarios—(1) x, (2) x or x, (3) x. Once we know an object is in or , its membership in such a set will never change. Hence, we are not interested in knowing the dominance relationship between objects from and only. In all these three scenarios, comparing x and y is only useful for indirectly determining (by transitive closure) the outcome of comparing other objects. Intuitively speaking, such indirect pruning is not as efficient as direct pruning.
Condition (iii): This condition requires that, when xy is chosen, we cannot rule out the possibility of y dominating x. Otherwise, if y cannot possibly dominate x, the outcome of xy cannot help prune x. Note that, in such a case, comparing x and y by may help prune y, if y still belongs to and x may dominate y. Such possibility is not neglected and is covered by a different representation of the same question—yx, i.e., swapping the positions of x and y in checking the three conditions. If it is determined x and y cannot dominate each other, then their further comparison is only useful for indirectly determining the outcome of comparing other objects. Due to the same reason explained for condition (ii), such indirect pruning is less efficient.
The following simple Property 3 helps to determine whether yx is possible: If x is better than y by any criterion, then we can already rule out the possibility of yx, without knowing the outcome of their comparison by every criterion. This allows us to skip further comparisons between them. Its correctness is straightforward based on the definition of object dominance.
Property 3 (NonDominance Property).
At any given moment, suppose the set of asked questions is
. Consider two objects x and y for which the comparison outcome is not known for every criterion, i.e., such that . It can be determined that yx if such that xy. ∎In justifying the three conditions in defining candidate questions, we intuitively explained that indirect pruning is less efficient—if it is known that x does not belong to or y cannot possibly dominate x, we will not ask question xy. We now justify this strategy theoretically and precisely. Consider a question sequence . We use , , to denote object partitions according to . For any question , the subsequence comprised of its preceding questions is denoted . If was not a candidate question when it was chosen (i.e., after was obtained), we say it is a noncandidate. The following Theorem 1 states that, if a question sequence contains noncandidate questions, we can replace it by a shorter or equally long sequence without noncandidate questions that produces the same set of dominated objects . Recall that the key to our framework is to recognize dominated objects and move them into as early as possible. Hence, the new sequence will likely lead to less cost when the algorithm terminates. Hence, it is a good idea to only select among candidate questions.
Theorem 1.
If contains noncandidate questions, there exists a question sequence without noncandidate questions such that and .
Proof.
We prove by demonstrating how to transform into such a . Given any noncandidate question in , we remove it and, when necessary, replace several questions. The decisions and choices are partitioned into the following three mutually exclusive scenarios, which correspond to violations of the three conditions in Definition 3.
Case (i): violates condition (i), i.e., . We simply remove from , which does not change , since the transitive closure already contains the outcome.
Case (ii): conforms to condition (i) but violates condition (ii), i.e., and . The proof for this case is similar to a subset of the proof for the following case(iii). We omit the complete proof.
Case (iii): conforms to conditions (i) and (ii) but violates condition (iii), i.e., , x, xy. There are three possible subcases, as follows.
(iii1): xy. We simply remove from and thus remove xy from . (We shall explain one exception, for which we replace instead of removing it.) The removal of does not change object partitioning and thus does not change , as explained below. The difference between and is due to transitivity. Since xy does not participate in transitivity, we only need to consider the direct impact of removing xy from . Therefore, (1) with respect to any object z that is not x or y, xy does not have any impact on z since it does not involve z. (2) With regard to x, if x, removing xy from will not move x into ; if x, then must contain comparisons between x and zy such that zx. (zy, because case(iii) violates condition (iii), i.e., yx is impossible.) Removing xy from does not affect the comparisons between z and x and thus does not affect . (3) For y, if y, removing xy from will not move y into ; if y, then there are three possible situations—(a) If y, removing xy will not move y out of and thus will not change . (b) If y and xy was ruled out before , then must contain comparisons between y and zx such that z dominates y. Removing xy from does not affect since it does not affect the comparisons between z and y; (c) If y and xy was not ruled out before , then we replace (instead of removing ) by yx. Note that yx and xy (i.e., ) are the same question but different with regard to satisfying the three conditions for candidate questions. Different from , yx is a candidate question when it is chosen (i.e., with regard to )—, y, xy is not ruled out.
(iii2): xy. We remove and replace some questions in . Consider , i.e., the objects that would be in but instead are in due to the removal of xy form . The question replacements are for maintaining intact. Fig.5 eases our explanation of this case. Suppose yv and ux. We can derive that (1) . The reason is that the outcome xy may have impact on whether other objects dominate v only if vy or yv, i.e., v. For an object v not in , the removal of cannot possibly move v from into . (2) such that uv and uv. This is because, if there does not exist such a u, removing cannot possibly move v from into , which contradicts with v.
According to the above results, such that , ww. In order to make sure v stays in , we replace the question wv by vu. If removing wv moves any object from into , we recursively deal with it as we do for . Note that vu is a candidate question when it succeeds , since (otherwise v does not belong to ), v (again, since v), and uv cannot be ruled out.
IiiB Resolving Unusual Contradictions in Question Outcomes
A preference relation can be more accurately derived, if more input is collected from the crowd. However, under practical constraints on budget and time, the limited responses from the crowd ( answers per question) may present two types of contradicting preferences.
(i) Suppose xy and yz have been derived, i.e., they belong to . They together imply xz, since a preference relation must be transitive. Therefore the question xz will not be asked. If the crowd is nevertheless asked to further compare x and z, the result might be possibly zx, which presents a contradiction.
(ii) Suppose xy and yz have been derived from the crowd. If the crowd is asked to further compare x and z, the result might be possibly zx. The outcomes yz and zx together imply yx, which contradicts with xy. (A symmetric case is xy, zy, and the crowd might respond with xz, which also leads to contradiction with xy. The following discussion applies to this symmetric case, which is thus not mentioned again.)
In practice, such contradictions are rare, even under just modest number of answers per question () and threshold (). This is easy to understand intuitively—as long as the underlying preference relation is transitive, the collective wisdom of the crowds will reflect it. We can find indirect evidence of it in [29, 30], which confirmed that preference judgments of relevance in document retrieval are transitive. Our empirical results also directly verified it. We asked Amazon Mechanical Turk workers to compare photos by color, sharpness and landscape, and we asked students at our institution to compare U.S. cities with regard to weather, living expenses, and job opportunities. In both experiments, we asked all possible questions—comparing every pair of objects by every criterion. For each criterion, we considered the graph representing the outcomes of questions, where a directed edge represents “betterthan” and an undirected edge represents “indifferent”. If there is such a “cycle” that it contains zero or one undirected edge and all its directed edges are in the same direction, the outcomes in the cycle form a contradiction. We adapted depthfirst search to detect all elementary cycles. (A cycle is elementary if no vertices in the cycle (except the start/end vertex) appear more than once.) The number of elementary cycles amounts to only 2.9% and 2.2% of the number of question outcomes in the two experiments. These values would be smaller if we had used larger and .
Nevertheless, contradictions still occur. Type (i) contradictions can be prevented by enforcing the following simple Rule 1 to assume transitivity and thus skip certain questions. They will never get into the derived preference relations. In fact, in calculating transitive closure (Definition 1) and defining candidate questions (Sec.IIIA), we already apply this rule.
Rule 1 (Contradiction Prevention by Skipping Questions).
Given objects x, y, z and a criterion , if xy and yz, we assume xz and thus will not ask the crowd to further compare x and z by criterion . ∎
To resolve type (ii) contradictions, we enforce the following simple Rule 2.
Rule 2 (Contradiction Resolution by Choosing Outcomes).
Consider objects x, y, z and a criterion . Suppose xy and yz are obtained from the crowd. If zx is obtained from the crowd afterwards, we replace the outcome of this question by xz. (Note that we do not replace it by xz, since zx is closer to xz.) ∎
Iv MicroOrdering in Question Selection
At every iteration of Alg.1, we choose a question xy from the set of candidate questions. By macroordering, when available, we choose a candidate question in which y , i.e., we choose from . Otherwise, we choose from . The size of and can be large. Microordering is for choosing from the many candidates. As discussed in Sec.III, in order to find a short question sequence, the overriding principle of our question selection strategy is to identify nonPareto optimal objects as early as possible. Guided by this principle, we discuss several microordering strategies in this section. Since the strategies are the same for and , we will simply use the term “candidate questions”, without distinction between and .
Iva Random Question (RandomQ)
RandomQ, as its name suggests, simply selects a random candidate question. Table II shows an execution of the general framework under RandomQ for Example 1. For each iteration , the table shows the question outcome . Following the question form xy in Definition 3, the object “x” in a question is underlined when we present the question outcome. The column “derived results” displays derived question outcomes by transitive closure (e.g., ae based on de and ad) and derived object dominance (e.g., bd after ). The table also shows the object partitions (, and ) when the execution starts and when the partitions are changed after an iteration. Multiple iterations may be presented together if other columns are the same for them.
Derived Results  
  be, cd, ac  {a,b,c,d,e,f}  
ce, bd, ba  
de, bd, bf  
ad  ae  
ca  
bc  
cd  ce  
  de, ec, df  
ad, fa, be  
bd  bd  {a,b,c,e,f}  {d}  
  cf, ae, fb  
af  af  
ef  bf, ba  {a,b,c,e}  {d,f}  
ea, bf  
bc  
ab  
be  be  {a,b,c}  {d,e,f}  
ca  ce, ca  {b,c}  {a,d,e,f}  
bc  bc  {b}  {a,c,d,e,f} 
As Table II shows, this particular execution under RandomQ requires questions. When the execution terminates, it finds the only Paretooptimal object b. This simplest microordering strategy (or rather no strategy at all) already avoids many questions in the bruteforce approach. The example clearly demonstrates the benefits of choosing candidate questions only and applying macrostrategy.
IvB Random Pair (RandomP)
RandomP randomly selects a pair of objects x and y and keeps asking questions to compare them (xy or yx) until there is no such candidate question, upon which it randomly picks another pair of objects. This strategy echoes our principle of eagerly identifying nonPareto optimal objects. In order to declare an object x nonPareto optimal, we must identify another object y such that y dominates x. If we directly compare x and y, it requires comparing them by every criterion in in order to make sure yx. By skipping questions according to transitive closure, we do not need to directly compare them by every criterion. However, Property 4 below states that we still need at least questions involving x—some are direct comparisons with y, others are comparisons with other objects which indirectly lead to outcomes of comparisons with y. When there is a candidate question xy, it means y may dominate x. In such a case, the fewer criteria remain for comparing them, the more likely y will dominate x. Hence, by keeping comparing the same object pair, RandomP aims at finding more nonPareto objects by less questions.
Property 4.
Given a set of criteria and an object x, at least pairwise comparison questions involving x are required in order to find another object y such that yx.
Proof.
By the definition of object dominance, if yx, then , either yx or xy, and such that yx. Given any particular , if xy, then xy, i.e., a question xy or yx belongs to the sequence , because indifference of objects on a criterion cannot be derived by transitive closure. If yx, then yx or such that yw, , wx. Either way, at least one question involving x on each criterion is required. Thus, it takes at least questions involving x to determine yx. ∎
Derived Results  
cf  {a,b,c,d,e,f}  
fc  fc  
ae, ae  
ea  ae  
ce, ce  
ec  ce  {a,b,c,d,f}  {e}  
ba  be  
ab  ab  
df  
fd  fd  
da  de  
ad  ad  
bc, bc  
bc  bc  {a,b,d,f}  {c,e}  
db, db  
bd  bd  {a,b,f}  {c,d,e}  
af  bf  
af  
fa  af  
bf  
bf  ba, bf  {b}  {a}  {c,d,e,f}  
ca, ac  
ca  ca  {b} 
Comments
There are no comments yet.