A simple game (N, v) is given by a set N of n players and a partition of (2^N ) into a set ( L ) of losing coalitions L with value (v(L)=0 ) that is closed under taking subsets and a set ( W ) of winning coalitions W with (v(W)=1 ). Simple games with ( = _ p 0 _ W W ,L L p(L) p(W) 0 ).
For graphic simple games, it is natural to take the number of players @math as the input size for answering complexity questions, but in general simple games may have different representations. For instance, one can list all minimal winning coalitions or all maximal losing coalitions. Under these two representations the problem of deciding if @math , that is, if a given simple game is a weighted voting game, is also polynomial-time solvable. This follows from results of Heged "us and Megiddo @cite_12 and Peled and Simeone @cite_2 , as shown by Freixas, Molinero, Olsen and Serna @cite_26 . The latter authors also showed that the same result holds if the representation is given by listing all winning coalitions or all losing coalitions. Moreover, they gave a number of complexity results of recognizing other subclasses of simple games.
@cite_26 @cite_12 @cite_2
2050727325 2057727486 1969423858
Simple games cover voting systems in which a single alternative, such as a bill or an amendment, is pitted against the status quo. A simple game or a yes–no voting system is a set of rules that specifies exactly which collections of “yea” votes yield passage of the issue at hand, each of these collections of “yea” voters forms a winning coalition. We are interested in performing a complexity analysis on problems defined on such families of games. This analysis as usual depends on the game representation used as input. We consider four natural explicit representations: winning, losing, minimal winning, and maximal losing. We first analyze the complexity of testing whether a game is simple and testing whether a game is weighted. We show that, for the four types of representations, both problems can be solved in polynomial time. Finally, we provide results on the complexity of testing whether a simple game or a weighted game is of a special type. We analyze strongness, properness, decisiveness and homogeneity, which are desirable properties to be fulfilled for a simple game. We finalize with some considerations on the possibility of representing a game in a more succinct representation showing a natural representation in which the recognition problem is hard. Abstract We investigate the complexity of the MEMBERSHIP problem for some geometrically defined classes of Boolean functions, i.e., the complexity of deciding whether a Boolean function given in DNF belongs to the class. We give a general argument implying that this problem is co-NP-hard for any class having some rather benign closure properties. Applying this result we show that the MEMBERSHIP problem is co-NP-complete for the class of linearly separable functions, threshold functions of order k (for any fixed k ⩾ 0), and some binary-parameter analogues of these classes. Finally, we obtain that the considered problem for unions of k ⩾ 3 halfspaces is NP-hard, co-NP-hard and belongs to Σ 2 p , and that the optimal threshold decomposition of a Boolean function as a union of halfspaces cannot even be efficiently approximated in a very strong sense unless P = NP. In some cases we improve previous hardness results on the considered problems. Abstract A set-covering problem is called regular if a cover always remains a cover when any column in it is replaced by an earlier column. From the input of the problem - the coefficient matrix of the set-covering inequalities - it is possible to check in polynomial time whether the problem is regular or can be made regular by permuting the columns. If it is, then all the minimal covers are generated in polynomial time, and one of them is an optimal solution. The algorithm also yields an explicit bound for the number of minimal covers. These results can be used to check in polynomial time whether a given set-covering problem is equivalent to some knapsack problem without additional variables, or equivalently to recognize positive threshold functions in polynomial time. However, the problem of recognizing when an arbitrary Boolean function is threshold is NP-complete. It is also shown that the list of maximal non-covers is essentially the most compact input possible, even if it is known in advance that the problem is regular.