On Learning Monotone Boolean Functions under the Uniform Distribution

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.

Let $T_t$ denote the $t$-threshold function on the $n$-cube: $T_t(x) = 1$ if $|\{i : x_i=1\}| \geq t$, and $0$ otherwise. Define the distance between Boolean functions $g$ and $h$, $d(g,h)$, to be the number of points on which $g$ and $h$ disagree. We consider the following extremal problem: Over a monotone Boolean function $g$ on the $n$-cube with $s$ zeros, what is the maximum of $d(g,T_t)$? We show that the following monotone function $p_s$ maximizes the distance: For $x \in \{0,1\}^n$, $p_s(x)=0$ if and only if $N(x) < s$, where $N(x)$ is the integer whose $n$-bit binary representation is $x$. Our result generalizes the previous work for the case $t=\lceil n/2 \rceil$ and $s=2^{n-1}$ by Blum, Burch, and Langford [BBL98-FOCS98], who considered the problem to analyze the behavior of a learning algorithm for monotone Boolean functions, and the previous work for the same $t$ and $s$ by Amano and Maruoka [AM02-ALT02].

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 give an algorithm that learns any monotone Boolean function $\fisafunc$ to any constant accuracy, under the uniform distribution, in time polynomial in n and in the decision tree size of $f.$ This is the first algorithm that can learn arbitrary monotone Boolean functions to high accuracy, using random examples only, in time polynomial in a reasonable measure of the complexity of $f.$ A key ingredient of the result is a new bound showing that the average sensitivity of any monotone function computed by a decision tree of size s must be at most $\sqrt{\log s}$. This bound has proved to be of independent utility in the study of decision tree complexity [O. Schramm, R. O'Donnell, M. Saks, and R. Servedio, Every decision tree has an influential variable, in Proceedings of the 46th Annual IEEE Symposium on Foundations of Computer Science, IEEE Computer Society, Los Alamitos, CA, 2005, pp. 31–39]. We generalize the basic inequality and learning result described above in various ways—specifically, to partition size (a stronger complexity measure than decision tree size), p-biased measures over the Boolean cube (rather than just the uniform distribution), and real-valued (rather than just Boolean-valued) functions.

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.

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.

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.

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.

Approximation of a partial boolean function by a monotonic boolean function

Fast sequential evaluation of monotonic Boolean functions

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.

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.

Any monotone Boolean function on a lattice can be described by the set of its minimal 1 values. If a lattice is given as a concept lattice, this set can be represented by the set of minimal hypotheses of a classification context. Enumeration of minimal hypotheses in output polynomial time is shown to be impossible unless P = NP, which shows that dualization of monotone functions on lattices with quasipolynomial delay is hardly possible.

In this article the triangular codes found dependence of the power of these codes on the length of codewords in them.The methods of construction codes and some triangular propose an effective general method for constructing such codes based on monotone Boolean functions.Designed with correcting codes cryptosystem on the basis of such a code, which allows one to correct the error.The advantage of this cryptosystem is the speed of coding and decoding, and the ability to quickly change the code without changing tables, coding and decoding.Change the code is implemented using the substitution, and the choice of codes is very large.The number of possible codes is 20! (approximately equal to 2.4*10 18 ) has at length codeword of 20.