Utilitarians Without Utilities: Maximizing Social Welfare for Graph Problems using only Ordinal Preferences - Full Version

11/28/2017 ∙ by Ben Abramowitz, et al. ∙ Rensselaer Polytechnic Institute 0

We consider ordinal approximation algorithms for a broad class of utility maximization problems for multi-agent systems. In these problems, agents have utilities for connecting to each other, and the goal is to compute a maximum-utility solution subject to a set of constraints. We represent these as a class of graph optimization problems, including matching, spanning tree problems, TSP, maximum weight planar subgraph, and many others. We study these problems in the ordinal setting: latent numerical utilities exist, but we only have access to ordinal preference information, i.e., every agent specifies an ordering over the other agents by preference. We prove that for the large class of graph problems we identify, ordinal information is enough to compute solutions which are close to optimal, thus demonstrating there is no need to know the underlying numerical utilities. For example, for problems in this class with bounded degree b a simple ordinal greedy algorithm always produces a (b+1)-approximation; we also quantify how the quality of ordinal approximation depends on the sparsity of the resulting graphs. In particular, our results imply that ordinal information is enough to obtain a 2-approximation for Maximum Spanning Tree; a 4-approximation for Max Weight Planar Subgraph; a 2-approximation for Max-TSP; and a 2-approximation for various Matching problems.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Human beings are terrible at expressing their feelings quantitatively. For example, when forming collaborations people may be able to order their peers from “best to collaborate with” to worst, but would have a difficult time assigning exact numeric values to the acuteness of these preferences. In other words, even when numerical (possibly latent) utilities exist, in many settings it is much more reasonable to assume that we only know ordinal preferences: every agent specifies the order of their preferences over the alternatives, instead of a numerical value for each alternative. Recently there has been a lot of work using such an implicit utilitarian approach, especially for matching and social choice (see Related Work), in situations where obtaining true numerical utilities may be difficult. Amazingly, as this line of work shows, it is often possible to design algorithms and mechanisms which perform well using only ordinal information. In fact, ordinal algorithms often perform almost as well as omniscient mechanisms which know the true underlying numerical utilities, instead of just the ordinal preferences induced by these utilities.

In this work we consider a relatively general network formation setting. All problems considered herein are modeled by an undirected complete graph , where the (symmetric) weight of each edge represents the hidden utility of connecting agents . The goal is to form a maximum-weight (i.e., maximum utility) graph which obeys some given constraints. For example, constraints may include bounds on the maximum degree, on component size, and many others. This framework includes such problems as matching, group formation, TSP, and many others as special cases; see Section 2 for example constraints and how they lead to different important settings.

In many settings we may not have access to the true edge weights . Instead, each agent reports a strict preference ordering over the other agents with whom it can connect. We assume this ordering to be consistent with the latent weights, so that implies that prefers to . While it is clearly impossible to form an optimal (i.e., maximum-utility) solution without direct knowledge of the edge weights, we show how to design good approximation algorithms for selecting a maximum weight subgraph of , subject to a large set of constraints. As usual in this line of work, the measure of performance is simply the sum of the agent utilities. Our paper provides good approximations for a broad class of ordinal analogues to graph optimization problems representing utility maximization for multi-agent systems. Note that unlike all previous work mentioned here, we do not make additional assumptions about the structure of the edge weights: we do not assume either that the agent utilities are normalized (as in [6, 7, 10, 11, 12]), nor that they form a metric space (as in [1, 2, 3, 4, 9, 15, 16, 23]). Thus, our results demonstrate how well one can perform using only ordinal information without additional assumptions.

ABC Systems

More specifically, we define a class of constraints called ABC Systems which consists of three types of constraints. The first two are the familiar constraints which bound the maximum degree of each node and the maximum component size, or number of nodes in a connected component. The third constraint is a much more general requirement called attachment which only applies to nodes that are already in the same connected component. The maximization problem for an ABC System is to compute a maximum weight subgraph of an undirected, complete graph such that in every node has degree at most , every connected component has size (number of nodes) at most , and for some arbitrary attachment set . A collection of subgraphs is an attachment set of if the following properties hold for all subgraphs :
1) Heredity: If and then .
2) Attachment: If and for some , then there is a -path in . 111We use the “+” and “-” notation when adding or removing a single edge to or from a set.

Note that all three of our constraints possess the heredity property which enables greedy heuristics, like the Ordinal Greedy algorithm we introduce in Section

3.1, to construct valid solutions. The intuition behind the attachment property is that if but , then must have both endpoints in the same component. Therefore, the number of such edges whose addition would violate within any component of size is bounded by , where is bounded by .

The utility maximization objective for ABC Systems encompasses a wide variety of well-known problems central to algorithm design. The examples we address in this paper include Max Weight -Matching, Maximum Weight Spanning Tree, Maximum Traveling Salesperson, and Max Weight Planar Subgraph. Our results also encapsulate many other interesting optimization problems for ABC Systems which we will not discuss directly, like finding the maximum weight subgraph with minimum girth , maximum cycle length , or which excludes a variety of graph minors (including all 2-edge-connected minors). As we show, all such problems are amenable to knowing only secondhand ordinal information, instead of the true numerical utilities.

1.1 Our Contributions

Maximization Problem Ordinal Greedy Omniscient Greedy Best Known
ABC System -
AB System -
Spanning Tree 2 1 1
Planar Subgraph 4 3 72/25 [8]
Traveling Salesperson 2 2 9/7 [19]
-Matching 2 2 1
Table 1: Here we compare our results for Ordinal Greedy, known results for Omniscient Greedy, and the best known polynomial-time algorithm with full-information. All of our bounds are tight except for the one on Planar Subgraph.

Most algorithmic techniques for maximizing utility for the full-information setting do not translate to the ordinal information setting. These typically rely on non-local information, like comparisons between weights of non-adjacent edges, or comparing the total weights of sets of edges. This is not possible using only ordinal information. Even the fundamental, and well-studied [24, 14, 22], Omniscient Greedy algorithm, which adds edges in strictly non-increasing order of their weight, cannot be executed using only ordinal information. Instead, we focus on the natural Ordinal Greedy algorithm (defined in Section 3.1), which adds edges iteratively as long as the edge being added is the most preferred edge for both and out of all the possible edges which could be added at that time. Ordinal Greedy has some very nice properties: in addition to being natural and providing high-utility solutions (as we prove in this paper), it also always creates pairwise stable solutions: no pair of agents would have incentive to destroy some of their links and form a new link connecting them. Note that the performance of Ordinal Greedy can be very different from Omniscient Greedy: see Example 1 in Section 3.1 for intuition of why this must be.

In this paper, we analyze the performance of Ordinal Greedy for many ABC Systems (see Table 1). We first prove that for general ABC Systems, Ordinal Greedy always produces a solution with weight at most factor away from optimum, and that this factor is tight. In other words, for general problems including all those in Table 1, as long as the number of connections for each node must be bounded by some small , then using only ordinal information it is possible to compete with the best possible solution, and thus with any algorithm which knows the true numerical utilities. Such results tell us that when is small, there is no need to find out the hidden edge weights/utilities; knowing the ordinal preferences is good enough.

Second, we show that by relaxing the component size constraint (i.e., setting to be unbounded) we can achieve significant improvements. For convenience, we call ABC Systems with the component size constraint relaxed AB Systems. We prove that as long as any solution formed by such an AB System is guaranteed to be at most -sparse, then Ordinal Greedy forms a solution within a factor of from optimum. Since the sparsity of a graph is at most half the average degree in any subgraph, we know that . Therefore an AB System is at worst -approximable, giving us a factor of 2 improvement over general ABC Systems.

This result is more powerful than it may first appear, as many important constraints yield sparse solutions. For example, since all tours and trees are 1-sparse, Ordinal Greedy provides a 2-approximation for both Maximum Traveling Salesperson and Maximum Weight Spanning Tree. And since all planar graphs are 3-sparse, we obtain a 4-approximation for Max Weight Planar Subgraph which uses only ordinal information.

Lastly, we consider Max Weight -Matching, in which the only constraint is that each agent can be matched with at most others. This is simply an ABC System with unbounded and being all possible sets. We prove that our approximation factor drops to a constant 2, regardless of the value of .

To prove the ordinal approximations above, we first demonstrate that for any ABC System (and any graphic system with the heredity property defined earlier) Ordinal Greedy achieves its worst approximation on an instance with weight function . We use this fact heavily to establish our approximation bounds, and believe it to be of independent interest. Note that similar results for Omniscient Greedy have relied critically on the fact that it selects edges in strictly non-increasing order by weight. Clearly this does not and cannot hold for the ordinal setting, as it is even possible for the minimum weight edge of the graph to be selected before the maximum weight edge. Because of this, our proofs require completely new approaches and techniques.

1.2 Related Work

Historically, it has been common to approach problems in the ordinal setting with a normative view by designing mechanisms which satisfy axiomatic properties, like stability or truthfulness. These axiomatic properties are useful in many applications, but do not provide a quantitative measure of the quality of a solution. The notion of distortion and the implicit utilitarian framework were first introduced by [21] in the context of voting to provide such a measure. Since then the distortion, or approximation factor, of various ordinal utility maximization mechanisms has been studied, particularly for matchings [3, 4, 5, 12, 9] and social choice [1, 2, 6, 7, 10, 11, 15, 16, 23].

Our work is unlike that in social choice, since we consider network formation problems where agent preferences are expressed over one another. In the context of matchings, [3, 4] develop various matching algorithms as a black-box to provide approximations for a variety of matching and clustering problems under the implicit utilitarian view. Additionally, [12] and [9] provide results for one-sided matchings and [5] consider bipartite matchings. However, all previous work on approximation for utility maximization mentioned above either assumes the underlying weights form a metric space [1, 2, 3, 4, 5, 15, 16, 23, 9] or are normalized [6, 7, 10, 11, 12], with only two exceptions. The first exception is that Maximum Traveling Salesperson yields a 2-approximation without the metric assumption [4]. We prove this result as part of a much more general theorem using much more general techniques. The second is the result developed in the full-information setting by [20] and affirmed in the ordinal setting by [3], that Max Weight Matching yields a 2-approximation without any assumptions on the weights. We generalize this result to all -Matchings instead of only .

The work most similar to ours is [3] which bounds the distortion of ordinal mechanisms for several problems, including Maximum Traveling Salesperson, but relies heavily on the assumption that the weights obey the triangle inequality. For the Ordinal Greedy algorithm, [3] show the metric assumption implies that any two edges which are both most preferred by their respective endpoints at some iteration must be within a factor of 2 of one another, even if they are not adjacent. By contrast, this non-local information is unavailable to us in our model. Our paper is unique in that we identify a large class of problems for which assumptions on the weights are unnecessary to achieve good approximations to optimum with only ordinal information.

The Omniscient Greedy algorithm has been studied extensively. In fact, it is known to be optimal on exactly the set of independence systems (any system with the heredity property) which are matroids [14, 22], which includes Maximum Spanning Trees. [17] showed that Omniscient Greedy provides good approximations for many independence systems, including matching and symmetric TSP. [13] further demonstrated that Omniscient Greedy provides a tight 3-approximation for Max Weight Planar Subgraph. These results were later reformulated as k-extendibility by [18], who applies this idea to a diverse set of problems, including -Matching. Unfortunately, the proofs for all results just mentioned rely critically on Omniscient Greedy selecting edges in strictly non-increasing order, making them untenable in the ordinal setting. No ordinal algorithm can yield optimum solutions, even for matroids. However, as we show in Table 1, our results compete well with the best known polynomial-time algorithms for ABC Systems.

2 Model and Problem Statements

The input for all problems in this paper is a set of agents (nodes) of size , and a strict preference ordering for each over the edges adjacent to . The preference orderings reported by each agent are induced by a set of hidden symmetric weights for all . The set of hidden weights corresponds to an undirected, complete graph with non-negative weight function . The transitive relation of the individual preference orderings for all agents determines a partial ordering over all edges; note that some pairs of edges may end up being incomparable in (see Example 1). The preference ordering is said to be consistent with the hidden weights if , if prefers to then it must be that . If an edge is known to be at least as large as edge according to this partial ordering , then we will say that dominates in . The problems we consider are optimization problems where for an instance the objective is to compute the subgraph of with maximum total edge weight, subject to a set of constraints, knowing only .

For weight function , we let be the optimal solution for the weights prescribed by , and we let be the total weight of the optimal solution evaluated by . Likewise, we use to denote our constructed solution and its weight. Our approximation factor for a problem is therefore , where is any solution returned by our algorithm for .

Recall the definition of ABC Systems. Given constraints we can say without loss of generality that , because if any node has or more neighbors in a component, this component would have to be of size greater than . When this effectively removes the node degree constraint. Similarly, when , the component size is effectively unbounded. Therefore, . Likewise, when = all subgraphs of , this effectively annuls the attachment set constraint. Some specific problems which we consider in this paper are as follows.

Max ABC:

, , = any attachment set of

Max AB:

, , = any attachment set of

Maximum Spanning Tree:

, , = all acyclic subgraphs of

Maximum Traveling Salesperson:

, , = all subgraphs of without non-Hamiltonian cycles

Max Weight Planar Subgraph:

, , = all planar subgraphs of

Max Weight -Matching:

, , = all subgraphs of

Max Weight Matching:

, , = all subgraphs of

3 Algorithmic Framework

In this section we define the Ordinal Greedy algorithm and reveal some of its salient properties. Rather than limit ourselves only to ABC Systems, in this section we consider general graphic independence systems. An independence system for our setting is a pair where corresponds to the set of edges in some graph and is a collection of subsets of such that if and then . The sets in are called independent. It is easy to see that all ABC Systems are independence systems because their three constraints possess this heredity property. Let denote the set of all subgraphs in which all nodes have degree at most and let denote the set of all subgraphs in which all connected components have size at most . Our Max ABC problem can be restated as: Given a graph , attachment set , degree limit and component size limit , compute the maximum weight subgraph in .

3.1 The Ordinal Greedy Algorithm

In an ordinal setting, algorithms only have access to a partial ordering, or set of preference orderings, which provide strictly local information about the preferences of each agent. This precludes the use of algorithms which require comparisons between the weights of non-adjacent edges. In fact, it is not difficult to see that no ordinal algorithm can be guaranteed to compute the optimal solution for even simple settings, e.g., forming a matching [3]. However, the Ordinal Greedy algorithm defined below performs well in this setting because it relies on strictly local information. Ordinal Greedy starts from the empty set and builds up a sequence of intermediate solutions by adding locally optimal edges at each iteration which do not violate a set of constraints, i.e., preserve independence. To understand how this heuristic is applied to the ordinal setting, we must formalize what it means for an edge to be locally optimal.

Definition 1.

Undominated Edge
Given a set of edges, is undominated if for all and in , and .

At this point it is important to make several observations. First, every edge set has at least one undominated edge, because its maximum weight edge must be undominated. However, there may be undominated edges which are not globally maximum. Second, for any edge set it is straightforward to find at least one undominated edge using only the partial ordering (see [3] for details). Undominated edges are either of the form where and are each other’s most preferred neighbor, or form cycles in which each subsequent node is the first choice of the previous one, and thus all edges in the cycle have the same weight.

What follows is a general purpose Ordinal Greedy algorithm, which starts from the empty set and iteratively selects undominated edges from the set of remaining edges which do not violate the constraints in question. The algorithm uses the partial ordering to determine which edges are undominated at each iteration. The algorithm concludes when there are no edges left which can be added to the subgraph without violating the constraints, so the final solution is maximal in this sense.

Input: Edge set , partial ordering , collection of valid subgraphs
Initialize , ;
while  do
       Pick an undominated edge and add it to the intermediate solution: ;
       Remove from ;
       Remove all edges from such that ;
      
end while
Output: Return
Algorithm 1 Ordinal Greedy

We refer to the iteration at which an edge is removed from as the critical iteration of . When the inputs to our algorithm characterize an ABC System, there are exactly four cases which may occur at the critical iteration of edge :
1) is added to the ordinal greedy solution
2) is removed from because
3) is removed from because (where sets of edges with any degree )
4) is removed from because (where sets of edges with any component size )

For cases 2-4 we say was eliminated due to or . If an edge was eliminated due to , the attachment property implies there must be a -path in the intermediate solution at its critical iteration. In other words, and are already in the same connected component in at this iteration. If was eliminated due to , either or must already have degree exactly at this iteration. If was eliminated due to , and must already be in disjoint connected components whose cumulative size is greater than . Note that in these three cases, an edge can only be eliminated if at least one adjacent edge of equal or greater weight has already been added to the intermediate solution, and all adjacent edges already added to the intermediate solution must be of equal or greater weight (since only undominated edges are added to our solution).

There are limiting values of , , and for which elimination due to these constraints cannot occur. When , no edge can be eliminated due to because all nodes can be in the same connected component. Additionally, when is the set of all subgraphs of , no edge can be eliminated due to . If adding an edge would violate more than one constraint, we say that it was eliminated in order of priority . For example, when , no edge can be eliminated due to , because for a node to reach degree the size of its component must be exactly and we say that any incident edge would be eliminated due to . As the following sections show, the approximation factor of Ordinal Greedy for an ABC System depends on which cases of elimination can occur.

Notice that the performance of the Ordinal Greedy algorithm can deviate significantly from the Omniscient Greedy algorithm in the full-information setting (which we call “Omniscient Greedy” because it knows the underlying edge weights and can choose the edge with maximum weight at each iteration). Consider the following example.

Example 1.

Suppose the graph is constructed as follows. Let . Let for for some infinitesimal . Let for all . Let for all . Let all other edges have weight 0. Consider the ABC System corresponding to finding a Maximum-Weight Spanning Tree. It is clear that Omniscient Greedy will find the optimum solution with weight .

Now consider Ordinal Greedy. Suppose Ordinal Greedy begins by selecting for , which are all undominated at the beginning of the algorithm. Once these edges have been selected, edges of the form and become undominated for . Now, if an edge or is selected, the other must be eliminated at that iteration, since taking it would form a cycle. Notice that since we only have access to ordinal information, there is no possible way for Ordinal Greedy to tell which of these edges is better: they are both edges which are most preferred by their endpoints, even though one secretly has weight and the other only . In other words, these edges are incomparable in the partial preference order . Suppose Ordinal Greedy proceeds by selecting for . Then the Ordinal Greedy solution formed has weight . This example shows that (in the limit) it is not possible for Ordinal Greedy to always result in solutions better than a factor of 2 away from optimum, even though Omniscient Greedy can easily compute the true optimum solution. As we show in this paper, however, despite its knowledge handicap, Ordinal Greedy can often produce surprisingly good results.

3.2 Properties of Ordinal Greedy

For any independence system in the full-information setting, the Omniscient Greedy algorithm has been shown to achieve its worst approximation on an instance with a binary weight function [17]. However, previous proofs have relied crucially on the fact that Omniscient Greedy selects edges in strictly non-increasing order by weight, which is not possible with only ordinal information. We offer a new proof to show that even in the ordinal setting, Ordinal Greedy always achieves its worst approximation factor on an instance with a binary weight function for any graphic independence system. This theorem will allow us to prove approximation bounds for ABC and AB Systems later in this paper.

Theorem 1.

For any graphic independence system , for any instance with weight function and partial ordering consistent with , there exists an instance with weight function such that is consistent with and the worst-case ratio of the optimal solution to an Ordinal Greedy solution is at least as large as for .

Before we begin the proof, we provide a short proof sketch. Suppose on instance the ratio between the optimal solution and solution constructed by Ordinal Greedy is . Our goal is to construct a binary weight function such that . When is infinite, constructing is straightforward, so we only consider finite values of . First we create a weight function by raising the weights of all edges not in as much as possible without altering the weights of the edges of , such that remains consistent with . Since Ordinal Greedy selects and none of its edge weights have changed, and the edge weights of cannot have decreased, then . From we carefully create by proving that there must exist a subset of edges to which we can assign weight 1 and let all other edges have weight 0, such that is consistent with and .

Proof.

Recall that a partial ordering is consistent with weight function if for all , if prefers to in then . We will now show that for any instance where for which Ordinal Greedy provides a -approximation for in the worst case, there exists an instance where for which Ordinal Greedy provides no better than a -approximation in the worst case. Given any weight function we now construct a binary weight function such that the approximation factor is at least as large and is still consistent with .

Observation 1.

For an independence system the solution computed by Ordinal Greedy depends only on , not the edge weights. Therefore, if is consistent with and , the possible solutions are the same for instances and . However, and may differ.

Therefore, given a worst possible solution constructed by Ordinal Greedy for , our goal is to take the weight function and construct a binary weight function such that , and is still consistent with (and thus can still be produced by Ordinal Greedy for the instance with weights ). Recall that is the optimum (maximum-weight) solution for weights . Since by definition , it is enough to show that .

Suppose there is some edge , such that no edge in is known to be greater than or equal to it in the partial ordering . If such an edge exists, we can let be the weight function such that and all edges known to be greater than or equal to in have weight 1, and all other edges have weight 0. Clearly, remains consistent with . To see this, consider any such that prefers to . Then either both and dominate in , so , or neither do, in which case . The only other case is that dominates and does not (since we know that dominates everything that does), and then . In all cases, , so is consistent with . This means remains the same set of edges, and since , the approximation factor becomes unbounded. This means for any instance where there is some edge for which no edge in dominates it in , we can always create a weight function with an approximation factor at least as large. Therefore, for the rest of the proof we assume that for every edge there exists some edge in known to be at least as great by the partial ordering .

For our greedy solution , fix an ordering over the edges of in non-increasing order by weight so that . Construct weight function by increasing the weight of each edge not in to be equal to the weight of the smallest-weight edge known to be greater than or equal to it in the partial ordering . Note that by our assumption above, such an edge always exists.

Claim 1.

is consistent with .

Proof.

Consider any two adjacent edges and where prefers to . Let be a smallest edge known by to have weight at least . Then is also known to have weight at least since prefers to . Therefore, the smallest edge of known to have weight at least is either or has weight smaller than . After increasing the weights, . Therefore if prefers to in , then . By definition, remains consistent with . ∎

The above process of forming forms an assignment of edges: consider every edge to be assigned to the smallest edge in known to be larger than or equal to it in the partial ordering, where . Now alter these assignments so that if then all edges with this weight, including , are assigned to . Let be the number of edges of assigned to . Note that if then .

Lemma 1.

Proof.

On the left side of the inequality, the product denotes the total weight of the edges of assigned to after having their weight increased. This sum over computes , the total weight of the optimal solution over , evaluated by . On the right hand side, the summation yields the total weight of the edges in the greedy solution, multiplied by . Since is consistent with by Claim 1 the greedy solution remains the same, and since none of the weights of edges of were altered . By construction, because the weights of edges of could only have been increased. And so . ∎

We now demonstrate that we can alter the weights of to create a binary weight function such that . All changes to the weights keep consistent with , so that remains a solution of Ordinal Greedy.

Lemma 2.

There exists some such that .

Proof.

Suppose to the contrary that for all . We show by induction that this implies , which yields a contradiction to Lemma 1. Specifically, we will show that for every ,

(1)

When applied to , this gives us the result that . Since , then , and thus the right hand side of the above inequality is strictly less than , which gives us a contradiction with Lemma 1, as desired. Note that here we use the fact that without loss of generality; if this were not the case then we can make the same argument for being the largest integer such that . Thus all that is left is to prove Inequality (1).

We proceed by induction. The base case for is trivially true. Now assume that Inequality (1) holds for , and we will prove it for . Then,

Let . Since by our assumption , we know that . Suppose in the right-hand side of the above inequality, we increase the coefficient of by , and decrease the coefficient of by . Since , this only makes the quantity larger. Thus, we obtain that:

as desired. This proves Inequality (1) for every , and thus completes the proof of this Lemma. ∎

We now use this value of to construct the binary weight function . Take the smallest such that and let be the weight function where for all , , for all assigned to , and all other edges have weight 0. Note that since if and , then .

We now argue that is still consistent with . Consider any adjacent edges such that prefers to , and suppose that is assigned to edge , while is assigned to edge . First consider the case when . It must be that , since the set of edges dominating is a subset of edges dominating , and edges are assigned to a smallest edge of dominating them. Then , as desired. If instead , then by construction of our assignment we have that , so . Therefore is consistent with because for any adjacent edges such that prefers to it must be that .

Thus we now have a binary weight function such that is a possible solution of Ordinal Greedy, since is consistent with . By definition of , we know that , and . Due to our choice of , we thus have that .

This concludes our proof that for any instance where for which Ordinal Greedy provides a -approximation for in the worst case, there exists an instance where for which Ordinal Greedy provides no better than a -approximation in the worst case. ∎

Another nice property is that every solution constructed by Ordinal Greedy is pairwise stable. Pairwise stability means that no pair of agents has incentive to collude to add edge by each giving up some of their edges in the Ordinal Greedy solution . Either this exchange would decrease the total utility of one of the agents, or adding is infeasible even after sacrificing the other edges. Here we assume that the utility of a node in solution is simply the total weight of edges in incident on .

Theorem 2.

Any solution constructed by Ordinal Greedy on an independence system is pairwise stable.

Proof.

Let and let and be any set of edges in adjacent to and excluding . If and can improve their individual utilities by adding at the expense of removing all of the edges in , this means and . However, this clearly implies is larger than the weight of each individual edge in and . If , then its critical iteration must have occurred before any of the adjacent edges in and were added to the Ordinal Greedy solution. Therefore cannot be a feasible solution. ∎

4 Ordinal Approximation for ABC Systems

In this section we bound the worst-case performance of Ordinal Greedy compared to the optimal solution for any ABC System. We use to denote the approximation factor, or the ratio of the optimal solution to the worst possible Ordinal Greedy solution for any ABC System.

Unlike Example 1 in Section 3.1 for the maximum spanning tree problem, Ordinal Greedy does not provide a constant approximation factor for all ABC Systems. However, it does always provide a finite approximation which depends on the degree limit . To simplify notation, since the optimal solution here is only evaluated using the same weight function used to generate it, we refer to the total weight of the optimal solution as . Here we show that for any ABC System and provide a family of examples where to show that is a tight bound on the approximation factor. In later sections, we explore classes of ABC Systems in which Ordinal Greedy achieves a better worst-case approximation.

Note that this result is quite general. As we discussed, ABC Systems include many varied constraints, some quite difficult to approximate. Our result in this section states that, even for extremely complex and constraints on component size , as long as the maximum allowed degree of any node is small, then it is possible to form a good approximation to the true optimum solution while only knowing ordinal information instead of the true edge weights.

Theorem 3.

For any ABC System, the Ordinal Greedy algorithm always produces a solution within a factor of (b+1) of the optimal solution, and this bound is tight.

Before we begin the detailed proof, we provide a short proof sketch. We proceed via a charging argument. We wish to charge the weight of the edges of to the edges of such that all edges of are fully charged somewhere, and no edge of receives a charge greater than times its weight. However, unlike Omniscient Greedy in the full-information setting, we cannot assume that any eliminated edge of has weight smaller than all edges of the Ordinal Greedy solution which were added before its critical iteration. This prohibits us from using the methods in previous work. Thankfully, due to Theorem 1 we know that if Ordinal Greedy produces a solution within a factor of of optimal for all instances with binary weight functions, then this holds for all instances. We therefore assume that all weights are , and can now charge any edge of to any weight 1 edge of , but must ensure that no weight is charged to any edges of with weight 0.

To ensure no edge of is charged more than times its weight, we look at the connected components of with only weight 1 edges, and charge all edges of to these components. Specifically, we design the following charging scheme. Let be an edge of where . Let and be the connected components containing and in the subgraph of containing only weight 1 edges. We charge the weight of between and based on what occurs at the critical iteration of . If then , so charge its full weight to this component. If was eliminated due to , charge its full weight to either or arbitrarily. Note that while the attachment property of ensures that and are in the same connected component in at this iteration, this does not imply that because all -paths in may contain a weight 0 edge. If was eliminated due to , one of its endpoints must have a degree of exactly in at this iteration, so charge its full weight to the component containing this endpoint. If was eliminated due to , we split the charge between and based on the size of the connected components in containing and at this iteration. Let and be the sizes of the connected components in containing and at the critical iteration of . Charge to and to . In all four cases we have ensured the full weight of the edge of has been charged between the components containing its endpoints.

The rest of the proof involves arguing that each such component of size is charged a total of at most using the above charging scheme. Since such a component must contain at least edges with weight 1, this completes the proof of the upper bound because it shows that the total number of edges in with weight 1 is at most times the number of such edges in .

We then provide a family of examples to show this bound is tight. Omniscient Greedy has the same worst-case solution as Ordinal Greedy on this family of examples, so our ordinal approximation competes well despite its knowledge handicap. Note that in the example yielding the lower bound of , all edges are eliminated due to . The following section demonstrates that when the component size constraint is relaxed by allowing , the approximation factor improves significantly.

Proof.

First, we prove the upper bound . Since all ABC Systems are independence systems, by Theorem 1 it is sufficient to show that for all instances with integral weight functions to provide an upper bound on for all instances.

We proceed via a charging argument. Let be a binary weight function , so all edges in our graph are either weight 1 or weight 0. Given the Ordinal Greedy solution constructed for some instance we consider the subgraph with only weight 1 edges and partition into connected components. We then construct a charging scheme which charges the full weight of all the edges in to these components. The total charge over all these components represents the total weight of , while the total weight of these components is equal to the weight of the greedy solution. If our charging scheme guarantees that the full weight of all edges of has been charged to the components, and no component of is charged more than times the total weight of its edges, then we can sum over these components to show that .

Let be the set of connected components in . Let be any connected component in this subgraph of size and total weight . We make two obvious, but critical observations about each component .

Observation 2.

For any component , its total weight is at least , the weight of its maximum spanning tree.

Observation 3.

There is a path between any two nodes in with only weight 1 edges if and only if the nodes are in the same component .

Claim 2.

There exists a charging scheme which charges the full weight of all edges of to the components of such that the total charge to any component of size is at most .

Proof.

We need only charge the edges of such that because the weight 0 edges do not contribute to the value of .

Charging Scheme: Let be an edge of where . Let and be the connected components containing and in the subgraph containing only weight 1 edges. We charge the weight of between and based on what occurs at the critical iteration of . If then , so charge its full weight to this component. If was eliminated due to , charge its full weight to either or arbitrarily. Note that while the attachment property of ensures that and are in the same connected component in at this iteration, this does not imply that they are in the same connected component in because all -paths in may contain a weight 0 edge. If was eliminated due to , one of its endpoints must have a degree of exactly in at this iteration, so charge its full weight to the component containing this endpoint. If was eliminated due to , we split the charge between and based on the size of the connected components in containing and at this iteration. Let and be the sizes of the connected components in containing and at the critical iteration of . Charge to and to . In all four cases we have ensured the full weight of the edge of has been charged between the components containing its endpoints.

The weight of each edge has been charged exclusively to the components containing its endpoints, and . Therefore, to determine the maximum possible charge to any component , we bound the charge from edges of with one or both endpoints in and show this is at most .

Case 1)
All nodes have at most adjacent edges in , so the maximum charge to any component with nodes is . If then the total charge on is at most .

Case 2)
Let be the first node in to have an edge of weight 0 added adjacent to it in at some iteration of Ordinal Greedy. By definition, at any time before the critical iteration of this weight 0 edge cannot be in the same component in as any edge of weight 0. If there is no node in with an adjacent weight 0 edge in , let be any arbitrary node in . Let a Type 2 edge be an edge of with weight 1 which is incident to , but not to any other node in . Let a Type 1 edge be all edges of of weight 1 which are not Type 1, including all edges with both endpoints in and those with a single endpoint in which is not .

Since all nodes have degree at most in and there are nodes other than , it is clear that Type 1 edges cumulatively contribute a charge of at most to . Here we show that Type 2 edges contribute a total charge of at most , limiting the total charge to any component to at most .

Let be an edge of where . The critical iteration of must be before the critical iteration of the first weight 0 edge incident to in . This is because at the iteration the weight 0 edge was added to it had to be undominated, so could not still have been adjacent to it in the set of available edges .

Let denote the component containing . We look at the four cases of charging based on the critical iteration of to show that Type 2 edges contribute a charge of at most to .

If , then clearly this is Type 1 because and so it has already been charged to . Likewise, if was eliminated due to then its endpoints must be in the same component . This is because the attachment property ensures that and are in the same connected component in at this iteration, and by the definition of it cannot yet have a path to any edge of weight 0. Therefore any path from to in must contain only weight 1 edges, meaning . If was eliminated due to then its full weight is either charged to or to . For its weight to be charged to , must have degree at this iteration. For to have weight 1 this means all of the edges incident to in must have weight 1 because otherwise they could not have been undominated before the critical iteration of . However, this would mean that all neighbors of are in , so . Therefore, if there can be no Type 2 edges charged to which were eliminated due to .

We can now see that the only Type 2 edges charged to are those which are eliminated due to . For each of these edges is charged . For to be eliminated due to this means the combined sizes of the disjoint components in containing and must be at least , otherwise the edge would still be a valid edge to add. In other words, so . And since no weight 0 edge may yet be adjacent to the component in containing at this iteration, we know that . Therefore, , so the charge from each Type 2 edge eliminated due to is at most . And since there can be at most Type 2 edges, the total charge they contribute to is at most because (the maximum degree can never be more than the component size).

This leaves us with a total charge to of at most when . Together with Case 1, we have shown that the total charge to each component of size at most . This concludes the proof of Claim 2. ∎

By summing the charge over all components we get from the above claim. In other words, .

To show that the above result is tight, consider the following ABC System. This system represents the problem of hedonic coalition formation with additive separable symmetric preferences ( and = all subgraphs of ), where agents are partitioned into coalitions (cliques) and each agent’s total utility is the sum of its utility for being matched with all other agents in its coalition.

Example 2

Suppose that , , and = all subgraphs of G. In other words, the only constraint is that all components must be of size at most . Label the nodes for and . Let for all . Let for all for some infinitesimal . Let all other edges have weight 0.

For appropriate choices of preferences , Ordinal Greedy may select each of the edges for all before selecting any others, creating a path of length . Thus, all of the weight 1 edges are eliminated due to . The optimal solution is to select each of the edges for all . This yields while because consists of stars with edges each. Therefore as , because . As is an upper bound on the ratio between the optimal solution and the greedy solution for any instance, we have .

This concludes our proof of Theorem 3. ∎

5 AB Systems and Important Special Cases

In this section, we bound the performance of Ordinal Greedy on ABC Systems where , effectively removing the component size constraint. We then discuss some common examples of maximization problems on AB Systems, including Max Spanning Tree, Max TSP, and Max Planar Subgraph. To improve our bound from we invoke the notion of sparsity.

Definition 2.

Sparsity
A graph is -sparse if for all subgraphs containing nodes and edges and for any there exists a subgraph such that .

Suppose our attachment set and degree limit imply that any feasible solution must be -sparse. Note that this sparsity is implied by our constraints, and is not a separate constraint. Our main result in this section is that, for any graph collection which is guaranteed to be -sparse, ordinal information is enough to produce good approximations. Specifically, we prove a bound of for such settings. Since the sparsity corresponds to an upper bound on average degree of the nodes, it is always true that , and so when , this immediately reduces the approximation factor from to . Even for large , however, there are many natural classes of graphs that are always sparse, including planar graphs, scale-free graphs, graphs of small arboricity or treewidth, and many others. As we discuss in the next section, this result allows us to provide extremely strong guarantees for many important problems.

Theorem 4.

For any ABC System where the components can be of any size and the constraints imply that any feasible solution must be -sparse, the Ordinal Greedy algorithm always produces a solution within a factor of of the optimal solution, and this bound is tight.

As with our proof of Theorem 3 for general ABC Systems, we only need to consider instances with weights due to Theorem 1. However, the charging schemes and proofs for ABC Systems and AB Systems differ significantly. To lower the approximation factor from to , we have to be more selective about where we charge the edges of . For simplicity, we first assign the edges of to their endpoints, before considering the total charge to all the nodes in any component. Since is -sparse, the edges of can be assigned to their endpoints such that each node is assigned at most edges. We then take such an assignment and for each edge of eliminated due to we change its assignment, if necessary, to the node which caused its elimination. Let be a component of the subgraph of containing only weight 1 edges, and suppose . Then, similarly to the proof of Theorem 3, we must show that this component will be charged at most , but unlike before, components may be charged more than if .

Now we consider two cases based on whether any node in a component was charged an edge of eliminated due to . If there such a node in a component, then it must be possible to distribute the charge on the nodes over the edges of the component directly so that no edge is charged more than times its weight. If there is no such node, then we show that at least one node in the component must be charged at most and the rest are charged at most , cumulatively providing a charge at most which can then be distributed over the edges in the component. Once again, we provide a family of examples to show that this bound is tight.

Proof.

In other words, we will show that