Monotone Boolean Functions with s Zeros Farthest from Threshold Functions

In this paper, we prove two general theorems on monotone Boolean functions which are useful for constructing an learning algorithm for monotone Boolean functions under the uniform distribution. A monotone Boolean function is called fair if it takes the value 1 on exactly half of its inputs. The first result proved in this paper is that the single variable function f(x) = x i has the minimum correlation with the majority function among all fair monotone functions (Theorem 1). This proves the conjecture by Blum, Burch and Langford (FOCS '98) and improves the performance guarantee of the best known learning algorithm for monotone Boolean functions under the uniform distribution proposed by them. Our second result is on the relationship between the influences and the average sensitivity of a monotone Boolean function. The influence of variable x i on f is defined as the probability that f(x) differs from f(x○+ e i ) where x is chosen uniformly from {0, 1} n and x ○+ e i means x with its i-th bit flipped. The average sensitivity of f is defined as the sum of the influences over all variables x i . We prove that a somewhat unintuitive result which says if the influence of every variable on a monotone Boolean function is small, i.e., O(1/n c ) for some constant c > 0, then the average sensitivity of the function must be large, i.e., Ω(log n) (Theorem 11). We also discuss how to apply this result to construct a new learning algorithm for monotone Boolean functions.

Consider a situation with n agents or players, where some of the players form a coalition with a certain collective objective. Simple games are used to model systems that can decide whether coalitions are successful (winning) or not (losing). A simple game can be viewed as a monotone boolean function. The dimension of a simple game is the smallest positive integer d such that the simple game can be expressed as the intersection of d threshold functions, where each threshold function uses a threshold and n weights. Taylor and Zwicker have shown that d is bounded from above by the number of maximal losing coalitions. We present two new upper bounds both containing the Taylor-Zwicker bound as a special case. The Taylor-Zwicker bound implies an upper bound of (n choose n/2). We improve this upper bound significantly by showing constructively that d is bounded from above by the cardinality of any binary covering code with length n and covering radius 1. This result supplements a recent result where Olsen et al. showed how to construct simple games with dimension |C| for any binary constant weight SECDED code C with length n. Our result represents a major step in the attempt to close the dimensionality gap for simple games.

We consider average-case complexity of computing monotone Boolean functions by straight-line programs with a conditional stop over the basis of all Boolean functions of at most two variables. For the set of all n -ary monotone Boolean functions new Shannon-type upper and lower bounds for the average-case complexity as n → ∞ are established.

We study the realization of monotone Boolean functions by networks. Our main result is a precise version of the following statement: the complexity of realizing a monotone Boolean function ofn arguments is less by the factor (2/πn)1/2, whereπ is the circular ratio, than the complexity of realizing an arbitrary Boolean function ofn arguments. The proof combines known results concerning monotone Boolean functions with new methods relating the computing abilities of networks and machines.

Related DatabasesWeb of Science You must be logged in with an active subscription to view this.Article DataHistoryPublished online: 27 July 2006Keywordstransversal, minimal infrequent set, independent set, hypergraph, dualization, monotone Boolean function, incremental polynomial time, threshold function, data mining, maximal frequent setAMS Subject Headings68R05, 68Q25, 68Q32Publication DataISSN (print): 0097-5397ISSN (online): 1095-7111Publisher: Society for Industrial and Applied MathematicsCODEN: smjcat

Approximation of a partial boolean function by a monotonic boolean function

Fast sequential evaluation of monotonic Boolean functions

We study how hard is to determine some fundamental properties of dynamics of certain types of network automata. We address the computational complexity of determining how many different possible dynamic evolutions can arise from some structurally very simple, deterministic and sparsely connected network automata. In this as well as our prior, related work, we try to push the limits on the underlying simplicity of two structural aspects of such network automata: (i) the uniform sparseness of their topologies, and (ii) severely restricted local behaviors of the individual agents (that is, the local update rules of the network nodes). In this endeavor, we prove that counting the Fixed Point (FP) configurations and the predecessor and ancestor configurations in two classes of network automata, called Sequential and Synchronous Dynamical Systems (SDSs and SyDSs, respectively), are computationally intractable problems. Moreover, this intractability is shown to hold when each node in such a network is required to update according to (i) a monotone Boolean function, (ii) a symmetric Boolean function, or even (iii) a simple threshold function that is both monotone and symmetric. Furthermore, the hardness of the exact enumeration of FPs and other types of configurations of interest remains to hold even in some severely restricted cases with respect to both the network topology and the diversity (or lack thereof) of individual node's local update rules. Namely, we show that the counting problems of interest remain hard even when the nodes of an SDS or SyDS use at most two different update rules from a given restricted class, and, additionally, when the network topologies are constrained so that each node has only $c = O(1)$ neighbors for small values of constant $c$. Our results also have considerable implications for other discrete dynamical system models studied in applied mathematics, physics, biology and computer science, such as Hopfield networks and spin glasses. In particular, one corollary of our results is that determining the memory capacity of sparse discrete Hopfield networks (viewed as associative memories) remains computationally intractable even when the interconnection and dependence structure among the nodes of a Hopfield network is severely restricted.

The classification of monotone Boolean functions (MBF) into types is given.The notion of the maximum type of MBF is introduced, and the shift-sum types are constructed.The matrices of type distribution by rank are constructed.Convenient algorithms for finding the number of maximum types and the maximum types themselves are presented.The proposed methods can be used to analyze large MBF ranks.

We consider the problem of learning monotone Boolean functions over {0, 1}/sup n/ under the uniform distribution. Specifically, given a polynomial number of uniform random samples for an unknown monotone Boolean function f, and given polynomial completing time, we would like to approximate f as well as possible. We describe a simple algorithm that we prove achieves error at most 1/2-/spl Omega/(1//spl radic/n), improving on the previous best bound of 1/2-/spl Omega/((log/sup 2/ n)/n). We also prove that no algorithm, given a polynomial number of samples, can guarantee error 1/2-/spl omega/((log n)//spl radic/n), improving on the previous best hardness bound of O(1//spl radic/n). These lower bounds hold even if the learning algorithm is allowed membership queries. Thus this paper settles to an O(log n) factor the question of the best achievable error for learning the class of monotone Boolean functions with respect to the uniform distribution.

We study competitive function evaluation in the context of computing with priced information. A function f has to be evaluated for a fixed but unknown choice of the values of the variables. Each variable x of f has an associated cost c(x), which has to be paid to read the value of x. The problem is to design algorithms that compute the function querying the values of the variables sequentially while trying to minimize the total cost incurred. The evaluation of the performance of the algorithms is made by employing competitive analysis. We determine the best possible extremal competitive ratio for the classes of threshold trees, game trees, and monotone boolean functions with constrained minterms, by providing a polynomial-time algorithm whose competitiveness matches the known lower bounds.

Definitions of a reduct for a single object, decision class and all objects of decision table for the variable precision rough set model are introduced. The definitions have a property that the set of prime implicants of minimal disjunctive normal form of a discernibility function is equal to the set of reducts. Thus the problem of reducts maintenance in dynamically extended information systems is equivalent to the problem of discernibility function maintenance. We prove that the problem can be stated in the form of a Boolean equation: g ⋀ h = f ⋀ k, where f, h and k are given monotonic Boolean functions and g is a function to be determined in minimal disjunctive normal form. An incremental algorithm finding the solution of the above equation is proposed.

Consensus maximisation (MaxCon), which is widely used for robust fitting in computer vision, aims to find the largest subset of data that fits the model within some tolerance level. In this paper, we outline the connection between MaxCon problem and the abstract problem of finding the maximum upper zero of a Monotone Boolean Function (MBF) defined over the Boolean Cube. Then, we link the concept of influences (in a MBF) to the concept of outlier (in MaxCon) and show that influences of points belonging to the largest structure in data would generally be smaller under certain conditions. Based on this observation, we present an iterative algorithm to perform consensus maximisation. Results for both synthetic and real visual data experiments show that the MBF based algorithm is capable of generating a near optimal solution relatively quickly. This is particularly important where there are large number of outliers (gross or pseudo) in the observed data.

Let f be a function on a set of variables V. For each x e V, let c(x) be the cost of reading the value of x. An algorithm for evaluating f is a strategy for adaptively identifying and reading a set of variables U ⊆ V whose values uniquely determine the value of f. We are interested in finding algorithms which minimize the cost incurred to evaluate f in the above sense. Competitive analysis is employed to measure the performance of the algorithms. We study two variants of the above problem. First we consider the classical setting in which one assumes that the algorithm knows the cost c(x), for each x e V. For the case where f is a monotone boolean function which is representable by a threshold tree, we provide a polynomial time algorithm with the best possible competitive ratio γfc for each fixed cost function c(·). Remarkably, the best known result for the same class of functions is a pseudo-polynomial algorithm with competitiveness 2γfc. For the class of game tree functions our polynomial time algorithm attains, for each fixed cost function, the same competitiveness as the best known algorithm for the same class of functions, which instead runs in pseudo-polynomial time.In the second part of the paper, we study a novel variant of the problem. Here, we assume that the cost function is not known in advance and some preemption is allowed in the reading operations. This model has applications, e.g., when reading a variable coincides with obtaining the output of a job on a CPU and the cost is the CPU time. In such a case, it is reasonable to assume that no exact knowledge of the cost is available. We define a new algorithm for this problem based on the solution of a Linear Program. We show the optimality of our algorithm for the class of monotone boolean functions representable by AND-OR-trees. We also show a sub-optimal implementation for general monotone boolean functions.

In [Proceedings of the Second Symposium on Switching Circuit Theory and Logical Design (FOCS), 1961, pp. 34–38], Chow proved that every Boolean threshold function is uniquely determined by its degree-0 and degree-1 Fourier coefficients. These numbers became known as the Chow parameters. Providing an algorithmic version of Chow's theorem—i.e., efficiently constructing a representation of a threshold function given its Chow parameters—has remained open ever since. This problem has received significant study in the fields of circuit complexity, game theory and the design of voting systems, and learning theory. In this paper we effectively solve the problem, giving a randomized polynomial-time approximation scheme with the following behavior: Given the Chow parameters of a Boolean threshold function f over n bits and any constant $\epsilon>0$, the algorithm runs in time $O(n^2\log^2n)$ and with high probability outputs a representation of a threshold function $f'$ which is $\epsilon$-close to f. Along the way we prove several new results of independent interest about Boolean threshold functions. In addition to various structural results, these include $\tilde{O}(n^2)$-time learning algorithms for threshold functions under the uniform distribution in the following models: (i) the restricted focus of attention model, answering an open question of Birkendorf et al.; (ii) an agnostic-type model. This contrasts with recent results of Guruswami and Raghavendra who show NP-hardness for the problem under general distributions; (iii) the PAC model, with constant $\epsilon$. Our $\tilde{O}(n^2)$-time algorithm substantially improves on the previous best known running time and nearly matches the $\Omega(n^2)$ bits of training data that any successful learning algorithm must use.